Changeset 7401

code/trunk

Property svn:mergeinfo changed

merged: 7290-7292,7296-7300,7302-7304,7306-7312,7315-7318,7323,7325,7327,7331-7332,7334-7335,7345-7347,7352-7353,7356-7357,7361,7363-7367,7371-7375,7388

code/trunk/cmake/tools/TargetUtilities.cmake

r7170	r7401
209	209	)
210	210	ADD_MODULE(${_target_name})
	211	# Ensure that the main program depends on the module
	212	SET(ORXONOX_MODULES ${ORXONOX_MODULES} ${_target_name} CACHE STRING "" FORCE)
211	213	ENDIF()
212	214

code/trunk/doc/api/CMakeLists.txt

-                      r6417
+                      r7401
   #ENDIF (NOT DVIPS_CONVERTER)
+  SET(INTERNAL_DOCFILE ${CMAKE_CURRENT_BINARY_DIR}/Internal.dox)
+  IF(WIN32)
+    SET(_working_dir ${RUNTIME_LIBRARY_DIRECTORY})
+  ELSE()
+    SET(_working_dir ${CMAKE_CURRENT_BINARY_DIR})
+  ENDIF()
+  ADD_CUSTOM_COMMAND(
+    OUTPUT ${INTERNAL_DOCFILE}
+    COMMAND orxonox-main
+    ARGS --noIOConsole --generateDoc ${INTERNAL_DOCFILE}
+    WORKING_DIRECTORY ${_working_dir}
+    COMMENT "Generating additional Doxygen documentation from Orxonox executable"
+  )
+  ADD_CUSTOM_TARGET(doc_internal DEPENDS ${INTERNAL_DOCFILE})
+  IF (NOT EXISTS ${INTERNAL_DOCFILE})
+    FILE(WRITE ${INTERNAL_DOCFILE} "// empty...")
+  ENDIF()
+  # Take care of most of the conditional compilation problems
+  # (Doxygen requires separate input for that)
+  IF(WIN32)
+    SET(DOXY_PLATFORM_DEF "ORXONOX_PLATFORM_WINDOWS")
+  ELSEIF(APPLE)
+    SET(DOXY_PLATFORM_DEF "ORXONOX_PLATFORM_APPLE ORXONOX_PLATFORM_UNIX")
+  ELSE()
+    SET(DOXY_PLATFORM_DEF "ORXONOX_PLATFORM_LINUX ORXONOX_PLATFORM_UNIX")
+  ENDIF()
+  IF(MSVC)
+    SET(DOXY_COMPILER_DEF "ORXONOX_COMPILER_MSVC")
+  ELSE()
+    SET(DOXY_COMPILER_DEF "ORXONOX_COMPILER_GCC")
+  ENDIF()
   IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/doxy.config.in)
-    CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/doxy.config.in ${CMAKE_CURRENT_BINARY_DIR}/doxy.config @ONLY)
     # use (configured) doxy.config from (out of place) BUILD tree:
     SET(DOXY_CONFIG ${CMAKE_CURRENT_BINARY_DIR}/doxy.config)
     SET(DOXY_LOGFILE ${CMAKE_CURRENT_BINARY_DIR}/doxy.log)
+    CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/doxy.config.in ${CMAKE_CURRENT_BINARY_DIR}/doxy.config @ONLY)
   ELSE()
     MESSAGE(FATAL_ERROR "Warning: Could not find dox.config.in in the root directory.")

code/trunk/doc/api/doxy.config.in

-                      r6085
+                      r7401
 # Doxyfile 1.4.5
+# Doxyfile 1.6.3
 # This file describes the settings to be used by the documentation system
 …
 #---------------------------------------------------------------------------
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+DOXYFILE_ENCODING      = UTF-8
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
 # by quotes) that should identify the project.
 PROJECT_NAME           = "@PROJECT_NAME@"
 # The PROJECT_NUMBER tag can be used to enter a project or revision number.
 # This could be handy for archiving the generated documentation or
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
 # if some version control system is used.
 PROJECT_NUMBER         = "@ORXONOX_VERSION@ Codename: @ORXONOX_VERSION_NAME@"
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
 # base path where the generated documentation will be put.
 # If a relative path is entered, it will be relative to the location
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
 # where doxygen was started. If left blank the current directory will be used.
 OUTPUT_DIRECTORY       = @DOXY_OUTPUT_DIR@
 # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
 # 4096 sub-directories (in 2 levels) under the output directory of each output
 # format and will distribute the generated files over these directories.
 # Enabling this option can be useful when feeding doxygen a huge amount of
 # source files, where putting all generated files in the same directory would
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
 # otherwise cause performance problems for the file system.
 CREATE_SUBDIRS         = NO
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish,
+# Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese,
+# Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian,
+# Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish,
+# Swedish, and Ukrainian.
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak,
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
 OUTPUT_LANGUAGE        = English
 # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
 # include brief member descriptions after the members that are listed in
 # the file and class documentation (similar to JavaDoc).
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
 # Set to NO to disable this.
 BRIEF_MEMBER_DESC      = YES
 # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
 # the brief description of a member or function before the detailed description.
 # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
 # brief descriptions will be completely suppressed.
 REPEAT_BRIEF           = YES
 # This tag implements a quasi-intelligent brief description abbreviator
 # that is used to form the text in various listings. Each string
 # in this list, if found as the leading text of the brief description, will be
 # stripped from the text and the result after processing the whole list, is
 # used as the annotated text. Otherwise, the brief description is used as-is.
 # If left blank, the following values are used ("$name" is automatically
 # replaced with the name of the entity): "The $name class" "The $name widget"
 # "The $name file" "is" "provides" "specifies" "contains"
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
 # "represents" "a" "an" "the"
 …
                          the
 # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
 # Doxygen will generate a detailed section even if there is only a brief
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
 # description.
 ALWAYS_DETAILED_SEC    = NO
 # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
 # inherited members of a class in the documentation of that class as if those
 # members were ordinary class members. Constructors, destructors and assignment
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
 # operators of the base classes will not be shown.
 INLINE_INHERITED_MEMB  = NO
 # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
 # path before files name in the file list and in the header files. If set
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
 # to NO the shortest path that makes the file name unique will be used.
 FULL_PATH_NAMES        = YES
 # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
 # can be used to strip a user-defined part of the path. Stripping is
 # only done if one of the specified strings matches the left-hand part of
 # the path. The tag can be used to show relative paths in the file list.
 # If left blank the directory from which doxygen is run is used as the
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
 # path to strip.
 STRIP_FROM_PATH        = @CMAKE_SOURCE_DIR@
 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
 # the path mentioned in the documentation of a class, which tells
 # the reader which header file to include in order to use a class.
 # If left blank only the name of the header file containing the class
 # definition is used. Otherwise one should specify the include paths that
+STRIP_FROM_PATH        = @CMAKE_SOURCE_DIR@/src \
+                         @CMAKE_BINARY_DIR@/src
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
 # are normally passed to the compiler using the -I flag.
 STRIP_FROM_INC_PATH    = @CMAKE_SOURCE_DIR@
 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
 # (but less readable) file names. This can be useful is your file systems
+STRIP_FROM_INC_PATH    = @DOXYGEN_INCLUDE_DIRECTORIES@
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful is your file systems
 # doesn't support long names like on DOS, Mac, or CD-ROM.
 SHORT_NAMES            = NO
 # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
 # will interpret the first line (until the first dot) of a JavaDoc-style
 # comment as the brief description. If set to NO, the JavaDoc
 # comments will behave just like the Qt-style comments (thus requiring an
 # explicit @brief command for a brief description.
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
 JAVADOC_AUTOBRIEF      = YES
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+QT_AUTOBRIEF           = NO
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
 # description. Set this tag to YES if you prefer the old behaviour instead.
 MULTILINE_CPP_IS_BRIEF = NO
+# If the DETAILS_AT_TOP tag is set to YES then Doxygen
+# will output the detailed description near the top, like JavaDoc.
+# If set to NO, the detailed description appears after the member
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+INHERIT_DOCS           = YES
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+SEPARATE_MEMBER_PAGES  = NO
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+TAB_SIZE               = 4
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+ALIASES                =
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+OPTIMIZE_OUTPUT_FOR_C  = NO
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+OPTIMIZE_OUTPUT_JAVA   = NO
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+OPTIMIZE_FOR_FORTRAN   = NO
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+OPTIMIZE_OUTPUT_VHDL   = NO
+# Doxygen selects the parser to use depending on the extension of the files it parses.
+# With this tag you can assign which parser to use for a given extension.
+# Doxygen has a built-in mapping, but you can override or extend it using this tag.
+# The format is ext=language, where ext is a file extension, and language is one of
+# the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP,
+# Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat
+# .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C. Note that for custom extensions you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+EXTENSION_MAPPING      =
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+BUILTIN_STL_SUPPORT    = YES
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+CPP_CLI_SUPPORT        = NO
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+SIP_SUPPORT            = NO
+# For Microsoft's IDL there are propget and propput attributes to indicate getter
+# and setter methods for a property. Setting this option to YES (the default)
+# will make doxygen to replace the get and set methods by a property in the
+# documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+IDL_PROPERTY_SUPPORT   = YES
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+DISTRIBUTE_GROUP_DOC   = NO
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+SUBGROUPING            = YES
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+TYPEDEF_HIDES_STRUCT   = NO
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
+# determine which symbols to keep in memory and which to flush to disk.
+# When the cache is full, less often used symbols will be written to disk.
+# For small to medium size projects (<1000 input files) the default value is
+# probably good enough. For larger projects a too small cache size can cause
+# doxygen to be busy swapping symbols to and from disk most of the time
+# causing a significant performance penality.
+# If the system has enough physical memory increasing the cache will improve the
+# performance by keeping more symbols in memory. Note that the value works on
+# a logarithmic scale so increasing the size by one will rougly double the
+# memory usage. The cache size is given by this formula:
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols
+SYMBOL_CACHE_SIZE      = 0
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+EXTRACT_ALL            = YES
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+EXTRACT_PRIVATE        = YES
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+EXTRACT_STATIC         = YES
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+EXTRACT_LOCAL_CLASSES  = YES
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+EXTRACT_LOCAL_METHODS  = NO
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespace are hidden.
+EXTRACT_ANON_NSPACES   = NO
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+HIDE_UNDOC_MEMBERS     = NO
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+HIDE_UNDOC_CLASSES     = NO
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
 # documentation.
+DETAILS_AT_TOP         = NO
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+INHERIT_DOCS           = YES
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+SEPARATE_MEMBER_PAGES  = NO
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+TAB_SIZE               = 4
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+ALIASES                =
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+OPTIMIZE_OUTPUT_FOR_C  = NO
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for Java.
+# For instance, namespaces will be presented as packages, qualified scopes
+# will look different, etc.
+OPTIMIZE_OUTPUT_JAVA   = NO
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want to
+# include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+BUILTIN_STL_SUPPORT    = NO
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+DISTRIBUTE_GROUP_DOC   = NO
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+SUBGROUPING            = YES
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+EXTRACT_ALL            = YES
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+EXTRACT_PRIVATE        = YES
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+EXTRACT_STATIC         = YES
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+EXTRACT_LOCAL_CLASSES  = YES
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+EXTRACT_LOCAL_METHODS  = NO
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+HIDE_UNDOC_MEMBERS     = NO
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+HIDE_UNDOC_CLASSES     = NO
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+HIDE_FRIEND_COMPOUNDS  = NO
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+HIDE_IN_BODY_DOCS      = NO
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+INTERNAL_DOCS          = NO
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+CASE_SENSE_NAMES       = NO
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+HIDE_SCOPE_NAMES       = NO
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+SHOW_INCLUDE_FILES     = YES
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+FORCE_LOCAL_INCLUDES   = NO
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+INLINE_INFO            = YES
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+SORT_MEMBER_DOCS       = YES
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+SORT_BRIEF_DOCS        = YES
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the (brief and detailed) documentation of class members so that constructors and destructors are listed first. If set to NO (the default) the constructors will appear in the respective orders defined by SORT_MEMBER_DOCS and SORT_BRIEF_DOCS. This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+SORT_MEMBERS_CTORS_1ST = YES
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+SORT_GROUP_NAMES       = NO
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+SORT_BY_SCOPE_NAME     = YES
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+GENERATE_TODOLIST      = YES
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+GENERATE_TESTLIST      = YES
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+GENERATE_BUGLIST       = YES
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+GENERATE_DEPRECATEDLIST= YES
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+ENABLED_SECTIONS       =
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or define consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and defines in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+MAX_INITIALIZER_LINES  = 30
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+SHOW_USED_FILES        = YES
+# If the sources in your project are distributed over multiple directories
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
+# in the documentation. The default is NO.
+SHOW_DIRECTORIES       = YES
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+SHOW_FILES             = YES
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page.
+# This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+SHOW_NAMESPACES        = YES
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+FILE_VERSION_FILTER    =
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by
+# doxygen. The layout file controls the global structure of the generated output files
+# in an output format independent way. The create the layout file that represents
+# doxygen's defaults, run doxygen with the -l option. You can optionally specify a
+# file name after the option, if omitted DoxygenLayout.xml will be used as the name
+# of the layout file.
+LAYOUT_FILE            =
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+QUIET                  = NO
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+WARNINGS               = YES
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+WARN_IF_UNDOCUMENTED   = YES
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+WARN_IF_DOC_ERROR      = YES
+# This WARN_NO_PARAMDOC option can be abled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
 # documentation.
-HIDE_FRIEND_COMPOUNDS  = NO
-# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
-# documentation blocks found inside the body of a function.
-# If set to NO (the default) these blocks will be appended to the
-# function's detailed documentation block.
-HIDE_IN_BODY_DOCS      = NO
-# The INTERNAL_DOCS tag determines if documentation
-# that is typed after a \internal command is included. If the tag is set
-# to NO (the default) then the documentation will be excluded.
-# Set it to YES to include the internal documentation.
-INTERNAL_DOCS          = NO
-# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
-# file names in lower-case letters. If set to YES upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
-CASE_SENSE_NAMES       = YES
-# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
-# will show members with their full class and namespace scopes in the
-# documentation. If set to YES the scope will be hidden.
-HIDE_SCOPE_NAMES       = NO
-# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
-# will put a list of the files that are included by a file in the documentation
-# of that file.
-SHOW_INCLUDE_FILES     = YES
-# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
-# is inserted in the documentation for inline members.
-INLINE_INFO            = YES
-# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
-# will sort the (detailed) documentation of file and class members
-# alphabetically by member name. If set to NO the members will appear in
-# declaration order.
-SORT_MEMBER_DOCS       = YES
-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
-# brief documentation of file, namespace and class members alphabetically
-# by member name. If set to NO (the default) the members will appear in
-# declaration order.
-SORT_BRIEF_DOCS        = YES
-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
-# sorted by fully-qualified names, including namespaces. If set to
-# NO (the default), the class list will be sorted only by class name,
-# not including the namespace part.
-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
-# Note: This option applies only to the class list, not to the
-# alphabetical list.
-SORT_BY_SCOPE_NAME     = NO
-# The GENERATE_TODOLIST tag can be used to enable (YES) or
-# disable (NO) the todo list. This list is created by putting \todo
-# commands in the documentation.
-GENERATE_TODOLIST      = YES
-# The GENERATE_TESTLIST tag can be used to enable (YES) or
-# disable (NO) the test list. This list is created by putting \test
-# commands in the documentation.
-GENERATE_TESTLIST      = YES
-# The GENERATE_BUGLIST tag can be used to enable (YES) or
-# disable (NO) the bug list. This list is created by putting \bug
-# commands in the documentation.
-GENERATE_BUGLIST       = YES
-# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
-# disable (NO) the deprecated list. This list is created by putting
-# \deprecated commands in the documentation.
-GENERATE_DEPRECATEDLIST= YES
-# The ENABLED_SECTIONS tag can be used to enable conditional
-# documentation sections, marked by \if sectionname ... \endif.
-ENABLED_SECTIONS       = YES
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
-# the initial value of a variable or define consists of for it to appear in
-# the documentation. If the initializer consists of more lines than specified
-# here it will be hidden. Use a value of 0 to hide initializers completely.
-# The appearance of the initializer of individual variables and defines in the
-# documentation can be controlled using \showinitializer or \hideinitializer
-# command in the documentation regardless of this setting.
-MAX_INITIALIZER_LINES  = 30
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
-# at the bottom of the documentation of classes and structs. If set to YES the
-# list will mention the files that were used to generate the documentation.
-SHOW_USED_FILES        = YES
-# If the sources in your project are distributed over multiple directories
-# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
-# in the documentation. The default is YES.
-SHOW_DIRECTORIES       = YES
-# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
-# This will remove the Files entry from the Quick Index and from the Folder
-# Tree View (if specified). The default is YES.
-SHOW_FILES             = YES
-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
-# Namespaces page. This will remove the Namespaces entry from the Quick Index
-# and from the Folder Tree View (if specified). The default is YES.
-SHOW_NAMESPACES        = YES
-# The FILE_VERSION_FILTER tag can be used to specify a program or script that
-# doxygen should invoke to get the current version for each file (typically from the
-# version control system). Doxygen will invoke the program by executing (via
-# popen()) the command <command> <input-file>, where <command> is the value of
-# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
-# provided by doxygen. Whatever the program writes to standard output
-# is used as the file version. See the manual for examples.
-FILE_VERSION_FILTER    =
-#---------------------------------------------------------------------------
-# configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-# The QUIET tag can be used to turn on/off the messages that are generated
-# by doxygen. Possible values are YES and NO. If left blank NO is used.
-QUIET                  = NO
-# The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated by doxygen. Possible values are YES and NO. If left blank
-# NO is used.
-WARNINGS               = YES
-# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
-# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
-# automatically be disabled.
-WARN_IF_UNDOCUMENTED   = YES
-# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some
-# parameters in a documented function, or documenting parameters that
-# don't exist or using markup commands wrongly.
-WARN_IF_DOC_ERROR      = YES
-# This WARN_NO_PARAMDOC option can be abled to get warnings for
-# functions that are documented, but have no documentation for their parameters
-# or return value. If set to NO (the default) doxygen will only warn about
-# wrong or incomplete parameter documentation, but not about the absence of
-# documentation.
 WARN_NO_PARAMDOC       = NO
 # The WARN_FORMAT tag determines the format of the warning messages that
 # doxygen can produce. The string should contain the $file, $line, and $text
 # tags, which will be replaced by the file and line number from which the
 # warning originated and the warning text. Optionally the format may contain
 # $version, which will be replaced by the version of the file (if it could
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
 # be obtained via FILE_VERSION_FILTER)
 WARN_FORMAT            = @DOXY_WARN_FORMAT@
 # The WARN_LOGFILE tag can be used to specify a file to which warning
 # and error messages should be written. If left blank the output is written
+# The WARN_LOGFILE tag can be used to specify a file to which warning
+# and error messages should be written. If left blank the output is written
 # to stderr.
 …
 #---------------------------------------------------------------------------
 # The INPUT tag can be used to specify the files and/or directories that contain
 # documented source files. You may enter file names like "myfile.cpp" or
 # directories like "/usr/src/myproject". Separate the files or directories
+# The INPUT tag can be used to specify the files and/or directories that contain
+# documented source files. You may enter file names like "myfile.cpp" or
+# directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 …
                          @CMAKE_CURRENT_SOURCE_DIR@ \
                          @CMAKE_BINARY_DIR@/src/OrxonoxConfig.h \
+                         @CMAKE_BINARY_DIR@/src/SpecialConfig.h
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py
+                         @CMAKE_BINARY_DIR@/src/SpecialConfig.h \
+                         @INTERNAL_DOCFILE@
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+INPUT_ENCODING         = UTF-8
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
 FILE_PATTERNS          = *.cpp \
 …
                          *.dox
 # The RECURSIVE tag can be used to turn specify whether or not subdirectories
 # should be searched for input files as well. Possible values are YES and NO.
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
 # If left blank NO is used.
 RECURSIVE              = YES
 # The EXCLUDE tag can be used to specify files and/or directories that should
 # excluded from the INPUT source files. This way you can easily exclude a
+# The EXCLUDE tag can be used to specify files and/or directories that should
+# excluded from the INPUT source files. This way you can easily exclude a
 # subdirectory from a directory tree whose root is specified with the INPUT tag.
+EXCLUDE                = @CMAKE_SOURCE_DIR@/src/external/bullet/
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix filesystem feature) are excluded
+EXCLUDE                = @CMAKE_SOURCE_DIR@/src/external/bullet/ \
+                         @CMAKE_SOURCE_DIR@/src/external/cpptcl/ \
+                         @CMAKE_SOURCE_DIR@/src/external/ceguilua/ceguilua-0.5.0 \
+                         @CMAKE_SOURCE_DIR@/src/external/ceguilua/ceguilua-0.6.0 \
+                         @CMAKE_SOURCE_DIR@/src/external/ceguilua/ceguilua-0.6.1 \
+                         @CMAKE_SOURCE_DIR@/src/libraries/core/command/IOConsoleWindows.h \
+                         @CMAKE_SOURCE_DIR@/src/libraries/core/command/IOConsoleWindows.cc \
+                         @CMAKE_SOURCE_DIR@/src/libraries/tools/bsp \
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix filesystem feature) are excluded
 # from the input.
 EXCLUDE_SYMLINKS       = NO
 # If the value of the INPUT tag contains directories, you can use the
 # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
 # certain files from those directories. Note that the wildcards are matched
 # against the file with absolute path, so to exclude all test directories
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
 # for example use the pattern */test/*
 EXCLUDE_PATTERNS       = */.svn/*
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+EXCLUDE_SYMBOLS        = orxonox::detail
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
 # the \include command).
 EXAMPLE_PATH           = @CMAKE_CURRENT_SOURCE_DIR@/examples/
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
 # and *.h) to filter out the source-files in the directories. If left
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
 # blank all files are included.
 …
                          INSTALL DEPENDENCIES CHANGELOG LICENSE LGPL
 # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
 # searched for input files to be used with the \include or \dontinclude
 # commands irrespective of the value of the RECURSIVE tag.
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
 # Possible values are YES and NO. If left blank NO is used.
 EXAMPLE_RECURSIVE      = YES
 # The IMAGE_PATH tag can be used to specify one or more files or
 # directories that contain image that are included in the documentation (see
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
 # the \image command).
 IMAGE_PATH             = @CMAKE_CURRENT_SOURCE_DIR@/images/
 # The INPUT_FILTER tag can be used to specify a program that doxygen should
 # invoke to filter for each input file. Doxygen will invoke the filter program
 # by executing (via popen()) the command <filter> <input-file>, where <filter>
 # is the value of the INPUT_FILTER tag, and <input-file> is the name of an
 # input file. Doxygen will then use the output that the filter program writes
 # to standard output.  If FILTER_PATTERNS is specified, this tag will be
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output.
+# If FILTER_PATTERNS is specified, this tag will be
 # ignored.
+INPUT_FILTER           =
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis.  Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match.  The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
+INPUT_FILTER           =
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis.
+# Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match.
+# The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
 # is applied to all files.
 FILTER_PATTERNS        =
 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
 # INPUT_FILTER) will be used to filter the input files when producing source
+FILTER_PATTERNS        =
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
 # files to browse (i.e. when SOURCE_BROWSER is set to YES).
 …
 #---------------------------------------------------------------------------
 # If the SOURCE_BROWSER tag is set to YES then a list of source files will
 # be generated. Documented entities will be cross-referenced with these sources.
 # Note: To get rid of all source code in the generated output, make sure also
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
 # VERBATIM_HEADERS is set to NO.
 SOURCE_BROWSER         = NO
 # Setting the INLINE_SOURCES tag to YES will include the body
+# Setting the INLINE_SOURCES tag to YES will include the body
 # of functions and classes directly in the documentation.
 INLINE_SOURCES         = NO
 # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
 # doxygen to hide any special comment blocks from generated source code
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
 # fragments. Normal C and C++ comments will always remain visible.
 STRIP_CODE_COMMENTS    = YES
 # If the REFERENCED_BY_RELATION tag is set to YES (the default)
 # then for each documented function all documented
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
 # functions referencing it will be listed.
 REFERENCED_BY_RELATION = YES
 # If the REFERENCES_RELATION tag is set to YES (the default)
 # then for each documented function all documented entities
+REFERENCED_BY_RELATION = NO
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
 # called/used by that function will be listed.
+REFERENCES_RELATION    = YES
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+REFERENCES_RELATION    = NO
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code.
+# Otherwise they will link to the documentation.
+REFERENCES_LINK_SOURCE = YES
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
 # will need version 4.8.6 or higher.
 USE_HTAGS              = NO
 # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
 # will generate a verbatim copy of the header file for each class for
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
 # which an include is specified. Set to NO to disable this.
 …
 #---------------------------------------------------------------------------
 # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
 # of all compounds will be generated. Enable this if the project
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
 # contains a lot of classes, structs, unions or interfaces.
 ALPHABETICAL_INDEX     = YES
 # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
 # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
 # in which this list will be split (can be a number in the range [1..20])
 COLS_IN_ALPHA_INDEX    = 2
 # In case all classes in a project start with a common prefix, all
 # classes will be put under the same header in the alphabetical index.
 # The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
 # should be ignored while generating the index headers.
 IGNORE_PREFIX          =
+IGNORE_PREFIX          =
 #---------------------------------------------------------------------------
 …
 #---------------------------------------------------------------------------
 # If the GENERATE_HTML tag is set to YES (the default) Doxygen will
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
 # generate HTML output.
 GENERATE_HTML          = YES
 # The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `html' will be used as the default path.
 HTML_OUTPUT            = html
 # The HTML_FILE_EXTENSION tag can be used to specify the file extension for
 # each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
 # doxygen will generate files with .html extension.
 HTML_FILE_EXTENSION    = .html
 # The HTML_HEADER tag can be used to specify a personal HTML header for
 # each generated HTML page. If it is left blank doxygen will generate a
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
 # standard header.
+HTML_HEADER            =
 # The HTML_FOOTER tag can be used to specify a personal HTML footer for
 # each generated HTML page. If it is left blank doxygen will generate a
+HTML_HEADER            =
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
 # standard footer.
 HTML_FOOTER            =
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading
 # style sheet that is used by each HTML page. It can be used to
 # fine-tune the look of the HTML output. If the tag is left blank doxygen
 # will generate a default style sheet. Note that doxygen will try to copy
 # the style sheet file to the HTML output directory, so don't put your own
+HTML_FOOTER            =
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
 # stylesheet in the HTML output directory as well, or it will be erased!
+HTML_STYLESHEET        =
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
+# files or namespaces will be aligned in HTML using tables. If set to
+HTML_STYLESHEET        =
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+HTML_TIMESTAMP         = YES
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
+# files or namespaces will be aligned in HTML using tables. If set to
 # NO a bullet list will be used.
 HTML_ALIGN_MEMBERS     = YES
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compressed HTML help file (.chm)
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+HTML_DYNAMIC_SECTIONS  = NO
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information.
+GENERATE_DOCSET        = NO
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
 # of the generated HTML documentation.
 GENERATE_HTMLHELP      = YES
 # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
 # be used to specify the file name of the resulting .chm file. You
 # can add a path in front of the file if the result should not be
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
 # written to the html output directory.
 CHM_FILE               =
 # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
 # be used to specify the location (absolute path including file name) of
 # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+CHM_FILE               =
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
 # the HTML help compiler on the generated index.hhp.
 HHC_LOCATION           =
 # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
 # controls if a separate .chi index file is generated (YES) or that
+HHC_LOCATION           =
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
 # it should be included in the master .chm file (NO).
 GENERATE_CHI           = NO
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+CHM_INDEX_ENCODING     =
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
 # normal table of contents (NO) in the .chm file.
 BINARY_TOC             = NO
 # The TOC_EXPAND flag can be set to YES to add extra items for group members
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
 # to the contents of the HTML help documentation and to the tree view.
 TOC_EXPAND             = NO
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
+# top of each HTML page. The value NO (the default) enables the index and
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER
+# are set, an additional index file will be generated that can be used as input for
+# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated
+# HTML documentation.
+GENERATE_QHP           = NO
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+QCH_FILE               =
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+QHP_NAMESPACE          = org.doxygen.Project
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+QHP_VIRTUAL_FOLDER     = doc
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add.
+# For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+QHP_CUST_FILTER_NAME   =
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">Qt Help Project / Custom Filters</a>.
+QHP_CUST_FILTER_ATTRS  =
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's
+# filter section matches.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">Qt Help Project / Filter Attributes</a>.
+QHP_SECT_FILTER_ATTRS  =
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+QHG_LOCATION           =
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+#  will be generated, which together with the HTML files, form an Eclipse help
+#  plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before the help appears.
+GENERATE_ECLIPSEHELP   = NO
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+ECLIPSE_DOC_ID         = org.doxygen.Project
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
+# top of each HTML page. The value NO (the default) enables the index and
 # the value YES disables it.
 DISABLE_INDEX          = NO
 # This tag can be used to set the number of enum values (range [1..20])
+# This tag can be used to set the number of enum values (range [1..20])
 # that doxygen will group on one line in the generated HTML documentation.
 ENUM_VALUES_PER_LINE   = 4
+# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
+# generated containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,
+# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are
+# probably better off using the HTML help feature.
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to YES, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
+# Windows users are probably better off using the HTML help feature.
 GENERATE_TREEVIEW      = NO
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
+# and Class Hierarchy pages using a tree view instead of an ordered list.
+USE_INLINE_TREES       = NO
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
 # is shown.
 TREEVIEW_WIDTH         = 250
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+FORMULA_FONTSIZE       = 10
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+SEARCHENGINE           = YES
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be implemented using a PHP enabled web server instead of at the web client using Javascript. Doxygen will generate the search PHP script and index
+# file to put on the web server. The advantage of the server based approach is that it scales better to large projects and allows full text search. The disadvances is that it is more difficult to setup
+# and does not have live searching capabilities.
+SERVER_BASED_SEARCH    = NO
 #---------------------------------------------------------------------------
 # configuration options related to the LaTeX output
 #---------------------------------------------------------------------------
 # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
 # generate Latex output.
 GENERATE_LATEX         = NO
 # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `latex' will be used as the default path.
 LATEX_OUTPUT           = latex
 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
 # invoked. If left blank `latex' will be used as the default command name.
+#LATEX_CMD_NAME         = latex
+LATEX_CMD_NAME          = @LATEX_COMPILER@
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
+LATEX_CMD_NAME         = @LATEX_COMPILER@
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
 # default command name.
-#MAKEINDEX_CMD_NAME     = makeindex
 MAKEINDEX_CMD_NAME     = @MAKEINDEX_COMPILER@
 # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
 # LaTeX documents. This may be useful for small projects and may help to
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
 # save some trees in general.
 COMPACT_LATEX          = NO
 # The PAPER_TYPE tag can be used to set the paper type that is used
 # by the printer. Possible values are: a4, a4wide, letter, legal and
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, a4wide, letter, legal and
 # executive. If left blank a4wide will be used.
 PAPER_TYPE             = a4wide
 # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
 # packages that should be included in the LaTeX output.
 EXTRA_PACKAGES         =
 # The LATEX_HEADER tag can be used to specify a personal LaTeX header for
 # the generated latex document. The header should contain everything until
 # the first chapter. If it is left blank doxygen will generate a
+EXTRA_PACKAGES         =
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
 # standard header. Notice: only use this tag if you know what you are doing!
 LATEX_HEADER           =
 # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
 # is prepared for conversion to pdf (using ps2pdf). The pdf file will
 # contain links (just like the HTML output) instead of page references
+LATEX_HEADER           =
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
 # This makes the output suitable for online browsing using a pdf viewer.
 PDF_HYPERLINKS         = YES
 # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
 # plain latex in the generated Makefile. Set this option to YES to get a
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
 # higher quality PDF documentation.
 USE_PDFLATEX           = YES
 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
 # command to the generated LaTeX files. This will instruct LaTeX to keep
 # running if errors occur, instead of asking the user for help.
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
+# command to the generated LaTeX files. This will instruct LaTeX to keep
+# running if errors occur, instead of asking the user for help.
 # This option is also used when generating formulas in HTML.
 LATEX_BATCHMODE        = YES
 # If LATEX_HIDE_INDICES is set to YES then doxygen will not
 # include the index chapters (such as File Index, Compound Index, etc.)
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
 # in the output.
 LATEX_HIDE_INDICES     = NO
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include source code with syntax highlighting in the LaTeX output. Note that which sources are shown also depends on other settings such as SOURCE_BROWSER.
+LATEX_SOURCE_CODE      = NO
 #---------------------------------------------------------------------------
 # configuration options related to the RTF output
 #---------------------------------------------------------------------------
 # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
 # The RTF output is optimized for Word 97 and may not look very pretty with
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
 # other RTF readers or editors.
 GENERATE_RTF           = NO
 # The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `rtf' will be used as the default path.
 RTF_OUTPUT             = rtf
 # If the COMPACT_RTF tag is set to YES Doxygen generates more compact
 # RTF documents. This may be useful for small projects and may help to
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
 # save some trees in general.
 COMPACT_RTF            = NO
 # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
 # will contain hyperlink fields. The RTF file will
 # contain links (just like the HTML output) instead of page references.
 # This makes the output suitable for online browsing using WORD or other
 # programs which support those fields.
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
 # Note: wordpad (write) and others do not support links.
 RTF_HYPERLINKS         = NO
 # Load stylesheet definitions from file. Syntax is similar to doxygen's
 # config file, i.e. a series of assignments. You only have to provide
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
 # replacements, missing definitions are set to their default value.
 RTF_STYLESHEET_FILE    =
 # Set optional variables used in the generation of an rtf document.
+RTF_STYLESHEET_FILE    =
+# Set optional variables used in the generation of an rtf document.
 # Syntax is similar to doxygen's config file.
 RTF_EXTENSIONS_FILE    =
+RTF_EXTENSIONS_FILE    =
 #---------------------------------------------------------------------------
 …
 #---------------------------------------------------------------------------
 # If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
 # generate man pages
 GENERATE_MAN           = NO
 # The MAN_OUTPUT tag is used to specify where the man pages will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `man' will be used as the default path.
 MAN_OUTPUT             = man
 # The MAN_EXTENSION tag determines the extension that is added to
+# The MAN_EXTENSION tag determines the extension that is added to
 # the generated man pages (default is the subroutine's section .3)
 MAN_EXTENSION          = .3
 # If the MAN_LINKS tag is set to YES and Doxygen generates man output,
 # then it will generate one additional man file for each entity
 # documented in the real man page(s). These additional files
 # only source the real man page, but without them the man command
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
 # would be unable to find the correct page. The default is NO.
 …
 #---------------------------------------------------------------------------
 # If the GENERATE_XML tag is set to YES Doxygen will
 # generate an XML file that captures the structure of
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
 # the code including all documentation.
 GENERATE_XML           = NO
 # The XML_OUTPUT tag is used to specify where the XML pages will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `xml' will be used as the default path.
 XML_OUTPUT             = xml
 # The XML_SCHEMA tag can be used to specify an XML schema,
 # which can be used by a validating XML parser to check the
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
 # syntax of the XML files.
 XML_SCHEMA             =
 # The XML_DTD tag can be used to specify an XML DTD,
 # which can be used by a validating XML parser to check the
+XML_SCHEMA             =
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
 # syntax of the XML files.
 XML_DTD                =
 # If the XML_PROGRAMLISTING tag is set to YES Doxygen will
 # dump the program listings (including syntax highlighting
 # and cross-referencing information) to the XML output. Note that
+XML_DTD                =
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
 # enabling this will significantly increase the size of the XML output.
 …
 #---------------------------------------------------------------------------
 # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
 # generate an AutoGen Definitions (see autogen.sf.net) file
 # that captures the structure of the code including all
 # documentation. Note that this feature is still experimental
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
 # and incomplete at the moment.
 …
 #---------------------------------------------------------------------------
 # If the GENERATE_PERLMOD tag is set to YES Doxygen will
 # generate a Perl module file that captures the structure of
 # the code including all documentation. Note that this
 # feature is still experimental and incomplete at the
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
 # moment.
 GENERATE_PERLMOD       = NO
 # If the PERLMOD_LATEX tag is set to YES Doxygen will generate
 # the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
 # to generate PDF and DVI output from the Perl module output.
 PERLMOD_LATEX          = NO
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader.  This is useful
+# if you want to understand what is going on.  On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader.
+# This is useful
+# if you want to understand what is going on.
+# On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
 # and Perl will parse it just the same.
 PERLMOD_PRETTY         = YES
 # The names of the make variables in the generated doxyrules.make file
 # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
 # This is useful so different doxyrules.make files included by the same
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
 # Makefile don't overwrite each other's variables.
 PERLMOD_MAKEVAR_PREFIX =
 #---------------------------------------------------------------------------
 # Configuration options related to the preprocessor
 #---------------------------------------------------------------------------
 # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
 # evaluate all C-preprocessor directives found in the sources and include
+PERLMOD_MAKEVAR_PREFIX =
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
 # files.
 ENABLE_PREPROCESSING   = YES
 # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
 # names in the source code. If set to NO (the default) only conditional
 # compilation will be performed. Macro expansion can be done in a controlled
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
 # way by setting EXPAND_ONLY_PREDEF to YES.
 MACRO_EXPANSION        = YES
 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
 # then the macro expansion is limited to the macros specified with the
+MACRO_EXPANSION        = NO
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
 # PREDEFINED and EXPAND_AS_DEFINED tags.
 EXPAND_ONLY_PREDEF     = YES
 # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
 # in the INCLUDE_PATH (see below) will be search if a #include is found.
 SEARCH_INCLUDES        = YES
 # The INCLUDE_PATH tag can be used to specify one or more directories that
 # contain include files that are not input files but should be processed by
+SEARCH_INCLUDES        = NO
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
 # the preprocessor.
 INCLUDE_PATH           =
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
 # patterns (like *.h and *.hpp) to filter out the header-files in the
 # directories. If left blank, the patterns specified with FILE_PATTERNS will
+INCLUDE_PATH           = #@DOXYGEN_INCLUDE_DIRECTORIES@
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
 # be used.
 INCLUDE_FILE_PATTERNS  =
 # The PREDEFINED tag can be used to specify one or more macro names that
 # are defined before the preprocessor is started (similar to the -D option of
 # gcc). The argument of the tag is a list of macros of the form: name
 # or name=definition (no spaces). If the definition and the = are
 # omitted =1 is assumed. To prevent a macro definition from being
 # undefined via #undef or recursively expanded use the := operator
+INCLUDE_FILE_PATTERNS  =
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
 # instead of the = operator.
+PREDEFINED             = DOXYGEN_SHOULD_SKIP_THIS
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+PREDEFINED             = DOXYGEN_SHOULD_SKIP_THIS \
+                         @DOXY_PLATFORM_DEF@ \
+                         @DOXY_COMPILER_DEF@
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
 # Use the PREDEFINED tag if you want to use a different macro definition.
 EXPAND_AS_DEFINED      =
 # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
 # doxygen's preprocessor will remove all function-like macros that are alone
 # on a line, have an all uppercase name, and do not end with a semicolon. Such
 # function macros are typically used for boiler-plate code, and will confuse
+EXPAND_AS_DEFINED      =
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all function-like macros that are alone
+# on a line, have an all uppercase name, and do not end with a semicolon. Such
+# function macros are typically used for boiler-plate code, and will confuse
 # the parser if not removed.
 …
 #---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+# The TAGFILES option can be used to specify one or more tagfiles.
+# Optionally an initial location of the external documentation
+# can be added for each tagfile. The format of a tag file without
+# this location is as follows:
+#   TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+#   TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths or
+# URLs. If a location is present for each tag, the installdox tool
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+# The TAGFILES option can be used to specify one or more tagfiles.
+# Optionally an initial location of the external documentation
+# can be added for each tagfile. The format of a tag file without
+# this location is as follows:
+#
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+#
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths or
+# URLs. If a location is present for each tag, the installdox tool
 # does not have to be run to correct the links.
 # Note that each tag file must have a unique name
 # (where the name does NOT include the path)
 # If a tag file is not located in the directory in which doxygen
+# If a tag file is not located in the directory in which doxygen
 # is run, you must also specify the path to the tagfile here.
 TAGFILES               =
 # When a file name is specified after GENERATE_TAGFILE, doxygen will create
+TAGFILES               =
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
 # a tag file that is based on the input files it reads.
 GENERATE_TAGFILE       = @DOXY_OUTPUT_DIR@/html/@PROJECT_NAME@.TAGFILE
 # If the ALLEXTERNALS tag is set to YES all external classes will be listed
 # in the class index. If set to NO only the inherited external classes
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
 # will be listed.
 ALLEXTERNALS           = NO
 # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
 # in the modules index. If set to NO, only the current project's groups will
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
 # be listed.
 EXTERNAL_GROUPS        = YES
 # The PERL_PATH should be the absolute path and name of the perl script
+# The PERL_PATH should be the absolute path and name of the perl script
 # interpreter (i.e. the result of `which perl').
 …
 #---------------------------------------------------------------------------
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
 # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
 # or super classes. Setting the tag to NO turns the diagrams off. Note that
 # this option is superseded by the HAVE_DOT option below. This is only a
 # fallback. It is recommended to install and use dot, since it yields more
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option is superseded by the HAVE_DOT option below. This is only a
+# fallback. It is recommended to install and use dot, since it yields more
 # powerful graphs.
 CLASS_DIAGRAMS         = YES
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+MSCGEN_PATH            =
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
 # or is not a class.
 HIDE_UNDOC_RELATIONS   = YES
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
 # available from the path. This tool is part of Graphviz, a graph visualization
 # toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
 # have no effect if this option is set to NO (the default)
 HAVE_DOT               = NO
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# By default doxygen will write a font called FreeSans.ttf to the output
+# directory and reference it in all dot files that doxygen generates. This
+# font does not include all possible unicode characters however, so when you need
+# these (or just want a differently looking font) you can specify the font name
+# using DOT_FONTNAME. You need need to make sure dot is able to find the font,
+# which can be done by putting it in a standard location or by setting the
+# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
+# containing the font.
+DOT_FONTNAME           = FreeSans
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+DOT_FONTSIZE           = 10
+# By default doxygen will tell dot to use the output directory to look for the
+# FreeSans.ttf font (which doxygen will put there itself). If you specify a
+# different font using DOT_FONTNAME you can set the path where dot
+# can find it using this tag.
+DOT_FONTPATH           =
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
 # the CLASS_DIAGRAMS tag to NO.
 CLASS_GRAPH            = YES
 # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
 # will generate a graph for each documented class showing the direct and
 # indirect implementation dependencies (inheritance, containment, and
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
 # class references variables) of the class with other documented classes.
 COLLABORATION_GRAPH    = YES
 # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
 # will generate a graph for groups, showing the direct groups dependencies
 GROUP_GRAPHS           = YES
 # If the UML_LOOK tag is set to YES doxygen will generate inheritance and
 # collaboration diagrams in a style similar to the OMG's Unified Modeling
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
 # Language.
 UML_LOOK               = NO
 # If set to YES, the inheritance and collaboration graphs will show the
+# If set to YES, the inheritance and collaboration graphs will show the
 # relations between templates and their instances.
 TEMPLATE_RELATIONS     = NO
 # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
 # tags are set to YES then doxygen will generate a graph for each documented
 # file showing the direct and indirect include dependencies of the file with
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
 # other documented files.
 INCLUDE_GRAPH          = YES
 # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
 # HAVE_DOT tags are set to YES then doxygen will generate a graph for each
 # documented header file showing the documented files that directly or
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
 # indirectly include this file.
 INCLUDED_BY_GRAPH      = YES
 # If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will
 # generate a call dependency graph for every global function or class method.
 # Note that enabling this option will significantly increase the time of a run.
 # So in most cases it will be better to enable call graphs for selected
 # functions only using the \callgraph command.
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
 CALL_GRAPH             = NO
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+CALLER_GRAPH           = NO
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
 # will graphical hierarchy of all classes instead of a textual one.
 GRAPHICAL_HIERARCHY    = YES
 # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
 # then doxygen will show the dependencies a directory has on other directories
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
 # in a graphical way. The dependency relations are determined by the #include
 # relations between the files in the directories.
 …
 DIRECTORY_GRAPH        = YES
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
 # generated by dot. Possible values are png, jpg, or gif
 # If left blank png will be used.
 …
 DOT_IMAGE_FORMAT       = png
 # The tag DOT_PATH can be used to specify the path where the dot tool can be
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
 # found. If left blank, it is assumed the dot tool can be found in the path.
 DOT_PATH               = @DOXYGEN_DOT_EXECUTABLE_PATH@
 # The DOTFILE_DIRS tag can be used to specify one or more directories that
 # contain dot files that are included in the documentation (see the
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
 # \dotfile command).
 DOTFILE_DIRS           = @CMAKE_CURRENT_SOURCE_DIR@/dot
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that a graph may be further truncated if the graph's
+# image dimensions are not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH
+# and MAX_DOT_GRAPH_HEIGHT). If 0 is used for the depth value (the default),
+# the graph is not depth-constrained.
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+DOT_GRAPH_MAX_NODES    = 50
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
 MAX_DOT_GRAPH_DEPTH    = 1000
 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
 # background. This is disabled by default, which results in a white background.
 # Warning: Depending on the platform used, enabling this option may lead to
 # badly anti-aliased labels on the edges of a graph (i.e. they become hard to
 # read).
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
 DOT_TRANSPARENT        = NO
 # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
 # files in one run (i.e. multiple -o and -T options on the command line). This
 # makes dot run faster, but since only newer versions of dot (>1.8.10)
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
 # support this, this feature is disabled by default.
 DOT_MULTI_TARGETS      = NO
 # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
 # generate a legend page explaining the meaning of the various boxes and
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
 # arrows in the dot generated graphs.
 GENERATE_LEGEND        = YES
 # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
 # remove the intermediate dot files that are used to generate
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
 # the various graphs.
 DOT_CLEANUP            = YES
-#---------------------------------------------------------------------------
-# Configuration::additions related to the search engine
-#---------------------------------------------------------------------------
-# The SEARCHENGINE tag specifies whether or not a search engine should be
-# used. If set to NO the values of all tags below this one will be ignored.
-SEARCHENGINE           = YES

code/trunk/doc/api/main.dox

-                      r6417
+                      r7401
 /**
+@mainpage
+    Orxonox Doxygen Reference
+    @mainpage
+    @image html orxonox.jpg
+    This is the documentation of Orxonox. It contains descriptions of our classes and functions and
+    explains their usage with several examples and background information. Because Orxonox is so big,
+    we can't document all of our code - sorry for that! But we do your best to document the most
+    important parts of it, namely the @ref Core "core" and @ref Util "util" libraries, as well as the
+    central classes in the @ref Orxonox "orxonox" main library and some @ref Modules "modules".
+    To understand the connection between different classes in Orxonox, have a look at the
+    <a href="modules.html"><b>Modules section</b></a>. It contains a list of the most important topics
+    and groups files that contribute to the same feature.
 */

code/trunk/src/CMakeLists.txt

-                      r7224
+                      r7401
 ADD_SUBDIRECTORY(modules)
 ################ Executable ################
+################## Executable ###################
 INCLUDE_DIRECTORIES(
 …
   OUTPUT_NAME orxonox
+)
+# Main executable should depend on all modules
+ADD_DEPENDENCIES(orxonox-main ${ORXONOX_MODULES})
 # Get name to configure the run scripts
 …
   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)

code/trunk/src/OrxonoxConfig.h.in

-                      r5695
+                      r7401
  * 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

code/trunk/src/SpecialConfig.h.in

-                      r7380
+                      r7401
 #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
 …
 } }
+/**
+@def ORXONOX_USE_WINMAIN
+    Use main() or WinMain()?
+*/
+#cmakedefine ORXONOX_USE_WINMAIN
+#cmakedefine ORXONOX_USE_WINMAIN  ///< Using MSVC or XCode IDE
 #endif /* _SpecialConfig_H__ */

code/trunk/src/libraries/CMakeLists.txt

-                      r5929
+                      r7401
+ #
+INCLUDE_DIRECTORIES(
+  ${CMAKE_SOURCE_DIR}/src/external
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 ################ Sub Directories ################

code/trunk/src/libraries/core/BaseObject.cc

-                      r7284
+                      r7401
         @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)
 …
         @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)

code/trunk/src/libraries/core/BaseObject.h

-                      r7284
+                      r7401
 /**
+    @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.
 …
     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
+    {

code/trunk/src/libraries/core/ClassFactory.h

-                      r5929
+                      r7401
 /**
     @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.
 */
 …
     // ###       Factory       ###
     // ###########################
     //! Base-class of ClassFactory.
+    /// Base-class of ClassFactory.
     class _CoreExport Factory
+    {
 …
     // ###      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

code/trunk/src/libraries/core/ClassTreeMask.cc

-                      r7268
+                      r7401
 /**
     @file
     @brief Implementation of the ClassTreeMask, ClassTreeMaskNode and ClassTreeMaskIterator classes.
+    @brief Implementation of the ClassTreeMask, ClassTreeMaskNode, and ClassTreeMaskIterator classes.
 */
 …
     /**
         @brief Adds a new subnode to the list of subnodes.
-        @param subnode The new subnode
     */
     void ClassTreeMaskNode::addSubnode(ClassTreeMaskNode* subnode)
 …
     /**
         @brief Returns a pointer to the ClassTreeMaskNode whereon the iterator points.
-        @return The pointer to the node
     */
     ClassTreeMaskNode* ClassTreeMaskIterator::operator*() const
 …
     /**
         @brief Returns a pointer to the ClassTreeMaskNode whereon the iterator points.
-        @return The pointer to the node
     */
     ClassTreeMaskNode* ClassTreeMaskIterator::operator->() const
 …
     /**
         @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
 …
     /**
         @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
 …
     /**
         @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
 …
     /**
+        @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)

code/trunk/src/libraries/core/ClassTreeMask.h

-                      r7268
+                      r7401
 /**
     @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
 …
     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.
 */
 …
     // ###      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
 …
             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(); }
 …
             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
     };
 …
     // ###    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
 …
         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
 …
         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)
     };
 …
     // ###        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
 …
             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; }
 …
             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
     };
 …
     // ### 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
 …
+    {
         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; }
 …
             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_); }
 …
             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
     };
+}

code/trunk/src/libraries/core/CommandLineParser.cc

-                      r7284
+                      r7401
     @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)
 …
     @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)
 …
         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)
 …
+    }
+    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
 …
         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)

code/trunk/src/libraries/core/CommandLineParser.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 #include "CorePrereqs.h"
+#include <fstream>
 #include <map>
 #include "util/OrxAssert.h"
 …
         static void destroyAllArguments();
+        static void generateDoc(std::ofstream& file);
     private:
         //! Constructor initialises bFirstTimeParse_ with true.
 …
     @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>

code/trunk/src/libraries/core/ConfigFileManager.cc

r7284	r7401
27	27	*/
28	28
	29	/**
	30	@file
	31	@brief Implementation of ConfigFileManager and its helper classes.
	32	*/
	33
29	34	#include "ConfigFileManager.h"
30	35
…	…
43	48	// ConfigFileEntryValue //
44	49	//////////////////////////
45
	50	/**
	51	@brief Updates the string that will be stored in the file after one of it's components (name, value, comment) has changed.
	52	*/
46	53	void ConfigFileEntryValue::update()
47	54	{
…	…
63	70	// ConfigFileEntryVectorValue //
64	71	////////////////////////////////
	72	/**
	73	@brief Updates the string that will be stored in the file after one of it's components (name, value, index, comment) has changed.
	74	*/
65	75	void ConfigFileEntryVectorValue::update()
66	76	{
…	…
73	83	// ConfigFileSection //
74	84	///////////////////////
	85	/**
	86	@brief Destructor: Deletes all entries.
	87	*/
75	88	ConfigFileSection::~ConfigFileSection()
76	89	{
…	…
79	92	}
80	93
	94	/**
	95	@brief Deletes all elements of a config vector if their index is greater or equal to @a startindex.
	96
	97	@param name The name of the vector
	98	@param startindex The index of the first element that will be deleted
	99	*/
81	100	void ConfigFileSection::deleteVectorEntries(const std::string& name, unsigned int startindex)
82	101	{
…	…
95	114	}
96	115
	116	/**
	117	@brief Returns the size of a config vector.
	118	@param name The name of the vector
	119	*/
97	120	unsigned int ConfigFileSection::getVectorSize(const std::string& name) const
98	121	{
…	…
108	131	}
109	132
	133	/**
	134	@brief Returns the title and comment of the section as it will be stored in the file.
	135	*/
110	136	std::string ConfigFileSection::getFileEntry() const
111	137	{
…	…
116	142	}
117	143
	144	/**
	145	@brief Returns the entry with given name (or NULL if it doesn't exist).
	146
	147	@param name The name of the entry
	148	*/
118	149	ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name) const
119	150	{
…	…
126	157	}
127	158
	159	/**
	160	@brief Returns the entry of a vector element with given name and index (or NULL if it doesn't exist).
	161
	162	@param name The name of the vector
	163	@param index The index of the element in the vector
	164	*/
128	165	ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name, unsigned int index) const
129	166	{
…	…
136	173	}
137	174
	175	/**
	176	@brief Returns the iterator to the entry with given name. If the entry doesn't exist, it is created using the fallback value.
	177
	178	@param name The name of the entry
	179	@param fallback The value that will be used if the entry doesn't exist
	180	@param bString If true, the value is treated as string which means some special treatment of special characters.
	181	*/
138	182	std::list<ConfigFileEntry*>::iterator ConfigFileSection::getOrCreateEntryIterator(const std::string& name, const std::string& fallback, bool bString)
139	183	{
…	…
152	196	}
153	197
	198	/**
	199	@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.
	200
	201	@param name The name of the vector
	202	@param index The index of the element in the vector
	203	@param fallback The value that will be used if the entry doesn't exist
	204	@param bString If true, the value is treated as string which means some special treatment of special characters.
	205	*/
154	206	std::list<ConfigFileEntry*>::iterator ConfigFileSection::getOrCreateEntryIterator(const std::string& name, unsigned int index, const std::string& fallback, bool bString)
155	207	{
…	…
178	230	const char* ConfigFile::DEFAULT_CONFIG_FOLDER = "defaultConfig";
179	231
	232	/**
	233	@brief Constructor: Initializes the config file.
	234	@param filename The file-name of this config file
	235	@param bCopyFallbackFile If true, the default config file is copied into the config-directory before loading the file
	236	*/
180	237	ConfigFile::ConfigFile(const std::string& filename, bool bCopyFallbackFile)
181	238	: filename_(filename)
…	…
185	242	}
186	243
	244	/**
	245	@brief Destructor: Deletes all sections and entries.
	246	*/
187	247	ConfigFile::~ConfigFile()
188	248	{
…	…
190	250	}
191	251
	252	/**
	253	@brief Loads the config file from the hard-disk and reads the sections and their values.
	254	*/
192	255	void ConfigFile::load()
193	256	{
…	…
318	381	}
319	382
	383	/**
	384	@brief Writes the sections and values to the hard-disk.
	385	*/
320	386	void ConfigFile::save() const
321	387	{
…	…
323	389	}
324	390
	391	/**
	392	@brief Writes the sections and values to a given file on the hard-disk.
	393	*/
325	394	void ConfigFile::saveAs(const std::string& filename) const
326	395	{
…	…
354	423	}
355	424
	425	/**
	426	@brief Deletes all sections (which again delete all their values) and clears the list of sections.
	427	*/
356	428	void ConfigFile::clear()
357	429	{
…	…
361	433	}
362	434
363		const std::string& ConfigFile::getOrCreateValue(const std::string& section, const std::string& name, const std::string& fallback, bool bString)
364		{
365		const std::string& output = this->getOrCreateSection(section)->getOrCreateValue(name, fallback, bString);
366		this->saveIfUpdated();
367		return output;
368		}
369
370		const std::string& ConfigFile::getOrCreateValue(const std::string& section, const std::string& name, unsigned int index, const std::string& fallback, bool bString)
371		{
372		const std::string& output = this->getOrCreateSection(section)->getOrCreateValue(name, index, fallback, bString);
373		this->saveIfUpdated();
374		return output;
375		}
376
	435	/**
	436	@brief Deletes all elements of a config vector if their index is greater or equal to @a startindex.
	437
	438	@param section The name of the section
	439	@param name The name of the vector
	440	@param startindex The index of the first element that will be deleted
	441	*/
377	442	void ConfigFile::deleteVectorEntries(const std::string& section, const std::string& name, unsigned int startindex)
378	443	{
…	…
384	449	}
385	450
	451	/**
	452	@brief Returns a pointer to the section with given name (or NULL if the section doesn't exist).
	453	*/
386	454	ConfigFileSection* ConfigFile::getSection(const std::string& section) const
387	455	{
…	…
392	460	}
393	461
	462	/**
	463	@brief Returns a pointer to the section with given name. If it doesn't exist, the section is created.
	464	*/
394	465	ConfigFileSection* ConfigFile::getOrCreateSection(const std::string& section)
395	466	{
…	…
403	474	}
404	475
	476	/**
	477	@brief Saves the config file if it was updated (or if any of its sections were updated).
	478	*/
405	479	void ConfigFile::saveIfUpdated()
406	480	{
…	…
442	516	SettingsConfigFile* SettingsConfigFile::singletonPtr_s = 0;
443	517
	518	/**
	519	@brief Constructor: Activates the console commands.
	520	*/
444	521	SettingsConfigFile::SettingsConfigFile(const std::string& filename)
445	522	: ConfigFile(filename)
…	…
452	529	}
453	530
	531	/**
	532	@brief Destructor: Deactivates the console commands.
	533	*/
454	534	SettingsConfigFile::~SettingsConfigFile()
455	535	{
…	…
461	541	}
462	542
	543	/**
	544	@brief Loads the config file and updates the @ref ConfigValueContainer "config value containers".
	545	*/
463	546	void SettingsConfigFile::load()
464	547	{
…	…
467	550	}
468	551
	552	/**
	553	@brief Changes the file-name.
	554	*/
469	555	void SettingsConfigFile::setFilename(const std::string& filename)
470	556	{
…	…
472	558	}
473	559
	560	/**
	561	@brief Registers a new @ref ConfigValueContainer "config value container".
	562	*/
474	563	void SettingsConfigFile::addConfigValueContainer(ConfigValueContainer* container)
475	564	{
…	…
481	570	}
482	571
	572	/**
	573	@brief Unregisters a @ref ConfigValueContainer "config value container".
	574	*/
483	575	void SettingsConfigFile::removeConfigValueContainer(ConfigValueContainer* container)
484	576	{
…	…
500	592	}
501	593
	594	/**
	595	@brief Updates all @ref ConfigValueContainer "config value containers".
	596	*/
502	597	void SettingsConfigFile::updateConfigValues()
503	598	{
	599	// todo: can this be done more efficiently? looks like some identifiers will be updated multiple times.
	600
504	601	for (ContainerMap::const_iterator it = this->containers_.begin(); it != this->containers_.end(); ++it)
505	602	{
…	…
509	606	}
510	607
	608	/**
	609	@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").
	610	@param bCleanComments If true, comments are also removed from the file
	611	*/
511	612	void SettingsConfigFile::clean(bool bCleanComments)
512	613	{
…	…
558	659	}
559	660
	661	/**
	662	@brief Console-command: Changes the value of an entry and stores it the file.
	663
	664	@param section The section of the config value
	665	@param entry The name of the config value
	666	@param value The new value
	667	*/
560	668	void SettingsConfigFile::config(const std::string& section, const std::string& entry, const std::string& value)
561	669	{
…	…
564	672	}
565	673
	674	/**
	675	@brief Console-command: Changes the value of an entry, but doesn't store it in the file (it's only a temporary change).
	676
	677	@param section The section of the config value
	678	@param entry The name of the config value
	679	@param value The new value
	680	*/
566	681	void SettingsConfigFile::tconfig(const std::string& section, const std::string& entry, const std::string& value)
567	682	{
…	…
570	685	}
571	686
	687	/**
	688	@brief Changes the value of an entry, depending on @a function, either by using "set" or "tset"
	689
	690	@param section The section of the config value
	691	@param entry The name of the config value
	692	@param value The new value
	693	@param function The function ("set" or "tset") that will be used to change the value.
	694	*/
572	695	bool SettingsConfigFile::configImpl(const std::string& section, const std::string& entry, const std::string& value, bool (ConfigValueContainer::*function)(const MultiType&))
573	696	{
…	…
586	709	}
587	710
	711	/**
	712	@brief Console-command: Returns the value of a given entry.
	713
	714	@param section The section of the config value
	715	@param entry The name of the config value
	716	*/
588	717	std::string SettingsConfigFile::getConfig(const std::string& section, const std::string& entry)
589	718	{
…	…
611	740	ConfigFileManager* ConfigFileManager::singletonPtr_s = 0;
612	741
	742	/// Constructor: Initializes the array of config files with NULL.
613	743	ConfigFileManager::ConfigFileManager()
614	744	{
…	…
616	746	}
617	747
	748	/// Destructor: Deletes the config files.
618	749	ConfigFileManager::~ConfigFileManager()
619	750	{
…	…
623	754	}
624	755
	756	/// Defines the file-name for the config file of a given type (settings, calibration, etc.).
625	757	void ConfigFileManager::setFilename(ConfigFileType::Value type, const std::string& filename)
626	758	{

code/trunk/src/libraries/core/ConfigFileManager.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
     // 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;
     };
 …
     // 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)
 …
                 { this->update(); }
+            /// Destructor
             inline virtual ~ConfigFileEntryValue() {}
 …
                 { 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_; }
 …
             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.
     };
 …
     // 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)
 …
                 { this->update(); /*No virtual calls in base class ctor*/ }
+            /// Destructor
             inline ~ConfigFileEntryVectorValue() {}
 …
                 { 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_; }
 …
             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)
     };
 …
     // 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() {}
 …
                 { return this->comment_; }
-            inline virtual const std::string& getKeyString() const
-                { return BLANKSTRING; }
         private:
             std::string comment_;
+            std::string comment_;   ///< The comment
     };
 …
     // ConfigFileSection //
     ///////////////////////
+    /**
+        @brief Represents a section in a config file.
+        A section has a name and a list of config values.
+    */
     class _CoreExport ConfigFileSection
+    {
 …
         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)
 …
             ~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)
+            {
 …
                 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)
+            {
 …
                 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(); }
 …
         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(); }
 …
             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
     };
 …
     // 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
+    {
 …
             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)
+            {
 …
                 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)
+            {
 …
                 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)
+            {
 …
                 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)
+            {
 …
                 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
+            {
 …
+            }
             static const char* DEFAULT_CONFIG_FOLDER;
+            static const char* DEFAULT_CONFIG_FOLDER;   ///< The folder where the default config files will be stored
         protected:
 …
             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
     };
 …
     // 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>
 …
             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); }
 …
             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
 …
     // ConfigFileManager //
     ///////////////////////
+    /**
+        @brief Manages the different config files (settings, calibration, etc). Implemented as Singleton.
+    */
     class _CoreExport ConfigFileManager : public Singleton<ConfigFileManager>
+    {
 …
             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)
+            {
 …
         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

code/trunk/src/libraries/core/ConfigValueContainer.h

-                      r6536
+                      r7401
 /**
     @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:
 …
-    //! 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
 …
                 @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>
 …
+            }
             /** @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(); }
 …
             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(); }

code/trunk/src/libraries/core/ConfigValueIncludes.h

-                      r7166
+                      r7401
 /**
+@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
 */

code/trunk/src/libraries/core/Core.cc

-                      r7284
+                      r7401
 #include <cassert>
+#include <fstream>
 #include <vector>
 …
         // 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;
+        }
+    }

code/trunk/src/libraries/core/Core.h

-                      r7266
+                      r7401
  */
+/**
+    @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__
 …
 #include "CorePrereqs.h"
-#include <cassert>
 #include <string>
 #include <boost/scoped_ptr.hpp>

code/trunk/src/libraries/core/CoreIncludes.h

-                      r6423
+                      r7401
 /**
+    @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
 */
 …
 /**
     @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) \
 …
 /**
     @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
 */
 …
 /**
     @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) \
 …
     /**
         @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)
 …
     /**
         @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)
 …
     /**
         @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)
 …
         @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>

code/trunk/src/libraries/core/DynLib.h

-                      r6073
+                      r7401
 // 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__
 …
 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
 …
         @since
 January 2002
-        @see
-            Resource
     */
     class _CoreExport DynLib

code/trunk/src/libraries/core/DynLibManager.h

-                      r5738
+                      r7401
 // 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__
 …
         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);

code/trunk/src/libraries/core/Event.cc

-                      r7284
+                      r7401
+ *
  */
+/**
+    @file
+    @brief Implementation of the classes Event and EventState.
+*/
 #include "Event.h"

code/trunk/src/libraries/core/Event.h

-                      r7284
+                      r7401
  */
+/**
+    @defgroup Event Events
+    @ingroup Core
+*/
+/**
+    @file
+    @ingroup Event
+    @brief Declaration of the classes Event and EventState.
+*/
 #ifndef _Event_H__
 #define _Event_H__
 …
         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

code/trunk/src/libraries/core/EventIncludes.h

-                      r7301
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup Event
+    @brief Definition of the XMLPortEventState() macro, as well as some more useful macros.
+*/
 #ifndef _EventIncludes_H__

code/trunk/src/libraries/core/GUIManager.cc

-                      r7284
+                      r7401
         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
     */
 …
     @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.

code/trunk/src/libraries/core/GUIManager.h

-                      r7163
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup Graphics
+*/
 #ifndef _GUIManager_H__

code/trunk/src/libraries/core/Game.h

-                      r7266
+                      r7401
 /**
 @file
+@ingroup Management CoreGame
 @brief
     Declaration of Game Singleton.
+    Declaration of Game Singleton which is responsible for running the game.
  */
 …
 /**
 @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)

code/trunk/src/libraries/core/GameMode.cc

r5929	r7401
33	33	bool GameMode::bShowsGraphics_s = false;
34	34	bool GameMode::bPlaysSound_s = false;
35		bool GameMode::b~~HasServer_s~~ = false;
	35	bool GameMode::bIsServer_s = false;
36	36	bool GameMode::bIsClient_s = false;
37	37	bool GameMode::bIsStandalone_s = false;

code/trunk/src/libraries/core/GameMode.h

-                      r6417
+                      r7401
 /**
     @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.
 */
 …
 namespace orxonox
+{
+    /// Helper class, stores and returns the current mode of the game.
     class _CoreExport GameMode
+    {
 …
         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:
 …
             ~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

code/trunk/src/libraries/core/GameState.h

r5929	r7401
29	29	/**
30	30	@file
	31	@ingroup Management CoreGame
31	32	@brief
32	33	Definition of GameState class.

code/trunk/src/libraries/core/GraphicsManager.h

-                      r7284
+                      r7401
 /**
+    @defgroup Graphics Graphics and GUI
+    @ingroup Core
+*/
+/**
 @file
+@ingroup Graphics
 @brief
     Declaration of GraphicsManager Singleton.

code/trunk/src/libraries/core/Identifier.cc

-                      r7284
+                      r7401
     /**
         @brief Sets the name of the class.
-        @param name The name
     */
     void Identifier::setName(const std::string& name)
 …
     /**
         @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)

code/trunk/src/libraries/core/Identifier.h

-                      r7284
+                      r7401
 /**
+    @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
 */
 …
     // ###       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; }
 …
             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(); }
 …
             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(); }
 …
             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_; }
 …
             ///// 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(); }
 …
             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_; }
 …
         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--; }
 …
     // ###     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:
 …
         @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>

code/trunk/src/libraries/core/Iterator.h

-                      r7271
+                      r7401
 /**
     @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)
+    {
 …
         myClass* myObject = *it;
+    }
+    @endcode
 */
 …
 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
 …
                 @return The Iterator itself
             */
             inline Iterator<T> operator++(int i)
+            inline Iterator<T> operator++(int)
+            {
                 Iterator<T> copy = *this;

code/trunk/src/libraries/core/Language.cc

r7284	r7401
168	168	@brief Returns the localisation of a given entry.
169	169	@param label The label of the entry
	170	@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.
170	171	@return The localisation
171	172	*/

code/trunk/src/libraries/core/Language.h

-                      r7284
+                      r7401
 /**
+    @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.
 …
     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
 */
 …
     // ###      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
+    {
 …
     // ###         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>
+    {
 …
     };
     //! Shortcut function for Language::addEntry
+    /// Shortcut function for Language::addEntry
     inline void AddLanguageEntry(const LanguageEntryLabel& label, const std::string& fallbackString)
+    {
 …
+    }
     //! Shortcut function for Language::getLocalisation
+    /// Shortcut function for Language::getLocalisation
     inline const std::string& GetLocalisation(const LanguageEntryLabel& label)
+    {
 …
+    }
     //! 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)
+    {

code/trunk/src/libraries/core/Loader.h

-                      r5781
+                      r7401
+ *
  */
+/**
+    @defgroup Loader Loader
+    @ingroup XML
+*/
+/**
+    @file
+    @ingroup XML Loader
+*/
 #ifndef _Loader_H__

code/trunk/src/libraries/core/LuaState.h

-                      r7284
+                      r7401
+ *
  */
+/**
+    @defgroup Lua Lua
+    @ingroup Core
+*/
+/**
+    @file
+    @ingroup Lua
+*/
 #ifndef _LuaState_H__

code/trunk/src/libraries/core/MemoryArchive.cc

r6417	r7401
54	54	}
55	55
56		DataStreamPtr MemoryArchive::open(const String& filename) const
	56	DataStreamPtr MemoryArchive::open(const Ogre::String& filename) const
57	57	{
58	58	const FileMap& files = archives_s[this->getName()];
…	…
64	64	}
65	65
66		void MemoryArchive::findFiles(const String& pattern, bool bRecursive,
67		bool bDirs, ~~StringVector* simpleList,~~ FileInfoList* detailList)
	66	void MemoryArchive::findFiles(const Ogre::String& pattern, bool bRecursive,
	67	bool bDirs, Ogre::StringVector* simpleList, Ogre::FileInfoList* detailList)
68	68	{
69	69	const FileMap& files = archives_s[this->getName()];
…	…
110	110	}
111	111
112		StringVectorPtr MemoryArchive::find(const String& pattern,
	112	StringVectorPtr MemoryArchive::find(const Ogre::String& pattern,
113	113	bool recursive, bool dirs)
114	114	{
…	…
118	118	}
119	119
120		FileInfoListPtr MemoryArchive::findFileInfo(const String& pattern,
	120	FileInfoListPtr MemoryArchive::findFileInfo(const Ogre::String& pattern,
121	121	bool recursive, bool dirs)
122	122	{
…	…
126	126	}
127	127
128		bool MemoryArchive::exists(const String& filename)
	128	bool MemoryArchive::exists(const Ogre::String& filename)
129	129	{
130	130	const FileMap& files = archives_s[this->getName()];

code/trunk/src/libraries/core/MemoryArchive.h

-                      r6417
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup Management Resources
+*/
 #ifndef _MemoryArchive_H__

code/trunk/src/libraries/core/MetaObjectList.h

-                      r5738
+                      r7401
 /**
     @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
 …
     // ###  MetaObjectListElement  ###
     // ###############################
     //! The list-element of the MetaObjectList
+    /// The list-element of the MetaObjectList
     class _CoreExport MetaObjectListElement
+    {
 …
     // ###     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.

code/trunk/src/libraries/core/Namespace.cc

-                      r6417
+                      r7401
+    }
-    /**
-        @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)
+    {

code/trunk/src/libraries/core/Namespace.h

-                      r5781
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup XML Loader
+*/
 #ifndef _Namespace_H__

code/trunk/src/libraries/core/NamespaceNode.h

-                      r5781
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup XML Loader
+*/
 #ifndef _NamespaceNode_H__

code/trunk/src/libraries/core/ObjectList.h

-                      r7278
+                      r7401
 /**
+    @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.
 */
 …
     // ###       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>
 …
             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()
+            {
 …
+            }
             /** @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()
+            {
 …
+            }
             /** @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()
+            {
 …
+            }
             /** @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()
+            {

code/trunk/src/libraries/core/ObjectListBase.cc

-                      r5738
+                      r7401
     @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.
 */
 …
     /**
         @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
 …
     /**
         @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
     */

code/trunk/src/libraries/core/ObjectListBase.h

-                      r5738
+                      r7401
 /**
     @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.
 */
 …
     // ###  ObjectListBaseElement  ###
     // ###############################
     //! The list-element of the ObjectListBase
+    /// The list-element of the ObjectListBase
     class _CoreExport ObjectListBaseElement
+    {
 …
             /**
                 @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) {}
 …
     // ###    ObjectListElement    ###
     // ###############################
     //! The list-element that actually contains the object
+    /// The list-element that actually contains the object
     template <class T>
     class ObjectListElement : public ObjectListBaseElement
 …
     // ###     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
 …
             ObjectListBaseElement* add(ObjectListBaseElement* element);
+            /// Helper struct, used to export an element and the list to an instance of Iterator.
             struct Export
+            {
 …
             };
             /** @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); }

code/trunk/src/libraries/core/ObjectListIterator.h

-                      r7268
+                      r7401
 /**
     @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)
+    {
 …
         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).
 */
 …
 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
 …
             /**
                 @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)
 …
                 @return The ObjectListIterator itself
             */
             inline ObjectListIterator<T> operator++(int i)
+            inline ObjectListIterator<T> operator++(int)
+            {
                 ObjectListIterator<T> copy = *this;
 …
         private:
             ObjectListElement<T>* element_;        //!< The element the Iterator points at
+            ObjectListElement<T>* element_;        //!< The element the iterator points at
     };
+}

code/trunk/src/libraries/core/OrxonoxClass.cc

-                      r6417
+                      r7401
 /**
     @file
     @brief Implementation of the OrxonoxClass Class.
+    @brief Implementation of OrxonoxClass.
 */
 …
 namespace orxonox
+{
+    /** @brief Constructor: Sets the default values. */
+    /**
+        @brief Constructor: Sets the default values.
+    */
     OrxonoxClass::OrxonoxClass()
+    {
 …
+    }
+    /** @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()
+    {
 …
+    }
+    /** @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()
+    {
 …
+    }
+    /**
+        @brief Removes this object from the object-lists.
+    */
     void OrxonoxClass::unregisterObject()
+    {
 …
+    }
     /** @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()); }

code/trunk/src/libraries/core/OrxonoxClass.h

-                      r7163
+                      r7401
 /**
+    @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.
 …
 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
 …
             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_; }
 …
             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); }
 …
             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_; }
 …
+            }
             //! 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()
+            {
 …
+            }
             /** @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_;
     };

code/trunk/src/libraries/core/PathConfig.h

-                      r6417
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup Management Resources
+*/
 #ifndef _PathConfig_H__

code/trunk/src/libraries/core/Resource.h

-                      r6746
+                      r7401
+ *
  */
+/**
+    @defgroup Resources Resources
+    @ingroup Management
+*/
+/**
+    @file
+    @ingroup Management Resources
+*/
 #ifndef _Core_Resource_H__
 …
         /**
             Find out if the named file exists.
         @param filename
+        @param name
             Fully qualified name of the file to test for
         */
 …
         /**
             Get struct with information about path and size.
         @param filename
+        @param name
             Fully qualified name of the file to test for
         */

code/trunk/src/libraries/core/SmartPtr.h

-                      r7268
+                      r7401
 // 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__
 …
 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)
+            {
 …
+            }
+            /// Copy-constructor
             inline SmartPtr(const SmartPtr& other) : pointer_(other.pointer_), base_(other.base_)
+            {
 …
+            }
+            /// 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_)
 …
+            }
+            /// 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())
 …
+            }
+            /// Destructor: Decrements the reference counter.
             inline ~SmartPtr()
+            {
 …
+            }
+            /// Used to assign a null pointer.
             inline SmartPtr& operator=(int)
+            {
 …
+            }
+            /// Assigns a new pointer.
             inline SmartPtr& operator=(T* pointer)
+            {
 …
+            }
+            /// Assigns the wrapped pointer of another SmartPtr.
             inline SmartPtr& operator=(const SmartPtr& other)
+            {
 …
+            }
+            /// Assigns the wrapped pointer of a SmartPtr of another class
             template <class O>
             inline SmartPtr& operator=(const SmartPtr<O>& other)
 …
+            }
+            /// Assigns the wrapped pointer of a WeakPtr.
             template <class O>
             inline SmartPtr& operator=(const WeakPtr<O>& other)
 …
+            }
+            /// Returns the wrapped pointer as @c T*
             inline T* get() const
+            {
 …
+            }
+            /// Returns the wrapped pointer as @c OrxonoxClass*
             inline OrxonoxClass* getBase() const
+            {
 …
+            }
+            /// Implicitly converts the SmartPtr to a pointer of type @c T*
             inline operator T*() const
+            {
 …
+            }
+            /// Overloaded operator, returns a pointer to the stored object.
             inline T* operator->() const
+            {
 …
+            }
+            /// Overloaded operator, returns a reference to the stored object.
             inline T& operator*() const
+            {
 …
+            }
+            /// Returns true if the wrapped pointer is NULL.
             inline bool operator!() const
+            {
 …
+            }
+            /// Swaps the contents of two smart pointers.
             inline void swap(SmartPtr& other)
+            {
 …
+            }
+            /// Resets the smart pointer (equivalent to assigning a NULL pointer).
             inline void reset()
+            {
 …
         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)
 …
+    }
+    /// 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)
 …
+    }
+    /// 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)
 …
+    }
+    /// 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)

code/trunk/src/libraries/core/SubclassIdentifier.h

-                      r7268
+                      r7401
 /**
     @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
 */
 …
     // ###   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>
 …
+    {
         public:
+            /**
+                @brief Constructor: Automaticaly assigns the Identifier of the given class.
+            */
+            /// Constructor: Automaticaly assigns the Identifier of the given class.
             SubclassIdentifier()
+            {
 …
+            }
+            /**
+                @brief Constructor: Assigns the given Identifier.
+                @param identifier The Identifier
+            */
+            /// Constructor: Assigns the given Identifier.
             SubclassIdentifier(Identifier* identifier)
+            {
 …
+            }
+            /**
+                @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)
 …
+            }
+            /**
+                @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)
 …
+            }
+            /**
+                @brief Overloading of the * operator: returns the assigned identifier.
+            */
+            /// Overloading of the * operator: returns the assigned identifier.
             inline Identifier* operator*() const
+            {
 …
+            }
+            /**
+                @brief Overloading of the -> operator: returns the assigned identifier.
+            */
+            /// Overloading of the -> operator: returns the assigned identifier.
             inline Identifier* operator->() const
+            {
 …
+            }
+            /**
+                @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
+            {
 …
+            }
+            /**
+                @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
+            {
 …
+            }
             /** @brief Returns the assigned identifier. @return The identifier */
+            /// Returns the assigned identifier.
             inline Identifier* getIdentifier() const
                 { return this->identifier_; }

code/trunk/src/libraries/core/Super.h

-                      r7163
+                      r7401
 /**
+    @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:
+) 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)
 ) 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)
 ) 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)
 ) 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
 */
 …
     */
     // 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, ...) \

code/trunk/src/libraries/core/Template.h

-                      r7163
+                      r7401
+ *
  */
+/**
+    @defgroup Template Template
+    @ingroup XML
+*/
+/**
+    @file
+    @ingroup XML Template
+*/
 #ifndef _Template_H__

code/trunk/src/libraries/core/Thread.h

-                      r7284
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup ThreadPool
+*/
 #ifndef _Thread_H__

code/trunk/src/libraries/core/ThreadPool.h

-                      r7284
+                      r7401
+ *
  */
+/**
+    @defgroup ThreadPool Thread pool
+    @ingroup Core
+*/
+/**
+    @file
+    @ingroup ThreadPool
+*/
 #ifndef _ThreadPool_H__

code/trunk/src/libraries/core/ToluaInterface.h

r5738	r7401
29	29	/**
30	30	@file
	31	@ingroup Lua
	32	@brief
31	33	This is required because tolua would parse this macro in LuaState.h and fail
32	34	*/

code/trunk/src/libraries/core/WeakPtr.h

r7284	r7401
29	29	// Inspired by boost::intrusive_ptr by Peter Dimov
30	30
	31	/**
	32	@file
	33	@ingroup Object SmartPtr
	34	@brief Definition of WeakPtr<T>, wraps a pointer to an object.
	35
	36	@anchor WeakPtrExample
	37
	38	A WeakPtr wraps a pointer to an object. If the object gets deleted, the WeakPtr becomes
	39	NULL. This can be used to store pointers to objects without knowing when they will be
	40	destroyed.
	41
	42	WeakPtr works only with objects that are derived from orxonox::OrxonoxClass, because
	43	WeakPtr is intrusive and registers itself in the stored object, to get a notification if
	44	the object is being deleted.
	45
	46	Example:
	47	@code
	48	MyClass* object = new MyClass(); // create an instance of MyClass
	49
	50	WeakPtr<MyClass> pointer = object; // create a WeakPtr and assign the object
	51
	52	if (pointer) // checks if pointer is not NULL (which is true)
	53	pointer->someFunction(); // calls MyClass::someFunction()
	54
	55	object->destroy(); // calls destroy() which deletes the object
	56
	57	if (pointer) // checks if pointer is not NULL (which is now false)
	58	pointer->someFunction(); // this will not be executed
	59	@endcode
	60	In this example we assumed that MyClass is derived of OrxonoxClass (otherwise it couldn't
	61	be used with a WeakPtr).
	62
	63	A callback can be registerd with the WeakPtr that will be called if the object gets deleted.
	64	@code
	65	void myCallback() // definition of the callback function
	66	{
	67	COUT(0) << "Object destroyed" << std::endl;
	68	}
	69
	70	MyClass* object = new MyClass(); // create an instance of MyClass
	71
	72	WeakPtr<MyClass> pointer = object; // create a WeakPtr and assign the object
	73
	74	pointer.setCallback(createFunctor(&myCallback)); // defines a callback
	75
	76	object->destroy(); // calls destroy() which deletes the object. prints "Object destroyed" to the console
	77	@endcode
	78	*/
	79
31	80	#ifndef _WeakPtr_H__
32	81	#define _WeakPtr_H__
…	…
41	90	namespace orxonox
42	91	{
	92	/**
	93	@brief WeakPtr wraps a pointer to an object, which becomes NULL if the object is deleted.
	94
	95	@see See @ref WeakPtrExample "this description" for more information and an example.
	96	*/
43	97	template <class T>
44	98	class WeakPtr
…	…
47	101
48	102	public:
	103	/// Constructor: Initializes the weak pointer with a null pointer.
49	104	inline WeakPtr() : pointer_(0), base_(0), callback_(0)
50	105	{
51	106	}
52	107
	108	/// Constructor: Used to explicitly initialize the weak pointer with a null pointer
53	109	inline WeakPtr(int) : pointer_(0), base_(0), callback_(0)
54	110	{
55	111	}
56	112
	113	/// Constructor: Initializes the weak pointer with a pointer to an object.
57	114	inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(0)
58	115	{
…	…
61	118	}
62	119
	120	/// Copy-constructor
63	121	inline WeakPtr(const WeakPtr& other) : pointer_(other.pointer_), base_(other.base_), callback_(0)
64	122	{
…	…
67	125	}
68	126
	127	/// Copy-constructor for weak pointers to objects of another class.
69	128	template <class O>
70	129	inline WeakPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.base_), callback_(0)
…	…
74	133	}
75	134
	135	/// Destructor
76	136	inline ~WeakPtr()
77	137	{
…	…
81	141	}
82	142
	143	/// Used to assign a null pointer.
83	144	inline WeakPtr& operator=(int)
84	145	{
…	…
87	148	}
88	149
	150	/// Assigns a new pointer.
89	151	inline WeakPtr& operator=(T* pointer)
90	152	{
…	…
93	155	}
94	156
	157	/// Assigns the wrapped pointer of another WeakPtr.
95	158	inline WeakPtr& operator=(const WeakPtr& other)
96	159	{
…	…
99	162	}
100	163
	164	/// Assigns the wrapped pointer of a WeakPtr of another class
101	165	template <class O>
102	166	inline WeakPtr& operator=(const WeakPtr<O>& other)
…	…
106	170	}
107	171
	172	/// Returns the wrapped pointer as @c T*
108	173	inline T* get() const
109	174	{
…	…
111	176	}
112	177
	178	/// Returns the wrapped pointer as @c OrxonoxClass*
113	179	inline OrxonoxClass* getBase() const
114	180	{
…	…
116	182	}
117	183
	184	/// Implicitly converts the WeakPtr to a pointer of type @c T*
118	185	inline operator T*() const
119	186	{
…	…
121	188	}
122	189
	190	/// Overloaded operator, returns a pointer to the stored object.
123	191	inline T* operator->() const
124	192	{
…	…
127	195	}
128	196
	197	/// Overloaded operator, returns a reference to the stored object.
129	198	inline T& operator*() const
130	199	{
…	…
133	202	}
134	203
	204	/// Returns true if the wrapped pointer is NULL.
135	205	inline bool operator!() const
136	206	{
…	…
138	208	}
139	209
	210	/// Swaps the contents of two weak pointers.
140	211	inline void swap(WeakPtr& other)
141	212	{
…	…
162	233	}
163	234
	235	/// Resets the weak pointer (equivalent to assigning a NULL pointer).
164	236	inline void reset()
165	237	{
…	…
167	239	}
168	240
	241	/// Registers a callback that will be executed if the stored object is destroyed.
169	242	inline void setCallback(const FunctorPtr& callback)
170	243	{
…	…
172	245	}
173	246
	247	/// Returns the registered callback.
174	248	inline const FunctorPtr& getCallback() const
175	249	{
…	…
178	252
179	253	private:
	254	/// Will be called by OrxonoxClass::~OrxonoxClass() if the stored object is deleted. Resets the wrapped pointer and executes the callback.
180	255	inline void objectDeleted()
181	256	{
…	…
186	261	}
187	262
188		T* pointer_;
189		OrxonoxClass* base_;
190		FunctorPtr callback_;
	263	T* pointer_; ///< The wrapped pointer to an object of type @a T
	264	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)
	265	FunctorPtr callback_; ///< This callback will be executed if the stored object is deleted
191	266	};
192	267
	268	/// Swaps the contents of two weak pointers.
193	269	template <class T>
194	270	void swap(WeakPtr<T>& a, WeakPtr<T>& b)
…	…
197	273	}
198	274
	275	/// 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>.
199	276	template <class T, class U>
200	277	WeakPtr<T> static_pointer_cast(const WeakPtr<U>& p)
…	…
203	280	}
204	281
	282	/// 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>.
205	283	template <class T, class U>
206	284	WeakPtr<T> const_pointer_cast(const WeakPtr<U>& p)
…	…
209	287	}
210	288
	289	/// 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>.
211	290	template <class T, class U>
212	291	WeakPtr<T> dynamic_pointer_cast(const WeakPtr<U>& p)

code/trunk/src/libraries/core/WindowEventListener.h

-                      r5781
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup Graphics
+*/
 #ifndef _WindowEventListener_H__

code/trunk/src/libraries/core/XMLFile.h

-                      r6417
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup XML XMLPort
+*/
 #ifndef _XMLFile_H__

code/trunk/src/libraries/core/XMLNameListener.h

-                      r5781
+                      r7401
  */
+/**
+    @file
+    @ingroup XML XMLPort
+*/
 #ifndef _XMLNameListener_H__
 #define _XMLNameListener_H__

code/trunk/src/libraries/core/XMLPort.h

-                      r7284
+                      r7401
 /**
+    @defgroup XMLPort XMLPort
+    @ingroup XML
+*/
+/**
     @file
+    @ingroup XML XMLPort
     @brief Declaration of the XMLPort helper classes and macros.
 …
     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
 …
     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.
 …
     @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
 …
     @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)
 …
     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:
 …
       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
+        {
 …
             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>
 …
       </weapons>
     </SpaceShip>
+    @endcode
     Note that "weapons" is the subsection. This allows you to add more types of sub-objects. In our example,

code/trunk/src/libraries/core/command/ArgumentCompleter.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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 = "")
+            {
 …
+            }
+            /// 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
     };
+}

code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.cc

r7284	r7401
26	26	*
27	27	*/
	28
	29	/**
	30	@file
	31	@brief Implementation of all argument completion functions
	32	*/
28	33
29	34	#include "ArgumentCompletionFunctions.h"
…	…
53	58	namespace autocompletion
54	59	{
	60	/**
	61	@brief Fallback implementation, returns an empty list.
	62	*/
55	63	ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(fallback)()
56	64	{
…	…
60	68	namespace detail
61	69	{
	70	/**
	71	@brief Returns true if a group of console commands is visible (i.e. if at least one command in this group is visible).
	72	*/
62	73	bool groupIsVisible(const std::map<std::string, ConsoleCommand*>& group, bool bOnlyShowHidden)
63	74	{
…	…
69	80	}
70	81
	82	/**
	83	@brief Returns a list of all console command groups AND all console command shortcuts.
	84	@param fragment The last argument
	85	@param bOnlyShowHidden If true, only hidden groups and commands are returned
	86	*/
71	87	ArgumentCompletionList _groupsandcommands(const std::string& fragment, bool bOnlyShowHidden)
72	88	{
	89	// note: this function returns only arguments that begin with "fragment", which would't be necessary for the
	90	// auto-completion, but it's necessary to place the line-break "\n" between groups and commands
	91	// only if both groups AND commands are in the list.
	92
73	93	ArgumentCompletionList groupList;
74	94	std::string fragmentLC = getLowercase(fragment);
75	95
	96	// get all the groups that are visible (except the shortcut group "")
76	97	const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommand::getCommands();
77	98	for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
…	…
79	100	groupList.push_back(ArgumentCompletionListElement(it_group->first, getLowercase(it_group->first)));
80	101
	102	// now add all shortcuts (in group "")
81	103	std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.find("");
82	104	if (it_group != commands.end())
83	105	{
	106	// add a line-break if the list isn't empty
84	107	if (!groupList.empty())
85	108	groupList.push_back(ArgumentCompletionListElement("", "", "\n"));
86	109
	110	// add the shortcuts
87	111	for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
88	112	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	114	}
91	115
	116	// if no shortcut was added, remove the line-break again
92	117	if (!groupList.empty() && groupList.back().getDisplay() == "\n")
93	118	groupList.pop_back();
…	…
96	121	}
97	122
	123	/**
	124	@brief Returns a list of all console commands in a given group.
	125	@param fragment The last argument
	126	@param group The group's name
	127	@param bOnlyShowHidden If true, only hidden console commands are returned
	128	*/
98	129	ArgumentCompletionList _subcommands(const std::string& fragment, const std::string& group, bool bOnlyShowHidden)
99	130	{
…	…
102	133	std::string groupLC = getLowercase(group);
103	134
	135	// find the iterator of the given group
104	136	std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommands().begin();
105	137	for ( ; it_group != ConsoleCommand::getCommands().end(); ++it_group)
…	…
107	139	break;
108	140
	141	// add all commands in the group to the list
109	142	if (it_group != ConsoleCommand::getCommands().end())
110	143	{
…	…
118	151	}
119	152
	153	/**
	154	@brief Returns a list of all console command groups AND all console command shortcuts.
	155	*/
120	156	ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(groupsandcommands)(const std::string& fragment)
121	157	{
…	…
123	159	}
124	160
	161	/**
	162	@brief Returns a list of all console commands in a given group.
	163	*/
125	164	ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(subcommands)(const std::string& fragment, const std::string& group)
126	165	{
…	…
128	167	}
129	168
	169	/**
	170	@brief Returns a list of commands and groups and also supports auto-completion of the arguments of these commands.
	171
	172	This is a multi-word function, because commands are composed of 1-2 words and additional arguments.
	173	*/
130	174	ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION_MULTI(command)(const std::string& fragment)
131	175	{
…	…
145	189	}
146	190
	191	/**
	192	@brief Returns a list of hidden commands and groups and also supports auto-completion of the arguments of these commands.
	193
	194	This is a multi-word function, because commands are composed of 1-2 words and additional arguments.
	195
	196	This function makes commands visible that would usually be hidden.
	197	*/
147	198	ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION_MULTI(hiddencommand)(const std::string& fragment)
148	199	{
…	…
170	221	}
171	222
	223	/**
	224	@brief Returns possible files and directories and also supports files in arbitrary deeply nested subdirectories.
	225
	226	This function returns files and directories in the given path. This allows to
	227	navigate iteratively through the file system. The first argument @a fragment
	228	is used to get the current path.
	229	*/
172	230	ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(files)(const std::string& fragment)
173	231	{
…	…
211	269	}
212	270
	271	/**
	272	@brief Returns the sections of the config file.
	273	*/
213	274	ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(settingssections)()
214	275	{
…	…
222	283	}
223	284
	285	/**
	286	@brief Returns the entries in a given section of the config file.
	287	*/
224	288	ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(settingsentries)(const std::string& fragment, const std::string& section)
225	289	{
…	…
235	299	}
236	300
	301	/**
	302	@brief Returns the current value of a given value in a given section of the config file.
	303	*/
237	304	ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(settingsvalue)(const std::string& fragment, const std::string& entry, const std::string& section)
238	305	{
…	…
255	322	}
256	323
	324	/**
	325	@brief Returns a list of indexes of the available Tcl threads (see TclThreadManager).
	326	*/
257	327	ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(tclthreads)()
258	328	{

code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 #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() \
 …
     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

code/trunk/src/libraries/core/command/ArgumentCompletionListElement.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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
     };
+}

code/trunk/src/libraries/core/command/CommandEvaluation.cc

-                      r7286
+                      r7401
  */
+/**
+    @file
+    @brief Implementation of CommandEvaluation
+*/
 #include "CommandEvaluation.h"
 …
 namespace orxonox
+{
+    /**
+        @brief Constructor: Initializes the command evaluation with an empty command.
+    */
     CommandEvaluation::CommandEvaluation()
+    {
 …
+    }
+    /**
+        @brief Initializes all values.
+    */
     void CommandEvaluation::initialize(const std::string& command)
+    {
 …
         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
+    {
 …
+    }
+    /**
+        @brief Executes the command which was evaluated by this object.
+        @return Returns the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+    */
     int CommandEvaluation::execute()
+    {
 …
+    }
+    /**
+        @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;
 …
+        }
+        // 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]);
+                }
+            }
 …
+        }
+        // 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)
+        {
 …
         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)
 …
+    }
+    /**
+        @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
+    {
 …
         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)
+        {
 …
+        }
+        // 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())
 …
+        }
+        // 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)
+    {
 …
+    }
+    /**
+        @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 == "")
+            {
 …
+            }
+            // check the length of the argument - arguments smaller than 'fragment' are always erased
             if (entry.size() < fragmentLC.size())
+            {
 …
             else
+            {
+                // compare the argument char by char with 'fragment'
                 bool bErase = false;
                 for (size_t i = 0; i < fragmentLC.size(); ++i)
 …
+    }
+    /**
+        @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());
 …
         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)
+                {
 …
                     const std::string& argument = it->getString();
+                    // ignore empty arguments
                     if (argumentComparable == "")
                         continue;
 …
                     if (argument.size() > i)
+                    {
                         if (tempComparable == 0)
+                        if (tempComparable == '\0')
+                        {
+                            // the first entry is always taken
                             tempComparable = argumentComparable[i];
                             temp = argument[i];
 …
                         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;
+                        }
 …
+    }
+    /**
+        @brief Joins the elements of the given list to a string.
+    */
     /* static */ std::string CommandEvaluation::dump(const ArgumentCompletionList& list)
+    {
 …
             output += it->getDisplay();
+            // add a space character between two elements for all non-empty arguments
             if (it->getComparable() != "")
                 output += ' ';
 …
+    }
+    /**
+        @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 += '[';
 …
                 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() + ']';

code/trunk/src/libraries/core/command/CommandEvaluation.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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
+    {
 …
             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_); }
 …
             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)
     };
+}

code/trunk/src/libraries/core/command/CommandExecutor.cc

-                      r7284
+                      r7401
  */
+/**
+    @file
+    @brief Implementation of CommandExecutor
+*/
 #include "CommandExecutor.h"
 …
         .argumentCompleter(1, autocompletion::command());
+    /**
+        @brief Returns a reference to the only instance of CommandExecutor.
+    */
     /* static */ CommandExecutor& CommandExecutor::getInstance()
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
+    }
+    /**
+        @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_)
 …
             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_)
 …
+        }
+        // if a valid command was found and the user is already entering arguments, overwrite hintCommand_ with execCommand_
         if (evaluation.execCommand_ && evaluation.getNumberOfArguments() > evaluation.execArgumentsOffset_)
+        {
 …
+    }
+    /**
+        @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)
+    {
 …
             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())
 …
+    }
+    /**
+        @brief Writes a command evaluation for a given command to the cache.
+    */
     void CommandExecutor::cache(const std::string& command, const CommandEvaluation& evaluation)
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
+    }
+    /**
+        @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])))
+            {
 …
+            }
+            // create a new console command with the given alias as its name
             if (tokens.size() == 1)
                 createConsoleCommand(tokens[0], executor);

code/trunk/src/libraries/core/command/CommandExecutor.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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
+    {
 …
             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();
 …
             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

code/trunk/src/libraries/core/command/ConsoleCommand.cc

-                      r7284
+                      r7401
  */
+/**
+    @file
+    @brief Implementation of the ConsoleCommand class.
+*/
 #include "ConsoleCommand.h"
 …
 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)
+    {
 …
         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;
 …
+    }
+    /**
+        @brief Destructor: Unregisters the command.
+    */
     ConsoleCommand::~ConsoleCommand()
+    {
 …
+    }
+    /**
+        @brief Registers the command with the same name, but without group, as shortcut.
+    */
     ConsoleCommand& ConsoleCommand::addShortcut()
+    {
 …
+    }
+    /**
+        @brief Registers the command with an alias as shortcut.
+    */
     ConsoleCommand& ConsoleCommand::addShortcut(const std::string&  name)
+    {
 …
+    }
+    /**
+        @brief Registers the command in a different group but with the same name.
+    */
     ConsoleCommand& ConsoleCommand::addGroup(const std::string& group)
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
+    }
+    /**
+        @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
+    {
 …
+    }
+    /**
+        @brief Returns true if the current state of the game matches the required access level.
+    */
     bool ConsoleCommand::hasAccess() const
+    {
 …
             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;
 …
+    }
+    /**
+        @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
+        {
 …
+    }
+    /**
+        @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
+        {
 …
+    }
+    /**
+        @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();
 …
+    }
+    /**
+        @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);
 …
+    }
+    /**
+        @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_;
 …
         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_;
 …
         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()
+    {
 …
+    }
+    /**
+        @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_)
 …
+    }
+    /**
+        @brief Sets the functor to NULL (which also deactivates the command).
+    */
     void ConsoleCommand::resetFunction()
+    {
 …
+    }
+    /**
+        @brief Returns the current executor which can be used to execute the command.
+    */
     const ExecutorPtr& ConsoleCommand::getExecutor() const
+    {
 …
+    }
+    /**
+        @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;
 …
+    }
+    /**
+        @brief Push a new object to the object-stack.
+    */
     void ConsoleCommand::pushObject(void* object)
+    {
 …
+    }
+    /**
+        @brief Removes the current object from the stack an restores the old object.
+    */
     void ConsoleCommand::popObject()
+    {
 …
+    }
+    /**
+        @brief Returns the current object pointer that is used to execute member-functions.
+    */
     void* ConsoleCommand::getObject() const
+    {
 …
+    }
+    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;
 …
+    }
+    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;
 …
+    }
+    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;
 …
+    }
+    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;
 …
+    }
+    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;
 …
+    }
+    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;
 …
+    }
+    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)
+    {
 …
+    }
+    /**
+        @brief Returns the description of this command.
+    */
     const std::string& ConsoleCommand::getDescription() const
+    {
 …
+    }
+    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)
+    {
 …
+    }
+    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;
+            }
 …
+    }
+    /**
+        @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)
+    {
 …
         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;
+            }
 …
+    }
+    /**
+        @brief Returns the static map that stores all console commands.
+    */
     /* static */ std::map<std::string, std::map<std::string, ConsoleCommand*> >& ConsoleCommand::getCommandMap()
+    {
 …
+    }
+    /**
+        @brief Returns the static map that stores all console commands in lowercase.
+    */
     /* static */ std::map<std::string, std::map<std::string, ConsoleCommand*> >& ConsoleCommand::getCommandMapLC()
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
             return;
+        // check if a command with this name already exists
         if (ConsoleCommand::getCommand(group, name) != 0)
+        {
 …
         else
+        {
+            // add the command to the map
             ConsoleCommand::getCommandMap()[group][name] = command;
             ConsoleCommand::getCommandMapLC()[getLowercase(group)][getLowercase(name)] = command;
 …
+    }
+    /**
+        @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++);
 …
+            }
+            // erase the group if it is empty now
             if (it_group->second.empty())
                 ConsoleCommand::getCommandMap().erase(it_group++);
 …
+        }
+        // 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++);
 …
+            }
+            // erase the group if it is empty now
             if (it_group->second.empty())
                 ConsoleCommand::getCommandMapLC().erase(it_group++);
 …
+    }
+    /**
+        @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;

code/trunk/src/libraries/core/command/ConsoleCommand.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
+/**
+    @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))
 …
 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
+    {
 …
     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
+        {
 …
+    }
+    /**
+        @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)
 …
                             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))
+                                {
 …
                             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)
 …
                             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))
+                                {
 …
                             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
             };
 …
             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); }
 …
             bool isActive() const;
             bool hasAccess() const;
+            /// Returns true if the command is currently hidden.
             inline bool isHidden() const
                 { return this->bHidden_; }
 …
             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()
+            {
 …
+            }
+            /// 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; }
 …
             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); }
 …
     };
+    /**
+        @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); }

code/trunk/src/libraries/core/command/ConsoleCommandCompilation.cc

r7284	r7401
26	26	*
27	27	*/
	28
	29	/**
	30	@file
	31	@brief Implementation of some console commands.
	32	*/
28	33
29	34	#include "ConsoleCommandCompilation.h"
…	…
51	56	SetConsoleCommand("calculate", calculate);
52	57
	58	/**
	59	@brief Reads the content of a file and executes the commands in it line by line.
	60	*/
53	61	void source(const std::string& filename)
54	62	{
…	…
86	94	}
87	95
	96	/**
	97	@brief Simply returns the arguments.
	98	*/
88	99	std::string echo(const std::string& text)
89	100	{
…	…
91	102	}
92	103
	104	/**
	105	@brief Writes text to the console, depending on the first argument with or without a line-break after it.
	106	*/
93	107	void puts(bool newline, const std::string& text)
94	108	{
…	…
103	117	}
104	118
	119	/**
	120	@brief Writes text to a file.
	121	*/
105	122	void write(const std::string& filename, const std::string& text)
106	123	{
…	…
118	135	}
119	136
	137	/**
	138	@brief Appends text to a file.
	139	*/
120	140	void append(const std::string& filename, const std::string& text)
121	141	{
…	…
133	153	}
134	154
	155	/**
	156	@brief Reads text from a file
	157	*/
135	158	std::string read(const std::string& filename)
136	159	{
…	…
158	181	}
159	182
	183	/**
	184	@brief Parses the mathematical expression and returns the result.
	185	*/
160	186	float calculate(const std::string& calculation)
161	187	{

code/trunk/src/libraries/core/command/ConsoleCommandCompilation.h

-                      r7284
+                      r7401
  */
+/**
+    @file
+    @ingroup Command ConsoleCommand
+    @brief Declaration of some console commands.
+*/
 #ifndef _ConsoleCommandCompilation_H__
 #define _ConsoleCommandCompilation_H__

code/trunk/src/libraries/core/command/Executor.cc

-                      r7284
+                      r7401
  *   Inspiration: Executor by Benjamin Grauer
  */
+/**
+    @file
+    @brief Implementation of orxonox::Executor
+*/
 #include "Executor.h"
 …
 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)
+    {
 …
+    }
+    /**
+        @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_)
+    {
 …
+    }
+    /**
+        @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
+    {
 …
+    }
+    /**
+        @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();
 …
         // 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)
 …
+    }
+    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
+    {

code/trunk/src/libraries/core/command/Executor.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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
+    {
 …
             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
+            {
 …
             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
+            {
 …
         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);
 …
+            }
-            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 = "")
+    {
 …
+    }
+    /// Creates a new ExecutorMember that wraps a given FunctorMember.
     template <class T>
     inline ExecutorMemberPtr<T> createExecutor(const FunctorMemberPtr<T>& functor, const std::string& name = "")
 …
+    }
+    /// Creates a new ExecutorStatic that wraps a given FunctorStatic.
     inline ExecutorStaticPtr createExecutor(const FunctorStaticPtr& functor, const std::string& name = "")
+    {

code/trunk/src/libraries/core/command/ExecutorPtr.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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>

code/trunk/src/libraries/core/command/Functor.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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
+    {
 …
             struct Type
+            {
+                /// Defines the type of a function (static or member)
                 enum Enum
+                {
 …
         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;
     };
 …
     namespace detail
+    {
+        // helper class to determine if a functor is static or not
         template <class O>
         struct FunctorTypeStatic
 …
+    }
+    /**
+        @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);
 …
+            }
+            // 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); };
 …
         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); } };
 …
         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
 …
         { enum { result = false }; };
+        // Helper class to count the number of parameters
         template <class P1, class P2, class P3, class P4, class P5>
         struct FunctorParamCount
 …
+    }
+    /**
+        @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)
+            {
 …
+            }
+            // see Functor::clone()
             FunctorPtr clone()
+            {
 …
+            }
+            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
+            {
 …
+            }
+            // see Functor::hasReturnvalue()
             bool hasReturnvalue() const
+            {
 …
+            }
+            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>();
 …
+            }
+            // see Functor::getTypenameReturnvalue()
             std::string getTypenameReturnvalue() const
+            {
 …
+            }
+            // see Functor::getHeaderIdentifier()
             const std::type_info& getHeaderIdentifier() const
+            {
 …
+            }
+            // see Functor::getHeaderIdentifier(unsigned int)
             const std::type_info& getHeaderIdentifier(unsigned int params) const
+            {
 …
     };
     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
+}

code/trunk/src/libraries/core/command/FunctorPtr.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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>
 …
     };
+    /// 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> >

code/trunk/src/libraries/core/command/IOConsole.h

-                      r7287
+                      r7401
  */
+/**
+    @file
+    @ingroup Command ShellConsole
+*/
 #include "OrxonoxConfig.h"

code/trunk/src/libraries/core/command/IOConsolePOSIX.h

-                      r7287
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup Command ShellConsole
+*/
 #ifndef _IOConsole_H__

code/trunk/src/libraries/core/command/IOConsoleWindows.h

-                      r7287
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup Command ShellConsole
+*/
 #ifndef _IOConsole_H__

code/trunk/src/libraries/core/command/IRC.cc

r7284	r7401
27	27	*/
28	28
	29	/**
	30	@file
	31	@brief Implementation of the IRC class and the IRC console commands.
	32	*/
	33
29	34	#include "IRC.h"
30	35
…	…
39	44	namespace orxonox
40	45	{
41		static const unsigned int IRC_TCL_THREADID = 1421421421;
	46	static const unsigned int IRC_TCL_THREADID = 1421421421; ///< The ID of the thread in TclThreadManager that is used for the IRC connection
42	47
43	48	SetConsoleCommand("IRC", "say", &IRC::say);
…	…
45	50	SetConsoleCommand("IRC", "nick", &IRC::nick);
46	51
	52	/**
	53	@brief Returns the only existing instance of IRC.
	54	*/
	55	IRC& IRC::getInstance()
	56	{
	57	static IRC instance;
	58	return instance;
	59	}
	60
	61	/**
	62	@brief Constructor: Doesn't yet connect to IRC nor does it create a Tcl interpreter.
	63	The IRC object will automatically connect to the IRC server if one of the registered
	64	console commands is used the first time.
	65	*/
47	66	IRC::IRC()
48	67	{
…	…
50	69	}
51	70
	71	/**
	72	@brief Creates and initializes a new multithreaded Tcl-interpreter and defines some callbacks to display IRC-messages in the console.
	73	*/
52	74	void IRC::initialize()
53	75	{
…	…
70	92	}
71	93
72		IRC& IRC::getInstance()
73		{
74		static IRC instance;
75		return instance;
76		}
77
	94	/**
	95	@brief Executes a Tcl-command on the Tcl-interpreter.
	96	*/
78	97	bool IRC::eval(const std::string& command)
79	98	{
…	…
96	115	}
97	116
	117	/// Console command: Sends a message to the current channel on the IRC server.
98	118	void IRC::say(const std::string& message)
99	119	{
…	…
102	122	}
103	123
	124	/// Console command: Sends a message to a given channel or nickname on the IRC server.
104	125	void IRC::msg(const std::string& channel, const std::string& message)
105	126	{
…	…
108	129	}
109	130
	131	/// Console command: Changes the nickname on the IRC server.
110	132	void IRC::nick(const std::string& nickname)
111	133	{
…	…
114	136	}
115	137
	138	/// Tcl-callback: Prints a message that was received from the current IRC channel to the console.
116	139	void IRC::tcl_say(Tcl::object const &channel, Tcl::object const &nick, Tcl::object const &args)
117	140	{
…	…
119	142	}
120	143
	144	/// Tcl-callback: Prints a private message that was received from a user to the console.
121	145	void IRC::tcl_privmsg(Tcl::object const &query, Tcl::object const &nick, Tcl::object const &args)
122	146	{
…	…
124	148	}
125	149
	150	/// Tcl-callback: Prints an action-message (usually /me ...) that was received from the current IRC channel to the console.
126	151	void IRC::tcl_action(Tcl::object const &channel, Tcl::object const &nick, Tcl::object const &args)
127	152	{
…	…
129	154	}
130	155
	156	/// Tcl-callback: Prints all kinds of information that were received from the IRC server or channel (connection info, join, part, modes, ...) to the console.
131	157	void IRC::tcl_info(Tcl::object const &channel, Tcl::object const &args)
132	158	{

code/trunk/src/libraries/core/command/IRC.h

-                      r7284
+                      r7401
  */
+/**
+    @file
+    @ingroup Command Tcl
+    @brief Declaration of IRC helper class, used for IRC connections using Tcl.
+*/
 #ifndef _IRC_H__
 #define _IRC_H__
 …
 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
+    {
 …
             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
     };
+}

code/trunk/src/libraries/core/command/Shell.cc

r7284	r7401
26	26	*
27	27	*/
	28
	29	/**
	30	@file
	31	@brief Implementation of the Shell class.
	32	*/
28	33
29	34	#include "Shell.h"
…	…
48	53	unsigned int Shell::cacheSize_s;
49	54
	55	/**
	56	@brief Constructor: Initializes the values and registers itself at OutputHandler.
	57	@param consoleName The name of the shell - used to define the name of the soft-debug-level config-value
	58	@param bScrollable If true, the user is allowed to scroll through the output-lines
	59	*/
50	60	Shell::Shell(const std::string& consoleName, bool bScrollable)
51	61	: OutputListener(consoleName)
…	…
88	98	}
89	99
	100	/**
	101	@brief Destructor: Unregisters the shell from OutputHandler.
	102	*/
90	103	Shell::~Shell()
91	104	{
…	…
94	107	}
95	108
	109	/**
	110	@brief Defines the config values.
	111	*/
96	112	void Shell::setConfigValues()
97	113	{
…	…
113	129	}
114	130
	131	/**
	132	@brief Config-value callback: Called when the history offset has changed in the config-file.
	133	*/
115	134	void Shell::commandHistoryOffsetChanged()
116	135	{
…	…
119	138	}
120	139
	140	/**
	141	@brief Config-value callback: Called when the length of the command history has changed in the config-file.
	142	*/
121	143	void Shell::commandHistoryLengthChanged()
122	144	{
…	…
131	153	}
132	154
	155	/**
	156	@brief Registers this object as listener for different key-events at the input buffer.
	157	*/
133	158	void Shell::configureInputBuffer()
134	159	{
…	…
159	184	}
160	185
161		/*
162		void Shell::history()
163		{
164		Shell& instance = Shell::getInstance();
165
166		for (unsigned int i = instance.historyOffset_; i < instance.commandHistory_.size(); ++i)
167		instance.addOutput(instance.commandHistory_[i] + '\n', -1);
168		for (unsigned int i = 0; i < instance.historyOffset_; ++i)
169		instance.addOutput(instance.commandHistory_[i] + '\n', -1);
170		}
171		*/
172
	186	/**
	187	@brief Registers a shell listener which listens for changes in this shell.
	188	*/
173	189	void Shell::registerListener(ShellListener* listener)
174	190	{
…	…
176	192	}
177	193
	194	/**
	195	@brief Unregisters a shell listener.
	196	*/
178	197	void Shell::unregisterListener(ShellListener* listener)
179	198	{
…	…
187	206	}
188	207
	208	/**
	209	@brief Changes the position of the cursor in the input buffer.
	210	*/
189	211	void Shell::setCursorPosition(unsigned int cursor)
190	212	{
…	…
193	215	}
194	216
	217	/**
	218	@brief Sends output to the internal output buffer.
	219	*/
195	220	void Shell::addOutput(const std::string& text, LineType type)
196	221	{
…	…
199	224	}
200	225
	226	/**
	227	@brief Clears the list of output-lines.
	228	*/
201	229	void Shell::clearOutput()
202	230	{
…	…
210	238	}
211	239
	240	/**
	241	@brief Returns an iterator to the newest line of output (except if the user is currently scrolling through the output).
	242	*/
212	243	Shell::LineList::const_iterator Shell::getNewestLineIterator() const
213	244	{
…	…
218	249	}
219	250
	251	/**
	252	@brief Returns the end() iterator of the list of output-lines.
	253	*/
220	254	Shell::LineList::const_iterator Shell::getEndIterator() const
221	255	{
…	…
223	257	}
224	258
	259	/**
	260	@brief Adds a command to the history of entered commands and writes it to the config-file.
	261	*/
225	262	void Shell::addToHistory(const std::string& command)
226	263	{
…	…
237	274	}
238	275
	276	/**
	277	@brief Returns a command from the history of entered commands (usually the most recent history entry, but the user can scroll through the history).
	278	*/
239	279	const std::string& Shell::getFromHistory() const
240	280	{
…	…
246	286	}
247	287
	288	/**
	289	@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.
	290	*/
248	291	void Shell::outputChanged(int lineType)
249	292	{
…	…
251	294	do
252	295	{
	296	// get the first line from the buffer
253	297	std::string output;
254	298	std::getline(this->outputBuffer_, output);
255	299
	300	// check the state of the buffer
256	301	bool eof = this->outputBuffer_.eof();
257	302	bool fail = this->outputBuffer_.fail();
258	303	if (eof)
259		this->outputBuffer_.flush();
	304	this->outputBuffer_.flush(); // check if more output was received in the meantime
260	305	if (eof \|\| fail)
261		this->outputBuffer_.clear();
	306	this->outputBuffer_.clear(); // clear the error flags
	307
	308	// the line is terminated with a line-break if neither an error occurred nor the end of the file was reached
262	309	newline = (!eof && !fail);
263	310
	311	// no output retrieved - break the loop
264	312	if (!newline && output.empty())
265	313	break;
266	314
	315	// check if the last line was terminated with a line-break
267	316	if (this->bFinishedLastLine_)
268	317	{
	318	// yes it was - push the new line to the list
269	319	this->outputLines_.push_front(std::make_pair(output, static_cast<LineType>(lineType)));
270	320
	321	// adjust the scroll position if needed
271	322	if (this->scrollPosition_)
272	323	this->scrollPosition_++;
273	324	else
274	325	this->scrollIterator_ = this->outputLines_.begin();
275
276		~~this->bFinishedLastLine_ = newline;~~
277	326
278	327	if (!this->scrollPosition_)
…	…
281	330	else
282	331	{
	332	// no it wasn't - add the new output to the last line
283	333	this->outputLines_.front().first += output;
284		~~this->bFinishedLastLine_ = newline;~~
285	334	this->updateListeners<&ShellListener::onlyLastLineChanged>();
286	335	}
	336
	337	// remember if the last line was terminated with a line-break
287	338	this->bFinishedLastLine_ = newline;
288	339
289		} while (newline);
290		}
291
	340	} while (newline); // loop as long as more lines are in the buffer
	341	}
	342
	343	/**
	344	@brief Clears the text in the input buffer.
	345	*/
292	346	void Shell::clearInput()
293	347	{
…	…
298	352	}
299	353
300		~~void Shell::setPromptPrefix(const std::string& str)~~
301		{
302		}
303
304	354
305	355	// ##########################################
…	…
307	357	// ##########################################
308	358
	359	/// InputBuffer callback: Called if the input changes.
309	360	void Shell::inputChanged()
310	361	{
…	…
313	364	}
314	365
	366	/// InputBuffer callback: Called if a key was pressed that executes a command (usually [return]).
315	367	void Shell::execute()
316	368	{
…	…
340	392	}
341	393
	394	/// InputBuffer callback: Called if a key was pressed that shows hints and completes a command (usually [tab]).
342	395	void Shell::hintAndComplete()
343	396	{
…	…
349	402	}
350	403
	404	/// InputBuffer callback: Called if a key was pressed that deletes the character before the cursor (usually [backspace]).
351	405	void Shell::backspace()
352	406	{
…	…
356	410	}
357	411
358		void Shell::exit()
359		{
360		if (this->inputBuffer_->getSize() > 0)
361		{
362		this->clearInput();
363		return;
364		}
365
366		this->clearInput();
367		this->scrollPosition_ = 0;
368		this->scrollIterator_ = this->outputLines_.begin();
369
370		this->updateListeners<&ShellListener::exit>();
371		}
372
	412	/// InputBuffer callback: Called if a key was pressed that deletes the character after the cursor (usually [delete]).
373	413	void Shell::deleteChar()
374	414	{
…	…
377	417	}
378	418
	419	/// InputBuffer callback: Called if a key was pressed that moves the input cursor the right (usually [arrow right]).
379	420	void Shell::cursorRight()
380	421	{
…	…
383	424	}
384	425
	426	/// InputBuffer callback: Called if a key was pressed that moves the input cursor the left (usually [arrow left]).
385	427	void Shell::cursorLeft()
386	428	{
…	…
389	431	}
390	432
	433	/// InputBuffer callback: Called if a key was pressed that moves the input cursor the end of the input line (usually [end]).
391	434	void Shell::cursorEnd()
392	435	{
…	…
395	438	}
396	439
	440	/// InputBuffer callback: Called if a key was pressed that moves the input cursor the beginning of the input line (usually [home]).
397	441	void Shell::cursorHome()
398	442	{
…	…
401	445	}
402	446
	447	/// InputBuffer callback: Called if a key was pressed that scrolls upwards through the history of entered commands (usually [arrow up]).
403	448	void Shell::historyUp()
404	449	{
…	…
410	455	}
411	456
	457	/// InputBuffer callback: Called if a key was pressed that scrolls downwards through the history of entered commands (usually [arrow down]).
412	458	void Shell::historyDown()
413	459	{
…	…
419	465	}
420	466
	467	/// 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.
421	468	void Shell::historySearchUp()
422	469	{
…	…
437	484	}
438	485
	486	/// 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.
439	487	void Shell::historySearchDown()
440	488	{
…	…
455	503	}
456	504
	505	/// InputBuffer callback: Called if a key was pressed that scrolls upwards through the output history (usually [page up]). Only if the shell is scrollable.
457	506	void Shell::scrollUp()
458	507	{
…	…
466	515	}
467	516
	517	/// InputBuffer callback: Called if a key was pressed that scrolls downwards through the output history (usually [page down]). Only if the shell is scrollable.
468	518	void Shell::scrollDown()
469	519	{
…	…
476	526	}
477	527	}
	528
	529	/// InputBuffer callback: Called if a key was pressed that clears the text in the input buffer or closes the shell (usually [esc]).
	530	void Shell::exit()
	531	{
	532	if (this->inputBuffer_->getSize() > 0)
	533	{
	534	this->clearInput();
	535	return;
	536	}
	537
	538	this->clearInput();
	539	this->scrollPosition_ = 0;
	540	this->scrollIterator_ = this->outputLines_.begin();
	541
	542	this->updateListeners<&ShellListener::exit>();
	543	}
478	544	}

code/trunk/src/libraries/core/command/Shell.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 namespace orxonox
+{
+    /**
+        @brief An interface, used to get a notification if the state of the Shell changes.
+    */
     class _CoreExport ShellListener
+    {
 …
         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
+            {
 …
             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(); }
 …
             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; }
 …
             void exit();
+            /// Iterates through all registered @ref ShellListener "shell listeners" and calls the function @a F.
             template <void (ShellListener::*F)()>
             void updateListeners()
 …
+            }
+            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
     };
+}

code/trunk/src/libraries/core/command/TclBind.cc

r7284	r7401
49	49	TclBind* TclBind::singletonPtr_s = 0;
50	50
	51	/**
	52	@brief Constructor: Initializes the Tcl-interpreter with a given data path.
	53	@param datapath Path to the directory that contains the Orxonox-specific Tcl-files
	54	*/
51	55	TclBind::TclBind(const std::string& datapath)
52	56	{
…	…
56	60	}
57	61
	62	/**
	63	@brief Destructor: Deletes the Tcl-interpreter.
	64	*/
58	65	TclBind::~TclBind()
59	66	{
…	…
62	69	}
63	70
	71	/**
	72	@brief Defines the path to the directory that contains the Orxonox-specific Tcl-files and initializes the Tcl-interpreter accordingly.
	73	*/
64	74	void TclBind::setDataPath(const std::string& datapath)
65	75	{
…	…
71	81	}
72	82
	83	/**
	84	@brief Creates and initializes the Tcl-interpreter by registering all callbacks and defining some useful functions.
	85	*/
73	86	void TclBind::initializeTclInterpreter()
74	87	{
…	…
96	109	}
97	110
	111	/**
	112	@brief Creates and initializes a new Tcl-interpreter and calls the Orxonox-specific
	113	init.tcl script that defines some special functions which are required by Orxonox.
	114	*/
98	115	Tcl::interpreter* TclBind::createTclInterpreter()
99	116	{
…	…
116	133	}
117	134
	135	/**
	136	@brief Returns the path to the Tcl-library (not the Orxonox-specific Tcl-files).
	137	*/
118	138	std::string TclBind::getTclLibraryPath()
119	139	{
…	…
128	148	}
129	149
	150	/**
	151	@brief Callback: Used to send an Orxonox-command from Tcl to the CommandExecutor and to send its result back to Tcl.
	152	*/
130	153	std::string TclBind::tcl_query(Tcl::object const &args)
131	154	{
…	…
151	174	}
152	175
	176	/**
	177	@brief Callback: Used to send an Orxonox-command from Tcl to the CommandExecutor.
	178	*/
153	179	void TclBind::tcl_execute(Tcl::object const &args)
154	180	{
…	…
162	188	}
163	189
	190	/**
	191	@brief Console command, executes Tcl code. Can be used to bind Tcl-commands to a key, because native
	192	Tcl-commands can not be evaluated and are thus not supported by the key-binder.
	193	*/
164	194	std::string TclBind::tcl(const std::string& tclcode)
165	195	{
…	…
182	212	}
183	213
	214	/**
	215	@brief Console command and implementation of the Tcl-feature "bgerror" which is called if an error
	216	occurred in the background of a Tcl-script.
	217	*/
184	218	void TclBind::bgerror(const std::string& error)
185	219	{
…	…
187	221	}
188	222
	223	/**
	224	@brief Executes Tcl-code and returns the return-value.
	225	@param tclcode A string that contains Tcl-code
	226	@param error A pointer to an integer (or NULL) that is used to write an error-code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
	227	@return Returns the return-value of the executed code (or an empty string if there's no return-value)
	228	*/
189	229	std::string TclBind::eval(const std::string& tclcode, int* error)
190	230	{
…	…
194	234	try
195	235	{
	236	// execute the code
196	237	return TclBind::getInstance().interpreter_->eval(tclcode);
197	238	}

code/trunk/src/libraries/core/command/TclBind.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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>
+    {
 …
             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);
 …
         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
     };
+}

code/trunk/src/libraries/core/command/TclThreadList.h

-                      r7284
+                      r7401
  */
+/**
+    @file
+    @ingroup Command Tcl
+    @brief Definition of TclThreadList.
+*/
 #ifndef _TclThreadList_H__
 #define _TclThreadList_H__
 …
 namespace orxonox
+{
+    /**
+        @brief A thread-safe implementation of a message queue, used by TclThreadManager.
+    */
     template <class T>
     class TclThreadList
 …
             /**
                 @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

code/trunk/src/libraries/core/command/TclThreadManager.cc

-                      r7284
+                      r7401
+ *
  */
+/**
+    @file
+    @brief Implementation of TclThreadManager.
+*/
 #include "TclThreadManager.h"
 …
     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
 …
     /**
         @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
     */
 …
         @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)
 …
     /**
         @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
     */
 …
     /**
         @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
 …
         @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
 …
         @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)
 …
         @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)
 …
+            {
                 // 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
 …
                     // 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.");
+                }
+            }
 …
         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;
+        }
 …
                 output += ' ';
             output += getConvertedValue<unsigned int, std::string>(*it);
+            output += multi_cast<std::string>(*it);
+        }
         return output;
 …
         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 "";
+        }

code/trunk/src/libraries/core/command/TclThreadManager.h

-                      r7284
+                      r7401
+ *
  */
+/**
+    @file
+    @ingroup Command Tcl
+    @brief Declaration of TclThreadManager, used to create multithreaded Tcl interpreters.
+*/
 #ifndef _TclThreadManager_H__

code/trunk/src/libraries/core/input/Button.cc

r7284	r7401
176	176	// evaluate the command
177	177	CommandEvaluation eval = CommandExecutor::evaluate(commandStr);
178		if (!eval.isValid() \|\| eval.evaluate~~Param~~s(true))
	178	if (!eval.isValid() \|\| eval.evaluateArguments(true))
179	179	{
180	180	parseError("Command evaluation of \"" + commandStr + "\"failed.", true);

code/trunk/src/libraries/core/input/InputCommands.cc

r5781	r7401
53	53	if (this->abs_ != 0.0f \|\| this->rel_ != 0.0f)
54	54	{
55		evaluation_.setEvaluated~~Parameter~~(paramIndex_, Vector2(abs_, rel_));
	55	evaluation_.setEvaluatedArgument(paramIndex_, Vector2(abs_, rel_));
56	56	// reset
57	57	rel_ = 0.0;

code/trunk/src/libraries/core/input/InputManager.cc

-                      r7284
+                      r7401
         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()

code/trunk/src/libraries/core/input/InputManager.h

-                      r6746
+                      r7401
         @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

code/trunk/src/libraries/core/input/InputState.h

r7284	r7401
128	128	void resetExpiration() { bExpired_ = false; }
129	129
130		//! Updates one specific device handler with ~~#device#~~Updated
	130	//! Updates one specific device handler with deviceUpdated
131	131	void update(float dt, unsigned int device);
132	132	//! Updates all handlers with allDevicesUpdated

code/trunk/src/libraries/core/input/KeyBinder.cc

-                      r6536
+                      r7401
     @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)
 …
     /**
     @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)

code/trunk/src/libraries/network/ClientInformation.cc

-                      r6417
+                      r7401
   * 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
   */
 …
   * 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
   */

code/trunk/src/libraries/network/GamestateClient.cc

-                      r7163
+                      r7401
   * @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?

code/trunk/src/libraries/network/synchronisable/Synchronisable.cc

-                      r7183
+                      r7401
    * 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
 …
    * @param mem pointer to the bytestream
    * @param mode same as in getData
+   * @param forceCallback FIXME - add doc!
    * @return true/false
    */
 …
    * 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
    */

code/trunk/src/libraries/tools/ResourceCollection.cc

r5781	r7401
52	52	}
53	53
54		void ResourceCollection::XMLPort(Element& xmlElement, XMLPort::Mode mode)
	54	void ResourceCollection::XMLPort(Element& xmlelement, XMLPort::Mode mode)
55	55	{
56		XMLPortParam(ResourceCollection, "resourceGroup", setResourceGroup, getResourceGroup, xmlElement, mode);
57		XMLPortObject(ResourceCollection, ResourceLocation, "", addResourceLocation, getResourceLocation, xmlElement, mode);
	56	XMLPortParam(ResourceCollection, "resourceGroup", setResourceGroup, getResourceGroup, xmlelement, mode);
	57	XMLPortObject(ResourceCollection, ResourceLocation, "", addResourceLocation, getResourceLocation, xmlelement, mode);
58	58	}
59	59

code/trunk/src/libraries/tools/ResourceCollection.h

r6105	r7401
44	44	virtual ~ResourceCollection();
45	45
46		virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	46	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
47	47
48	48	void setResourceGroup(const std::string& resourceGroup);

code/trunk/src/libraries/tools/ResourceLocation.cc

-                      r7174
+                      r7401
+    }
     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.");

code/trunk/src/libraries/tools/ResourceLocation.h

r5781	r7401
46	46	virtual ~ResourceLocation();
47	47
48		virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	48	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
49	49
50	50	void setPath(const std::string& path) { path_ = path; }

code/trunk/src/libraries/tools/Timer.cc

-                      r7284
+                      r7401
  */
+/**
+    @file
+    @brief Implementation of the Timer class.
+*/
 #include "Timer.h"
 …
     /**
         @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
 …
     /**
         @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
     */
 …
     /**
         @brief Kills all delayed commands.
+        @brief Console-command: Kills all scheduled commands that were delayed using delay().
     */
     void killdelays()
 …
     /**
+        @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)
 …
     /**
         @brief Executes the executor.
+        @brief Calls the executor and destroys the timer if requested.
     */
     void Timer::run()

code/trunk/src/libraries/tools/Timer.h

-                      r7284
+                      r7401
  */
+/*!
+/**
+    @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.
 */
 …
     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
+    {
 …
             /**
                 @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)
 …
             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; }
 …
             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
     };
+}

code/trunk/src/libraries/util/Clipboard.cc

-                      r6417
+                      r7401
     /**
+        @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
     */
 …
 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)
 …
     /**
         @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()

code/trunk/src/libraries/util/Clipboard.h

-                      r5781
+                      r7401
 /**
     @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.
 */

code/trunk/src/libraries/util/Clock.cc

-                      r6417
+                      r7401
+    }
-    /**
-    @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()
+    {

code/trunk/src/libraries/util/Clock.h

-                      r6417
+                      r7401
  */
+/**
+    @file
+    @ingroup Util
+*/
 #ifndef _Clock_H__
 #define _Clock_H__
 …
 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)
     };
+}

code/trunk/src/libraries/util/Convert.cc

r7163	r7401
32	32	namespace orxonox
33	33	{
34		~~//template <class FromType, class ToType>~~
35	34	bool ConverterExplicit<std::string, bool>::convert(bool* output, const std::string& input)
36	35	{

code/trunk/src/libraries/util/Convert.h

-                      r7305
+                      r7401
  */
+/*!
+    @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++.
 */
 …
 #include "ImplicitConversion.h"
-////////////////////////////////////
-//// ACTUAL CONVERSION SEQUENCE ////
-////////////////////////////////////
-/*
-    There is a distinct priority when choosing the right conversion function:
-    Overwrite:
-. (Partial) template specialisation of ConverterExplicit::convert()
-    Fallbacks:
-. Any possible implicit conversion. This includes 'FooBar' --> 'int' if FooBar defines operator float().
-. Global or member operators for stringstream when converting from or to std::string (or FROM const char*)
-. (Partial) template specialisation of ConverterFallback::convert()
-. 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
+{
 …
     ///////////////////
     // Default template. No conversion available at all.
+    /// Default template. No conversion available at all.
     template <class FromType, class ToType>
     struct ConverterFallback
 …
     };
     // 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*>
 …
+        }
     };
-    ////////////
-    // 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>());
+    }
+}
 …
 ///////////////////////
+// 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
 …
 /////////////
+/// 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)
 …
+}
 // 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>
 …
+    {
         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)
+        {
 …
 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>
 …
+    {
         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))
+        {
 …
 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>)
 …
+    }
     // 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>)
 …
     ////////////////////////////////
+    // 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
 …
         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>());
+        }
 …
     @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>
 …
         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.
 …
+    }
     // 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;
 …
+    }
-    // 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>
 …
     };
     // 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>
 …
+        }
     };
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<unsigned char, std::string>
 …
+        }
     };
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<std::string, char>
 …
+        }
     };
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<std::string, unsigned char>
 …
     // bool to std::string
+    /// Conversion from bool to std::string
     template <>
     struct ConverterExplicit<bool, std::string>
 …
     };
     // std::string to bool
+    /// Conversion from std::string to bool
     template <>
     struct _UtilExport ConverterExplicit<std::string, bool>

code/trunk/src/libraries/util/Debug.h

-                      r6443
+                      r7401
 /**
+    @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.
 …
      - 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:
 : Very important output
 : Errors
 : Warnings
 : Information
 : Debug information
 : More debug information
 : 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;
 …
     COUT(3) << "Info: It's Monday" << std::endl;
     COUT(4) << "Debug: x is 1.23456" << std::endl;
+    @endcode
 */
 …
 /**
 @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)                                                    \

code/trunk/src/libraries/util/Exception.cc

-                      r7174
+                      r7401
     { }
-    /**
-    @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
+    {
 …
+    }
-    //! Returns the error description
     const char* Exception::what() const throw()
+    {

code/trunk/src/libraries/util/Exception.h

-                      r6417
+                      r7401
 /**
+    @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.
 */
 …
 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
 …
         @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,
 …
         //! 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
 …
     };
 //! 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                               \
 …
     // 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);
 …
     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.
 …
+    }
+/**
+@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) \

code/trunk/src/libraries/util/ExprParser.h

-                      r6417
+                      r7401
 /**
+  @file
+  @brief Declaration of FloatParser
+@file
+@ingroup Util
+@brief Declaration of FloatParser
 */
 …
 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
+    {

code/trunk/src/libraries/util/ImplicitConversion.h

r7305	r7401
29	29	/**
30	30	@file
	31	@ingroup Util
31	32	@brief Declaration of various helper templates.
32	33	*/

code/trunk/src/libraries/util/Math.cc

-                      r7284
+                      r7401
         @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)
 …
         @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)
 …
         @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)
 …
+    }
+    /**
+        @brief Returns a unique number. This function will never return the same value twice.
+    */
     unsigned long getUniqueNumber()
+    {

code/trunk/src/libraries/util/Math.h

-                      r7184
+                      r7401
 /**
+    @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.
 */
 …
     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)
+    }
 …
     /**
         @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
 …
     /**
         @brief Returns the square value (x^2).
+        @brief Returns the squared value (x^2).
     */
     template <typename T>
 …
     /**
         @brief Returns the cube value (x^3).
+        @brief Returns the cubed value (x^3).
     */
     template <typename T>
 …
     /**
         @brief Rounds the value.
+        @brief Rounds the value to the nearest integer.
     */
     template <typename T>
 …
         @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>
 …
+    }
+    /**
+        @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()
 …
     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
 …
     /**
         @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>
 …
     /**
         @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>
 …
     /**
         @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()
 …
     /**
         @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
     */
 …
     /**
         @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
 …
     _UtilExport unsigned long getUniqueNumber();
+    /**
+        @brief A Vector class containing two integers @a x and @a y.
+    */
     class IntVector2
+    {
 …
     };
+    /**
+        @brief A Vector class containing three integers @a x, @a y, and @a z.
+    */
     class IntVector3
+    {

code/trunk/src/libraries/util/MathConvert.h

-                      r6417
+                      r7401
 /**
+    @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)
 */
 …
     ////////////////////
     // Vector2 to std::string
+    /// Ogre::Vector2 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector2, std::string>
 …
     };
     // Vector3 to std::string
+    /// Ogre::Vector3 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector3, std::string>
 …
     };
     // Vector4 to std::string
+    /// Ogre::Vector4 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector4, std::string>
 …
     };
     // Quaternion to std::string
+    /// Ogre::Quaternion to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Quaternion, std::string>
 …
     };
     // ColourValue to std::string
+    /// Ogre::ColourValue to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::ColourValue, std::string>
 …
     ////////////////////
     // 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); };
 …
     ///////////////////////////////
     // From Radian
+    /// Delegates conversions from Radian to conversions from float
     template <class ToType>
     struct ConverterFallback<orxonox::Radian, ToType>
 …
     };
     // From Degree
+    /// Delegates conversions from Degree to conversions from float
     template <class ToType>
     struct ConverterFallback<orxonox::Degree, ToType>
 …
     };
     // To Radian
+    /// Delegates conversions to Radian to conversions to float
     template <class FromType>
     struct ConverterFallback<FromType, orxonox::Radian>
 …
     };
     // To Degree
+    /// Delegates conversions to Degree to conversions to float
     template <class FromType>
     struct ConverterFallback<FromType, orxonox::Degree>

code/trunk/src/libraries/util/MultiType.cc

-                      r5738
+                      r7401
+    }
     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.
+}

code/trunk/src/libraries/util/MultiType.h

-                      r7284
+                      r7401
 /**
+    @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
 …
      - 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
 …
          - 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
 …
             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_; }
 …
             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);
 …
             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)
+            {
 …
                     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_); }
 …
             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; }
 …
     };
     /** @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);
 …
     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)); } }
+}

code/trunk/src/libraries/util/MultiTypeValue.h

-                      r6417
+                      r7401
 /**
     @file
+    @ingroup MultiType
     @brief Declaration and Implementation of the MT_Value<T> class.
 …
+    {
     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)
+        {
 …
+        }
         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
     };

code/trunk/src/libraries/util/OrxAssert.h

-                      r6105
+                      r7401
 /**
 @file
+@ingroup ExceptionAssertion
 @brief
     Declaration of custom assertion facilities
 …
 #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); \

code/trunk/src/libraries/util/OrxEnum.h

-                      r5738
+                      r7401
 /**
+@file
+@brief
+    Declaration of the OrxEnum class.
+    @file
+    @ingroup Util
 */
 …
 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
 …
         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_); }
 …
+}
+/// See orxonox::OrxEnum for more info
 #define OrxEnumConstructors(enumName)                        \
 enumName() { }                                               \

code/trunk/src/libraries/util/OutputHandler.cc

-                      r6417
+                      r7401
         @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()
 …
     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
     };
 …
         @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()
 …
     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
     };

code/trunk/src/libraries/util/OutputHandler.h

-                      r7284
+                      r7401
 /**
 @file
+@ingroup Util Output
 @brief
     Declaration of classes related to output (logging).
+    Declaration of classes related to output (logging), most notably OutputHandler and OutputListener.
 */
 …
         Denotes different levels of text output (log output)
 , None   : Very important output
 , Error  : Errors
 , Warning: Warnings
 , Info   : Information
 , Debug  : Debug information
 , Verbose: More debug information
 , 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
 …
     /**
     @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
 …
             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

code/trunk/src/libraries/util/Scope.cc

-                      r5738
+                      r7401
  */
+/**
+    @file
+    @brief Static linkage of the two maps in orxonox::ScopeManager.
+*/
 #include "Scope.h"

code/trunk/src/libraries/util/Scope.h

-                      r7266
+                      r7401
  */
+/**
+@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__
 …
+{
     /**
+        @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
 …
     /**
+        @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
 …
         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>
 …
+            }
+            //! Deactivates the listeners of this scope in case the scope is destroyed or the construction fails.
             void deactivateListeners()
+            {

code/trunk/src/libraries/util/ScopedSingletonManager.cc

-                      r7284
+                      r7401
  */
+/**
+    @file
+    @brief Static linkage of the ScopedSingletonManager maps.
+*/
 #include "ScopedSingletonManager.h"

code/trunk/src/libraries/util/ScopedSingletonManager.h

-                      r7284
+                      r7401
+ *
  */
+/**
+    @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__
 …
 #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; \
 …
     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)
 …
             { }
             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)
 …
+            }
             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)
 …
         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)
 …
+        }
+        //! 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*)
+        {
 …
     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)
 …
+        }
+        //! 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)
+        {
 …
     private:
         T* singletonPtr_;
+        T* singletonPtr_;   ///< Unique instance of the singleton class @a T
     };
+}

code/trunk/src/libraries/util/Serialise.h

r7182	r7401
29	29	/**
30	30	@file
	31	@ingroup Util
31	32	@brief Functions to serialise most of the types/classed used in Orxonox
32	33	*/
…	…
53	54	template <class T> inline bool checkEquality( const T& variable, uint8_t* mem );
54	55
55
	56
56	57	// =========== char*
57
	58
58	59	inline uint32_t returnSize( char*& variable )
59	60	{
60	61	return strlen(variable)+1;
61	62	}
62
	63
63	64	inline void saveAndIncrease( char& variable, uint8_t& mem )
64	65	{
…	…
66	67	mem += returnSize(variable);
67	68	}
68
	69
69	70	inline void loadAndIncrease( char& variable, uint8_t& mem )
70	71	{
…	…
76	77	mem += len;
77	78	}
78
	79
79	80	inline bool checkEquality( char& variable, uint8_t mem )
80	81	{
81	82	return strcmp(variable, (char*)mem)==0;
82	83	}
83
	84
84	85	// =================== Template specialisation stuff =============
85	86
…	…
423	424	return memcmp(&temp, mem, sizeof(uint64_t))==0;
424	425	}
425
	426
426	427	// =========== string
427	428

code/trunk/src/libraries/util/SharedPtr.cc

-                      r7284
+                      r7401
  */
+/**
+    @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;
+        }
+    }
+}

code/trunk/src/libraries/util/SharedPtr.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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
 …
         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_)
+            {
 …
+            }
+            /// 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_)
 …
+            }
+            /// Destructor, decrements the counter and deletes the object if the counter becomes zero.
             inline ~SharedPtr()
+            {
 …
+                    {
                         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)
+            {
 …
+            }
+            /// 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)
 …
+            }
+            /// Casts the pointer to another type
             template <class O>
             inline SharedPtr<O> cast() const
 …
+            }
+            /// Overloaded -> operator, returns the pointer to the managed object.
             inline T* operator->() const
+            {
 …
+            }
+            /// Overloaded * operator, returns a reference ot the managed object.
             inline T& operator*() const
+            {
 …
+            }
+            /// Returns the pointer to the managed object.
             inline T* get() const
+            {
 …
+            }
+            /// Returns true if the pointer is not NULL.
             inline operator bool() const
+            {
 …
+            }
+            /// Swaps the pointer and the counter of two instances of SharedPtr with the same template argument.
             inline void swap(SharedPtr& other)
+            {
 …
         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_)
 …
+            }
             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

code/trunk/src/libraries/util/SignalHandler.h

-                      r5738
+                      r7401
 /**
     @file
+    @ingroup Util
     @brief Declaration of the SignalHandler class.
 */
 …
     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>
+    {
 …
 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>
+    {

code/trunk/src/libraries/util/Singleton.h

-                      r7163
+                      r7401
  */
+/**
+    @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__
 …
         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>
 …
+        }
         //! Constructor resets the singleton instance pointer
+        //! Destructor resets the singleton instance pointer
         ~Singleton()
+        {

code/trunk/src/libraries/util/SmallObjectAllocator.cc

-                      r7284
+                      r7401
  */
+/**
+    @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()
+    {
 …
+    }
+    /**
+        @brief Helper function, used to set the next_ pointer of a Chunk.
+    */
     /* static */ void SmallObjectAllocator::setNext(void* chunk, void* next)
+    {
 …
+    }
+    /**
+        @brief Helper function, returns the next_ pointer of a Chunk
+    */
     /* static */ void* SmallObjectAllocator::getNext(void* chunk)
+    {
 …
+    }
+    /**
+        @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;

code/trunk/src/libraries/util/SmallObjectAllocator.h

-                      r7284
+                      r7401
  */
+/**
+    @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__
 …
 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
         };
 …
             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)
     };
+}

code/trunk/src/libraries/util/StringUtils.cc

-                      r7284
+                      r7401
 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()
+    {
 …
+    }
+    /**
+        @brief Removes all whitespaces from a string.
+        @param str The string to strip
+    */
+    /// Removes all whitespaces from a string.
     void strip(std::string* str)
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
     /**
         @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)
 …
     /**
         @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)
 …
+    }
+    /**
+        @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)
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
     /**
+        @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)
 …
     /**
+        @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)
 …
     /**
         @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 '//'.
 …
+    }
+    /**
+        @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)
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
     /**
         @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)
 …
     /**
         @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)
 …
+    }
+    /**
+        @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)
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
+    }
+    /**
+        @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)
+    {
 …
     /**
         @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)
 …
     /**
         @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
 …
+    }
+    /**
+        @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)

code/trunk/src/libraries/util/StringUtils.h

-                      r7284
+                      r7401
 /**
+    @defgroup String String functions
+    @ingroup Util
+*/
+/**
     @file
+    @ingroup String
     @brief Declaration of several string manipulation functions, used in many parts of the game.
 */

code/trunk/src/libraries/util/SubString.cc

-                      r7284
+                      r7401
  */
+/**
+    @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;
+        }
 …
+    }
+    /**
+     * @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)
+    {
 …
         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();
+        }
 …
+            {
             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;
+                    }
 …
                     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;
+                    }
 …
                         else
+                        {
                             i++;
+                            ++i;
                             continue;
+                        }
 …
                 break;
             case SL_ESCAPE:
                 if (!removeSafemodeChar)
+                if (!bRemoveSafemodeChar)
                     token += line[i];
                 else
 …
                 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;
 …
             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;
 …
                 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;
+                    }
 …
                 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;
+        }
 …
+    }
+    /**
+     * @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;
+    }
+}

code/trunk/src/libraries/util/SubString.h

-                      r7284
+                      r7401
  */
+ /*!
+ * @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__
 …
 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)
     };
+}

code/trunk/src/libraries/util/TriBool.h

-                      r6746
+                      r7401
  */
+/**
+    @file
+    @ingroup Util
+*/
 #ifndef _TriBool_H__
 #define _TriBool_H__
 …
 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
+    {

code/trunk/src/libraries/util/VA_NARGS.h

-                      r7284
+                      r7401
 /**
     @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.
 */

code/trunk/src/libraries/util/mbool.h

-                      r7268
+                      r7401
  */
+/**
+    @file
+    @ingroup Util
+    @brief Declaration and implementation of the @ref orxonox::mbool class.
+*/
 #ifndef _mbool_H__
 #define _mbool_H__
 …
 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_; }
 …
             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
     };
+}

code/trunk/src/modules/CMakeLists.txt

r7164	r7401
19	19
20	20	INCLUDE_DIRECTORIES(
21		~~${CMAKE_SOURCE_DIR}/src/external~~
22	21	${CMAKE_SOURCE_DIR}/src/libraries
23	22	${CMAKE_SOURCE_DIR}/src/orxonox

code/trunk/src/modules/notifications/Notification.cc

r7193	r7401
55	55	@brief
56	56	Constructor. Creates a Notification with the input message.
	57	@param creator
	58	The object that created this Notification
57	59	@param message
58	60	The message of the Notification.

code/trunk/src/modules/notifications/NotificationQueue.cc

-                      r7163
+                      r7401
         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;

code/trunk/src/modules/notifications/NotificationQueue.h

-                      r7164
+                      r7401
         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.
 …
             position = "0.0, 0.0" //The position of the NotificationQueue. (Default is 0.0,0.0)
         />
+        @endcode
     @author
         Damian 'Mozork' Frick
 …
             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.

code/trunk/src/modules/objects/Planet.cc

-                      r7163
+                      r7401
+    }
-    /**
-        @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)
+    {

code/trunk/src/modules/overlays/FadeoutText.h

r5929	r7401
44	44	virtual ~FadeoutText() {}
45	45
46		virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	46	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
47	47	virtual void tick(float dt);
48	48

code/trunk/src/modules/overlays/GUIOverlay.cc

r7163	r7401
52	52	}
53	53
54		void GUIOverlay::XMLPort(Element& xmlElement, XMLPort::Mode mode)
	54	void GUIOverlay::XMLPort(Element& xmlelement, XMLPort::Mode mode)
55	55	{
56		SUPER(GUIOverlay, XMLPort, xmlElement, mode);
	56	SUPER(GUIOverlay, XMLPort, xmlelement, mode);
57	57
58		XMLPortParam(GUIOverlay, "guiname", setGUIName, getGUIName, xmlElement, mode);
	58	XMLPortParam(GUIOverlay, "guiname", setGUIName, getGUIName, xmlelement, mode);
59	59	}
60	60

code/trunk/src/modules/overlays/GUIOverlay.h

r6753	r7401
44	44	virtual ~GUIOverlay();
45	45
46		virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	46	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
47	47
48	48	void setGUIName(const std::string& name);

code/trunk/src/modules/overlays/OverlayText.cc

-                      r6417
+                      r7401
+    }
     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);
+    }

code/trunk/src/modules/overlays/OverlayText.h

r5781	r7401
52	52	virtual ~OverlayText();
53	53
54		virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	54	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
55	55
56	56	void setCaption(const std::string& caption);

code/trunk/src/modules/overlays/hud/HUDBar.cc

-                      r7368
+                      r7401
+    }
     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);
+    }
 …
+    }
     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);
+    }

code/trunk/src/modules/overlays/hud/HUDBar.h

-                      r5781
+                      r7401
         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; }
 …
         virtual ~HUDBar();
         virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
         void clearColours();

code/trunk/src/modules/overlays/hud/HUDHealthBar.h

r6417	r7401
45	45	virtual ~HUDHealthBar();
46	46
47		virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	47	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
48	48	virtual void tick(float dt);
49	49	virtual void changedOwner();

code/trunk/src/modules/overlays/hud/HUDNavigation.cc

-                      r7368
+                      r7401
+}
 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 );
+}

code/trunk/src/modules/overlays/hud/HUDNavigation.h

r7163	r7401
51	51	void setConfigValues();
52	52
53		virtual void XMLPort ( Element& xmlElement, XMLPort::Mode mode );
	53	virtual void XMLPort ( Element& xmlelement, XMLPort::Mode mode );
54	54	virtual void tick ( float dt );
55	55

code/trunk/src/modules/overlays/hud/HUDRadar.cc

r7368	r7401
82	82	}
83	83
84		void HUDRadar::XMLPort(Element& xmlElement, XMLPort::Mode mode)
	84	void HUDRadar::XMLPort(Element& xmlelement, XMLPort::Mode mode)
85	85	{
86		SUPER(HUDRadar, XMLPort, xmlElement, mode);
	86	SUPER(HUDRadar, XMLPort, xmlelement, mode);
87	87
88		XMLPortParam(HUDRadar, "sensitivity", setRadarSensitivity, getRadarSensitivity, xmlElement, mode);
89		XMLPortParam(HUDRadar, "halfDotSizeDistance", setHalfDotSizeDistance, getHalfDotSizeDistance, xmlElement, mode);
90		XMLPortParam(HUDRadar, "maximumDotSize", setMaximumDotSize, getMaximumDotSize, xmlElement, mode);
	88	XMLPortParam(HUDRadar, "sensitivity", setRadarSensitivity, getRadarSensitivity, xmlelement, mode);
	89	XMLPortParam(HUDRadar, "halfDotSizeDistance", setHalfDotSizeDistance, getHalfDotSizeDistance, xmlelement, mode);
	90	XMLPortParam(HUDRadar, "maximumDotSize", setMaximumDotSize, getMaximumDotSize, xmlelement, mode);
91	91	}
92	92

code/trunk/src/modules/overlays/hud/HUDRadar.h

r7163	r7401
49	49	virtual ~HUDRadar();
50	50
51		virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	51	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
52	52	virtual void changedOwner();
53	53

code/trunk/src/modules/overlays/stats/Scoreboard.cc

-                      r6502
+                      r7401
             this->lines_.pop_back();
+        }
+    }
-    /**
-        @brief Initializes the lines.
-    */
-    void Scoreboard::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    {
-        SUPER(Scoreboard, XMLPort, xmlElement, mode);
+    }

code/trunk/src/modules/overlays/stats/Scoreboard.h

r5929	r7401
44	44	virtual ~Scoreboard();
45	45
46		~~virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);~~
47	46	virtual void tick(float dt);
48	47

code/trunk/src/modules/overlays/stats/Stats.cc

-                      r6502
+                      r7401
+    }
-    /**
-        @brief Initializes the Stats panel.
-    */
-    void Stats::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    {
-        OrxonoxOverlay::XMLPort(xmlElement, mode);
+    }
     void Stats::tick(float dt)
+    {

code/trunk/src/modules/overlays/stats/Stats.h

r5781	r7401
46	46	void setConfigValues();
47	47
48		~~virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);~~
49
50	48	virtual void tick(float dt);
51	49

code/trunk/src/modules/pickup/DroppedPickup.cc

-                      r7163
+                      r7401
     @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.

code/trunk/src/modules/pickup/Pickup.cc

r7208	r7401
225	225	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.:
226	226	DroppedPickup(BaseObject* creator, Pickupable* pickup, const Vector3& position);
227		~~@param position~~
228		~~The position at which the PickupSpawner should be placed.~~
229	227	@return
230	228	Returns true if a spawner was created, false if not.

code/trunk/src/modules/pickup/PickupCollection.cc

-                      r7163
+                      r7401
     @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.
 …
         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.

code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc

r7163	r7401
99	99	@brief
100	100	Add a Pickupable to the PickupCollectionIdentifier.
101		@param
	101	@param identifier
102	102	A pointer to the PickupIdentifier of the Pickupable to be added.
103	103	*/

code/trunk/src/modules/pickup/PickupSpawner.cc

r7163	r7401
70	70	@param respawnTime
71	71	The minimum time between two spawns.
72		@param maySpawnedItems
	72	@param maxSpawnedItems
73	73	The maximum number of items spawned by this PickupSpawner.
74	74	*/

code/trunk/src/modules/pickup/items/SpeedPickup.cc

r7208	r7401
252	252	@brief
253	253	Sets the SpeedMultiply
254		@param speed~~Add~~
	254	@param speedMultiply
255	255	The multiplied Speed
256	256	*/

code/trunk/src/modules/questsystem/CMakeLists.txt

-                      r7164
+                      r7401
 SET_SOURCE_FILES(QUESTSYSTEM_SRC_FILES
-  AddQuest.cc
-  AddQuestHint.cc
-  AddReward.cc
-  ChangeQuestStatus.cc
-  CompleteQuest.cc
-  FailQuest.cc
   GlobalQuest.cc
   LocalQuest.cc
 …
   QuestNotification.cc
+)
+ADD_SUBDIRECTORY(effects)
 ORXONOX_ADD_LIBRARY(questsystem

code/trunk/src/modules/questsystem/GlobalQuest.h

-                      r5781
+                      r7401
         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>
 …
             </reward-effects>
         </GlobalQuest>
+        @endcode
     @author
         Damian 'Mozork' Frick

code/trunk/src/modules/questsystem/LocalQuest.h

-                      r5781
+                      r7401
         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>
 …
             </complete-effects>
         </LocalQuest>
+        @endcode
     @author
         Damian 'Mozork' Frick

code/trunk/src/modules/questsystem/Quest.cc

-                      r7163
+                      r7401
     @brief
         Returns the subquest at the given index.
     @param
+    @param index
         The index.
     @return
 …
     @brief
         Returns the QuestHint at the given index.
     @param
+    @param index
         The index.
     @return
 …
     @brief
         Returns the fail QuestEffect at the given index.
     @param
+    @param index
         The index.
     @return
 …
     @brief
         Returns the complete QuestEffect at the given index.
     @param
+    @param index
         The index.
     @return

code/trunk/src/modules/questsystem/QuestDescription.h

-                      r7163
+                      r7401
         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

code/trunk/src/modules/questsystem/QuestEffectBeacon.cc

-                      r7163
+                      r7401
         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.
 …
         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;

code/trunk/src/modules/questsystem/QuestEffectBeacon.h

-                      r6800
+                      r7401
         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>
 …
             </attached>
         </QuestEffectBeacon>
+        @endcode
     @author
         Damian 'Mozork' Frick
 …
             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.
             /**

code/trunk/src/modules/questsystem/QuestHint.h

-                      r7163
+                      r7401
         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

code/trunk/src/modules/questsystem/QuestItem.cc

-                      r7163
+                      r7401
     @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.

code/trunk/src/modules/questsystem/QuestItem.h

r7163	r7401
98	98
99	99	private:
100		std::string id_; //!< Identifier. ~~Should be of GUID form: http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure~~
	100	std::string id_; //!< Identifier. Must be unique.
101	101	QuestDescription* description_; //!< The QuestDescription of the QuestItem.
102	102

code/trunk/src/modules/questsystem/QuestListener.h

-                      r5781
+                      r7401
         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>
 …
             </events>
         </BaseObject>
+        @endcode
     @author
     Damian 'Mozork' Frick

code/trunk/src/modules/questsystem/QuestNotification.cc

r7163	r7401
48	48	@brief
49	49	Creates a QuestNotification with the input message.
	50	@param creator
	51	The creator of this object
50	52	@param message
51	53	The message to be sent.

code/trunk/src/orxonox/CMakeLists.txt

r7163	r7401
19	19
20	20	INCLUDE_DIRECTORIES(
21		~~${CMAKE_SOURCE_DIR}/src/external~~
22	21	${CMAKE_SOURCE_DIR}/src/libraries
23	22	${CMAKE_CURRENT_SOURCE_DIR}

code/trunk/src/orxonox/Main.cc

-                      r7163
+                      r7401
 #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);
 …
 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
 …
         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;

code/trunk/src/orxonox/collisionshapes/CollisionShape.cc

r5781	r7401
150	150	}
151	151
152		void CollisionShape::calculateLocalInertia(~~btScalar~~ mass, btVector3& inertia) const
	152	void CollisionShape::calculateLocalInertia(float mass, btVector3& inertia) const
153	153	{
154	154	if (this->collisionShape_)

code/trunk/src/orxonox/controllers/ArtificialController.cc

-                      r7284
+                      r7401
     /**
         @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()
 …
         @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).
     */

code/trunk/src/orxonox/gamestates/GSServer.cc

-                      r6105
+                      r7401
     void GSServer::activate()
+    {
         GameMode::setHasServer(true);
+        GameMode::setIsServer(true);
         this->server_ = new Server(CommandLineParser::getValue("port"));
 …
         delete this->server_;
         GameMode::setHasServer(false);
+        GameMode::setIsServer(false);
+    }

code/trunk/src/orxonox/graphics/Light.h

-                      r7163
+                      r7401
             /**
                 @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:
 …
             /**
                 @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)

code/trunk/src/orxonox/interfaces/Pickupable.h

-                      r7163
+                      r7401
             @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.
             */

code/trunk/src/orxonox/overlays/GUISheet.cc

-                      r7163
+                      r7401
+    }
     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_)

code/trunk/src/orxonox/overlays/GUISheet.h

r6746	r7401
44	44	~GUISheet();
45	45
46		void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	46	void XMLPort(Element& xmlelement, XMLPort::Mode mode);
47	47
48	48	void show();

code/trunk/src/orxonox/overlays/InGameConsole.cc

-                      r7284
+                      r7401
     /**
         @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)

code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc

-                      r7284
+                      r7401
         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);
+    }
 …
         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)
 …
         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)
 …
         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)

code/trunk/src/orxonox/overlays/OrxonoxOverlay.h

r6753	r7401
90	90	virtual ~OrxonoxOverlay();
91	91
92		virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	92	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
93	93
94	94	virtual void changedName();

code/trunk/src/orxonox/overlays/OverlayGroup.cc

-                      r7284
+                      r7401
         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);
+    }
 …
     @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.
 …
         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)
 …
         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)

code/trunk/src/orxonox/overlays/OverlayGroup.h

r6054	r7401
58	58	~OverlayGroup();
59	59
60		virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	60	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
61	61
62	62	static void toggleVisibility(const std::string& name);

code/trunk/src/orxonox/worldentities/WorldEntity.cc

-                      r7163
+                      r7401
     @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.
 …
     @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.
 …
         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.
 …
     @brief
         Sets the three dimensional scaling of this object.
     @Note
+    @note
         Scaling physical objects has not yet been implemented and is therefore forbidden.
     */
 …
     @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)
 …
     @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)
 …
     @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.
 …
     @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.
 …
     /**
     @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.
     */
 …
         Recalculates the accumulated child mass and calls recalculateMassProps()
         and notifies the parent of the change.
     @Note
+    @note
         Called by a child WE
     */
 …
     @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

code/trunk/src/orxonox/worldentities/WorldEntity.h

-                      r7163
+                      r7401
             @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.
 …
             @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.
             */

Context Navigation

Legend: