Changeset 1747 for code

code/trunk

Property svn:mergeinfo changed

merged: 1573-1574,1583-1586,1591-1594,1596-1597,1603,1606-1607,1610-1611,1655,1658,1676-1679,1681-1685,1687,1716-1723,1725-1729,1736

code/trunk/src/audio/AudioIncludes.h

r1505	r1747
47	47	#include <vorbis/vorbisfile.h>
48	48
49		#include "~~core~~/Error.h"
	49	#include "util/Error.h"

code/trunk/src/audio/AudioManager.cc

-                      r1639
+                      r1747
 #include "AudioSource.h"
 #include "AudioStream.h"
 #include "core/Error.h"
 #include "core/Debug.h"
+#include "util/Error.h"
+#include "util/Debug.h"
 namespace audio

code/trunk/src/audio/AudioManager.h

-                      r1535
+                      r1747
                 void setOri(std::vector<float> at, std::vector<float> up);
-                // Parses given xml string
-                void loadParams();
                 // Update
                 void tick(float dt);

code/trunk/src/audio/AudioStream.cc

-                      r1505
+                      r1747
 #include "AudioStream.h"
 #include "core/Debug.h"
 #include "core/Error.h"
+#include "util/Debug.h"
+#include "util/Error.h"
 namespace audio

code/trunk/src/core/BaseObject.h

-                      r1625
+                      r1747
 #include "CorePrereqs.h"
+#include "Super.h"
+#include "OrxonoxClass.h"
 #include "util/XMLIncludes.h"
-#include "OrxonoxClass.h"
 namespace orxonox
 …
             Namespace* namespace_;
     };
+    SUPER_FUNCTION(0, BaseObject, XMLPort, false);
+    SUPER_FUNCTION(2, BaseObject, changedActivity, false);
+    SUPER_FUNCTION(3, BaseObject, changedVisibility, false);
+}

code/trunk/src/core/CMakeLists.txt

-                      r1612
+                      r1747
   ConfigValueContainer.cc
   Core.cc
-  Error.cc
   Language.cc
+  ObjectListBase.cc
   OrxonoxClass.cc
-  OutputBuffer.cc
-  OutputHandler.cc
   Script.cc
-  SignalHandler.cc
   # command

code/trunk/src/core/ClassFactory.h

-                      r1543
+                      r1747
 #include "Factory.h"
 #include "Identifier.h"
 #include "Debug.h"
+#include "util/Debug.h"
 namespace orxonox
 …
+    {
         COUT(4) << "*** ClassFactory: Create entry for " << name << " in Factory." << std::endl;
         ClassIdentifier<T>::getIdentifier()->addFactory(new ClassFactory<T>);
+        ClassIdentifier<T>::getIdentifier(name)->addFactory(new ClassFactory<T>);
         Factory::add(name, ClassIdentifier<T>::getIdentifier());

code/trunk/src/core/ClassTreeMask.h

-                      r1505
+                      r1747
 namespace orxonox
+{
     // ###############################
     // ###    ClassTreeMaskNode    ###
     // ###############################
+    // ###################################
+    // ###      ClassTreeMaskNode      ###
+    // ###################################
     //! The ClassTreeMaskNode is a node in the internal tree of the ClassTreeMask, containing the rules of the mask.
     /**
 …
     // ###############################
     // ###  ClassTreeMaskIterator  ###
     // ###############################
+    // ###################################
+    // ###    ClassTreeMaskIterator    ###
+    // ###################################
     //! The ClassTreeMaskIterator moves through all ClassTreeMaskNodes of the internal tree of a ClassTreeMask, containing the rules.
     /**
 …
     // ###############################
     // ###      ClassTreeMask      ###
     // ###############################
+    // ###################################
+    // ###        ClassTreeMask        ###
+    // ###################################
     //! The ClassTreeMask is a set of rules, containing the information for each class whether it's included or not.
     /**
 …
             ClassTreeMaskNode* root_;   //!< The root-node of the internal rule-tree, usually BaseObject
     };
+    // ###################################
+    // ### ClassTreeMaskObjectIterator ###
+    // ###################################
+    //! ...
+    /**
+        ...
+    */
+    class _CoreExport ClassTreeMaskObjectIterator
+    {
+    };
+}

code/trunk/src/core/CommandEvaluation.cc

r1563	r1747
30	30	#include "ConsoleCommand.h"
31	31	#include "Identifier.h"
32		#include "Debug.h"
	32	#include "util/Debug.h"
33	33	#include "util/String.h"
34	34
…	…
218	218	}
219	219
220		void CommandEvaluation::setEvaluatedParameter(unsigned int index, MultiType~~Math~~ param)
	220	void CommandEvaluation::setEvaluatedParameter(unsigned int index, MultiType param)
221	221	{
222	222	if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
…	…
224	224	}
225	225
226		MultiType~~Math~~ CommandEvaluation::getEvaluatedParameter(unsigned int index) const
	226	MultiType CommandEvaluation::getEvaluatedParameter(unsigned int index) const
227	227	{
228	228	if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
…	…
240	240	}
241	241
242		MultiType~~Math~~ CommandEvaluation::getReturnvalue() const
	242	MultiType CommandEvaluation::getReturnvalue() const
243	243	{
244	244	if (this->function_)
245	245	return this->function_->getReturnvalue();
246	246
247		return MultiType~~Math~~();
	247	return MultiType();
248	248	}
249	249
…	…
304	304
305	305	if (command->defaultValueSet(i))
306		output += "=" + command->getDefaultValue(i).toString() + "]";
	306	output += "=" + command->getDefaultValue(i).getString() + "]";
307	307	else
308	308	output += "}";

code/trunk/src/core/CommandEvaluation.h

-                      r1505
+                      r1747
 #include "ArgumentCompletionListElement.h"
 #include "util/SubString.h"
 #include "util/MultiTypeMath.h"
+#include "util/MultiType.h"
 namespace orxonox
 …
                 { return (this->additionalParameter_ != "") ? (" " + this->additionalParameter_) : ""; }
             void setEvaluatedParameter(unsigned int index, MultiTypeMath param);
             MultiTypeMath getEvaluatedParameter(unsigned int index) const;
+            void setEvaluatedParameter(unsigned int index, MultiType param);
+            MultiType getEvaluatedParameter(unsigned int index) const;
             bool hasReturnvalue() const;
             MultiTypeMath getReturnvalue() const;
+            MultiType getReturnvalue() const;
         private:
 …
             bool bEvaluatedParams_;
             MultiTypeMath param_[5];
+            MultiType param_[5];
     };
+}

code/trunk/src/core/CommandExecutor.cc

-                      r1505
+                      r1747
 #include "util/String.h"
 #include "util/Convert.h"
+#include "util/Debug.h"
 #include "Identifier.h"
 #include "Language.h"
-#include "Debug.h"
 #include "TclBind.h"

code/trunk/src/core/ConfigFileManager.cc

r1543	r1747
38	38	namespace orxonox
39	39	{
40		SetConsoleCommandShortcutExtern(config).~~setArgumentCompleter(0, autocompletion::configvalueclasses()).setArgumentCompleter(1, autocompletion::configvalues()).setA~~rgumentCompleter(2, autocompletion::configvalue());
41		SetConsoleCommandShortcutExtern(tconfig).~~setArgumentCompleter(0, autocompletion::configvalueclasses()).setArgumentCompleter(1, autocompletion::configvalues()).setA~~rgumentCompleter(2, autocompletion::configvalue());
	40	SetConsoleCommandShortcutExtern(config).argumentCompleter(0, autocompletion::configvalueclasses()).argumentCompleter(1, autocompletion::configvalues()).argumentCompleter(2, autocompletion::configvalue());
	41	SetConsoleCommandShortcutExtern(tconfig).argumentCompleter(0, autocompletion::configvalueclasses()).argumentCompleter(1, autocompletion::configvalues()).argumentCompleter(2, autocompletion::configvalue());
42	42	SetConsoleCommandShortcutExtern(reloadConfig);
43	43	SetConsoleCommandShortcutExtern(cleanConfig);
44		SetConsoleCommandShortcutExtern(loadSettings).~~setA~~rgumentCompleter(0, autocompletion::files());
45		SetConsoleCommandShortcutExtern(loadKeybindings).~~setA~~rgumentCompleter(0, autocompletion::files());
	44	SetConsoleCommandShortcutExtern(loadSettings).argumentCompleter(0, autocompletion::files());
	45	SetConsoleCommandShortcutExtern(loadKeybindings).argumentCompleter(0, autocompletion::files());
46	46
47	47	bool config(const std::string& classname, const std::string& varname, const std::string& value)
…	…
71	71	void reloadConfig()
72	72	{
73		ConfigFileManager::get~~Singleton~~()->load();
	73	ConfigFileManager::getInstance()->load();
74	74	}
75	75
76	76	void cleanConfig()
77	77	{
78		ConfigFileManager::get~~Singleton~~()->clean(false);
	78	ConfigFileManager::getInstance()->clean(false);
79	79	}
80	80
81	81	void loadSettings(const std::string& filename)
82	82	{
83		ConfigFileManager::get~~Singleton~~()->setFile(CFT_Settings, filename, false);
	83	ConfigFileManager::getInstance()->setFile(CFT_Settings, filename, false);
84	84	}
85	85
86	86	void loadKeybindings(const std::string& filename)
87	87	{
88		ConfigFileManager::get~~Singleton~~()->setFile(CFT_Keybindings, filename);
	88	ConfigFileManager::getInstance()->setFile(CFT_Keybindings, filename);
89	89	}
90	90
…	…
327	327	file.close();
328	328
329		COUT(3) << "Loaded config file \"" << this->filename_ << "\"." << std::endl;
	329	COUT(0) << "Loaded config file \"" << this->filename_ << "\"." << std::endl;
330	330
331	331	// Save the file in case something changed (like stripped whitespaces)
…	…
459	459	}
460	460
461		ConfigFileManager* ConfigFileManager::get~~Singleton~~()
	461	ConfigFileManager* ConfigFileManager::getInstance()
462	462	{
463	463	static ConfigFileManager instance;

code/trunk/src/core/ConfigFileManager.h

r1505	r1747
258	258	{
259	259	public:
260		static ConfigFileManager* get~~Singleton~~();
	260	static ConfigFileManager* getInstance();
261	261
262	262	void setFile(ConfigFileType type, const std::string& filename, bool bCreateIfNotExisting = true);

code/trunk/src/core/ConfigValueContainer.cc

-                      r1505
+                      r1747
+{
     /**
+        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
+        @param type The type of the corresponding config-file
+        @param identifier The identifier of the class the variable belongs to
+        @param varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const MultiTypeMath& defvalue)
+        @brief Initializes the ConfigValueContainer with defaultvalues.
+    */
+    void ConfigValueContainer::init(ConfigFileType type, Identifier* identifier, const std::string& varname)
+    {
         this->type_ = type;
 …
         this->sectionname_ = identifier->getName();
         this->varname_ = varname;
+        this->callback_ = 0;
+        this->bContainerIsNew_ = true;
+        this->bDoInitialCallback_ = false;
+        this->bAddedDescription_ = false;
+    }
+    /**
+        @brief Does some special initialization for single config-values.
+    */
+    void ConfigValueContainer::initValue(const MultiType& defvalue)
+    {
         this->value_ = defvalue;
-        this->bAddedDescription_ = false;
         this->bIsVector_ = false;
         this->defvalueString_ = defvalue.toString();
+        this->defvalueString_ = this->value_.getString();
         this->update();
+    }
     /**
+        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
+        @param type The type of the corresponding config-file
+        @param identifier The identifier of the class the variable belongs to
+        @param varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const std::vector<MultiTypeMath>& defvalue)
+    {
+        this->type_ = type;
+        this->identifier_ = identifier;
+        this->sectionname_ = identifier->getName();
+        this->varname_ = varname;
+        this->valueVector_ = defvalue;
+        this->bAddedDescription_ = false;
+        @brief Does some special initialization for vector config-values.
+    */
+    void ConfigValueContainer::initVector()
+    {
         this->bIsVector_ = true;
+        if (defvalue.size() > 0)
+        {
+                this->value_ = defvalue[0];
+            for (unsigned int i = 0; i < defvalue.size(); i++)
+            {
+                ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, i, defvalue[i].toString(), this->value_.isA(MT_string));
+                this->defvalueStringVector_.push_back(defvalue[i].toString());
+            }
+            this->update();
+        }
+        for (unsigned int i = 0; i < this->valueVector_.size(); i++)
+        {
+            ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_string));
+            this->defvalueStringVector_.push_back(this->valueVector_[i]);
+        }
+        this->update();
+    }
+    /**
+        @brief Destructor: Deletes the callback object if necessary.
+    */
+    ConfigValueContainer::~ConfigValueContainer()
+    {
+        if (this->callback_)
+            delete this->callback_;
+    }
 …
         @return True if the new value was successfully assigned
     */
     bool ConfigValueContainer::set(const MultiTypeMath& input)
+    {
         if (this->bIsVector_)
+        {
             return this->callFunctionWithIndex(&ConfigValueContainer::set, input.toString());
+    bool ConfigValueContainer::set(const MultiType& input)
+    {
+        if (this->bIsVector_)
+        {
+            return this->callFunctionWithIndex(&ConfigValueContainer::set, input);
+        }
         else
 …
             if (this->tset(input))
+            {
                 ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, input.toString(), this->value_.isA(MT_string));
+                ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, input, this->value_.isType(MT_string));
                 return true;
+            }
 …
         @return True if the new value was successfully assigned
     */
     bool ConfigValueContainer::set(unsigned int index, const MultiTypeMath& input)
+    bool ConfigValueContainer::set(unsigned int index, const MultiType& input)
+    {
         if (this->bIsVector_)
 …
             if (this->tset(index, input))
+            {
                 ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, index, input.toString(), this->value_.isA(MT_string));
+                ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, index, input, this->value_.isType(MT_string));
                 return true;
+            }
 …
         @return True if the new value was successfully assigned
     */
+    bool ConfigValueContainer::tset(const MultiTypeMath& input)
+    {
+        if (this->bIsVector_)
+        {
+            return this->callFunctionWithIndex(&ConfigValueContainer::tset, input.toString());
+        }
+        else
+        {
+            MultiTypeMath temp = this->value_;
+            if (temp.assimilate(input))
+            {
+                this->value_ = temp;
+                if (this->identifier_)
+                    this->identifier_->updateConfigValues();
+                return true;
+            }
+        }
+        return false;
+    bool ConfigValueContainer::tset(const MultiType& input)
+    {
+        if (this->bIsVector_)
+        {
+            return this->callFunctionWithIndex(&ConfigValueContainer::tset, input);
+            return false;
+        }
+        else
+        {
+            this->value_ = input;
+            if (this->identifier_)
+                this->identifier_->updateConfigValues();
+            return true;
+        }
+    }
 …
         @return True if the new value was successfully assigned
     */
     bool ConfigValueContainer::tset(unsigned int index, const MultiTypeMath& input)
+    bool ConfigValueContainer::tset(unsigned int index, const MultiType& input)
+    {
         if (this->bIsVector_)
 …
                 for (unsigned int i = this->valueVector_.size(); i <= index; i++)
+                {
                     this->valueVector_.push_back(MultiTypeMath());
+                    this->valueVector_.push_back(MultiType());
+                }
+            }
+            MultiTypeMath temp = this->value_;
+            if (temp.assimilate(input))
+            {
+                this->valueVector_[index] = temp;
+                if (this->identifier_)
+                    this->identifier_->updateConfigValues();
+                return true;
+            }
+            this->valueVector_[index] = input;
+            if (this->identifier_)
+                this->identifier_->updateConfigValues();
+            return true;
+        }
         else
+        {
             COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
+        }
         return false;
+            return false;
+        }
+    }
 …
         @return True if the new entry was successfully added
     */
     bool ConfigValueContainer::add(const MultiTypeMath& input)
+    bool ConfigValueContainer::add(const MultiType& input)
+    {
         if (this->bIsVector_)
 …
                 this->valueVector_.erase(this->valueVector_.begin() + index);
                 for (unsigned int i = index; i < this->valueVector_.size(); i++)
                     ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isA(MT_string));
                 ConfigFileManager::getSingleton()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->valueVector_.size());
+                    ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_string));
+                ConfigFileManager::getInstance()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->valueVector_.size());
                 return true;
 …
                 if (!this->set(i, this->defvalueStringVector_[i]))
                     success = false;
             ConfigFileManager::getSingleton()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->defvalueStringVector_.size());
+            ConfigFileManager::getInstance()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->defvalueStringVector_.size());
             return success;
+        }
 …
+    {
         if (!this->bIsVector_)
             this->value_.fromString(ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_, this->value_.isA(MT_string)));
+            this->value_ = ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_, this->value_.isType(MT_string));
         else
+        {
             this->valueVector_.clear();
             for (unsigned int i = 0; i < ConfigFileManager::getSingleton()->getVectorSize(this->type_, this->sectionname_, this->varname_); i++)
+            for (unsigned int i = 0; i < ConfigFileManager::getInstance()->getVectorSize(this->type_, this->sectionname_, this->varname_); i++)
+            {
                 if (i < this->defvalueStringVector_.size())
+                {
                     this->value_.fromString(ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isA(MT_string)));
+                    this->value_ = ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isType(MT_string));
+                }
                 else
+                {
                     this->value_.fromString(ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, i, MultiTypeMath(), this->value_.isA(MT_string)));
+                    this->value_ = ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, MultiType(), this->value_.isType(MT_string));
+                }
 …
         @return The returnvalue of the functioncall
     */
     bool ConfigValueContainer::callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiTypeMath&), const std::string& input)
+    bool ConfigValueContainer::callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiType&), const std::string& input)
+    {
         SubString token(input, " ", SubString::WhiteSpaces, true, '\\', false, '"', false, '(', ')', false, '\0');
 …
         @param description The description
     */
     void ConfigValueContainer::description(const std::string& description)
+    ConfigValueContainer& ConfigValueContainer::description(const std::string& description)
+    {
         if (!this->bAddedDescription_)
 …
             this->bAddedDescription_ = true;
+        }
+        return (*this);
+    }

code/trunk/src/core/ConfigValueContainer.h

-                      r1505
+                      r1747
 #include "util/Math.h"
 #include "util/MultiTypeMath.h"
+#include "util/MultiType.h"
 #include "ConfigFileManager.h"
 namespace orxonox
+{
+    class ConfigValueCallbackBase
+    {
+        public:
+            virtual void call(void* object) = 0;
+            inline virtual ~ConfigValueCallbackBase() {}
+    };
+    template <class T>
+    class ConfigValueCallback: public ConfigValueCallbackBase
+    {
+        public:
+            inline ConfigValueCallback(void (T::*function) (void)) : function_(function) {}
+            inline virtual ~ConfigValueCallback() {}
+            inline virtual void call(void* object)
+                { (((T*)object)->*this->function_)(); }
+        private:
+            void (T::*function_) (void);
+    };
     //! The ConfigValuecontainer contains all needed informations about a configurable variable.
     /**
 …
+    {
         public:
+            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const MultiTypeMath& defvalue);
+            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const std::vector<MultiTypeMath>& defvalue);
+            /** @brief Returns the configured value. @param value This is only needed to determine the right type. @return The value */
+            template <typename T>
+            inline ConfigValueContainer& getValue(T* value)
+                { this->value_.getValue(value); return *this; }
+            template <typename T>
+            inline ConfigValueContainer& getValue(std::vector<T>* value)
+            {
+                value->clear();
+                for (unsigned int i = 0; i < this->valueVector_.size(); i++)
+                    value->push_back(this->valueVector_[i]);
+            /**
+                @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
+                @param type The type of the corresponding config-file
+                @param identifier The identifier of the class the variable belongs to
+                @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>
+            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const D& defvalue, const V& value)
+            {
+                this->init(type, identifier, varname);
+                this->initValue((V)defvalue);
+            }
+            /**
+                @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
+                @param type The type of the corresponding config-file
+                @param identifier The identifier of the class the variable belongs to
+                @param varname The name of the variable
+                @param defvalue The default-value
+            */
+            template <class V>
+            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const std::vector<V>& defvalue)
+            {
+                this->init(type, identifier, varname);
+                this->value_ = V();
+                for (unsigned int i = 0; i < defvalue.size(); i++)
+                    this->valueVector_.push_back(MultiType(defvalue[i]));
+                this->initVector();
+            }
+            ~ConfigValueContainer();
+            /**
+                @brief Returns the configured value.
+                @param value A pointer to the variable to store the value.
+                @param object The object calling this function
+                @return The ConfigValueContainer
+            */
+            template <typename T, class C>
+            ConfigValueContainer& getValue(T* value, C* object)
+            {
+                if ((this->callback_ && object) || this->bContainerIsNew_)
+                {
+                    if (this->bContainerIsNew_)
+                        this->bContainerIsNew_ = false;
+                    T temp = *value;
+                    this->value_.getValue(value);
+                    if ((*value) != temp)
+                    {
+                        if (this->callback_ && object)
+                            this->callback_->call(object);
+                        else
+                            this->bDoInitialCallback_ = true;
+                    }
+                }
+                else
+                {
+                    this->value_.getValue(value);
+                }
                 return *this;
+            }
+            template <typename T>
+            inline void setVectorType(const std::vector<T>& value)
+            {
+                this->value_ = T();
+                this->update();
+            }
+            /**
+                @brief Returns the configured vector.
+                @param value A pointer to the vector to store the values.
+                @param object The object calling this function
+                @return The ConfigValueContainer
+            */
+            template <typename T, class C>
+            ConfigValueContainer& getValue(std::vector<T>* value, C* object)
+            {
+                if ((this->callback_ && object) || this->bContainerIsNew_)
+                {
+                    if (this->bContainerIsNew_)
+                        this->bContainerIsNew_ = false;
+                    std::vector<T> temp = *value;
+                    value->clear();
+                    for (unsigned int i = 0; i < this->valueVector_.size(); ++i)
+                        value->push_back(this->valueVector_[i]);
+                    if (value->size() != temp.size())
+                    {
+                        if (this->callback_ && object)
+                            this->callback_->call(object);
+                        else
+                            this->bDoInitialCallback_ = true;
+                    }
+                    else
+                    {
+                        for (unsigned int i = 0; i < value->size(); ++i)
+                        {
+                            if ((*value)[i] != temp[i])
+                            {
+                                if (this->callback_ && object)
+                                    this->callback_->call(object);
+                                else
+                                    this->bDoInitialCallback_ = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    value->clear();
+                    for (unsigned int i = 0; i < this->valueVector_.size(); ++i)
+                        value->push_back(this->valueVector_[i]);
+                }
+                return *this;
+            }
+            /** @brief Returns the name of this container. */
             inline const std::string& getName() const
                 { return this->varname_; }
+            /** @brief 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). */
             inline unsigned int getVectorSize() const
                 { return this->valueVector_.size(); }
             void description(const std::string& description);
+            ConfigValueContainer& description(const std::string& description);
             const std::string& getDescription() const;
+            bool set(const MultiTypeMath& input);
+            bool tset(const MultiTypeMath& input);
+            bool set(unsigned int index, const MultiTypeMath& input);
+            bool tset(unsigned int index, const MultiTypeMath& input);
+            bool add(const MultiTypeMath& input);
+            /**
+                @brief Adds a callback function, that gets called after getValue() if the newly assigned value differs from the old value of the variable.
+                @param object The object to call the function
+                @param function The callback function
+            */
+            template <class T>
+            inline ConfigValueContainer& callback(T* object, void (T::*function) (void))
+            {
+                if (!this->callback_)
+                {
+                    this->callback_ = new ConfigValueCallback<T>(function);
+                    if (this->bDoInitialCallback_)
+                    {
+                        this->bDoInitialCallback_ = false;
+                        this->callback_->call(object);
+                    }
+                }
+                return (*this);
+            }
+            bool set(const MultiType& input);
+            bool tset(const MultiType& input);
+            bool set(unsigned int index, const MultiType& input);
+            bool tset(unsigned int index, const MultiType& input);
+            bool add(const MultiType& input);
             bool remove(unsigned int index);
 …
             /** @brief Converts the config-value to a string. @return The string */
             inline std::string toString() const
                 { return this->value_.toString(); }
+                { return this->value_; }
             /** @brief Returns the typename of the assigned config-value. @return The typename */
             inline std::string getTypename() const
 …
         private:
+            bool callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiTypeMath&), const std::string& input);
+            void init(ConfigFileType type, Identifier* identifier, const std::string& varname);
+            void initValue(const MultiType& defvalue);
+            void initVector();
+            bool callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiType&), const std::string& input);
             bool                       bIsVector_;                  //!< True if the container contains a std::vector
 …
             std::vector<std::string>   defvalueStringVector_;       //!< A vector, containg the strings of the default-values in case we're storing a vector
             MultiTypeMath              value_;                      //!< The value
             std::vector<MultiTypeMath> valueVector_;                //!< A vector, containg the values in case we're storing a vector
+            MultiType                  value_;                      //!< The value
+            std::vector<MultiType>     valueVector_;                //!< A vector, containg the values in case we're storing a vector
             bool                       bAddedDescription_;          //!< True if a description was added
             LanguageEntryLabel         description_;                //!< The description
+            ConfigValueCallbackBase*   callback_;                   //!< A callback function to call after getValue if the value changed
+            bool                       bContainerIsNew_;            //!< True if it's the first time getValue() gets called
+            bool                       bDoInitialCallback_;         //!< True if the callback should be called as soon as it gets created
     };
+}

code/trunk/src/core/ConfigValueIncludes.h

-                      r1543
+                      r1747
     @param defvalue The default-value of the variable
 */
+#define SetConfigValue(varname, defvalue) \
+    orxonox::ConfigValueContainer* container##varname = this->getIdentifier()->getConfigValueContainer(#varname); \
+#define SetConfigValueGeneric(type, varname, defvalue) \
+    static orxonox::Identifier* identifier##varname = this->getIdentifier(); \
+    orxonox::ConfigValueContainer* container##varname = identifier##varname->getConfigValueContainer(#varname); \
     if (!container##varname) \
     { \
         container##varname = new orxonox::ConfigValueContainer(CFT_Settings, this->getIdentifier(), #varname, varname = defvalue); \
         this->getIdentifier()->addConfigValueContainer(#varname, container##varname); \
+        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, identifier##varname, #varname, defvalue, varname); \
+        identifier##varname->addConfigValueContainer(#varname, container##varname); \
     } \
     container##varname->getValue(&varname)
+    container##varname->getValue(&varname, this)
+/**
+    @brief Assigns the value, defined in the config-file, to the variable (or the default-value, if there is no entry in the file).
+    @param classname name in which the config value should be stored
+    @param varname The name of the variable
+    @param defvalue The default-value of the variable
+*/
+#define SetConfigValueGeneric(classname, varname, defvalue) \
+    orxonox::ConfigValueContainer* container##varname = ClassIdentifier<classname>::getIdentifier()->getConfigValueContainer(#varname); \
+    if (!container##varname) \
+    { \
+        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, ClassIdentifier<classname>::getIdentifier(), #varname, varname = defvalue); \
+        ClassIdentifier<classname>::getIdentifier()->addConfigValueContainer(#varname, container##varname); \
+    } \
+    container##varname->getValue(&varname)
+#define SetConfigValue(varname, defvalue) SetConfigValueGeneric(CFT_Settings, varname, defvalue)
+#define SetKeybindingValue(varname, defvalue) SetConfigValueGeneric(CFT_Keybindings, varname, defvalue)
 /**
 …
     @param defvalue The default-value
 */
+#define SetConfigValueVector(varname, defvalue) \
+    orxonox::ConfigValueContainer* container##varname = this->getIdentifier()->getConfigValueContainer(#varname); \
+#define SetConfigValueVectorGeneric(type, varname, defvalue) \
+    static orxonox::Identifier* identifier##varname = this->getIdentifier(); \
+    orxonox::ConfigValueContainer* container##varname = identifier##varname->getConfigValueContainer(#varname); \
     if (!container##varname) \
     { \
+        std::vector<MultiTypeMath> temp; \
+        for (unsigned int i = 0; i < defvalue.size(); i++) \
+            temp.push_back(MultiTypeMath(defvalue[i])); \
+        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, this->getIdentifier(), #varname, temp); \
+        container##varname->setVectorType(varname); \
+        this->getIdentifier()->addConfigValueContainer(#varname, container##varname); \
+        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, identifier##varname, #varname, defvalue); \
+        identifier##varname->addConfigValueContainer(#varname, container##varname); \
     } \
+    container##varname->getValue(&varname)
+    container##varname->getValue(&varname, this)
+#define SetConfigValueVector(varname, defvalue) SetConfigValueVectorGeneric(CFT_Settings, varname, defvalue)
+#define SetKeybindingValueVector(varname, defvalue) SetConfigValueVectorGeneric(CFT_Keybindings, varname, defvalue)
 /**
 …
     { \
         container##varname##reset->reset(); \
         container##varname##reset->getValue(&varname); \
+        container##varname##reset->getValue(&varname, this); \
     } \
     else \
 …
         COUT(2) << "Warning: Couldn't reset config-value '" << #varname << "', corresponding container doesn't exist." << std::endl; \
+    }
 /**
 …
     { \
         container##varname##modify##modifier->modifier(__VA_ARGS__); \
         container##varname##modify##modifier->getValue(&varname); \
+        container##varname##modify##modifier->getValue(&varname, this); \
     } \
     else \

code/trunk/src/core/ConsoleCommand.cc

r1505	r1747
45	45	}
46	46
47		ConsoleCommand& ConsoleCommand::~~setA~~rgumentCompleter(unsigned int param, ArgumentCompleter* completer)
	47	ConsoleCommand& ConsoleCommand::argumentCompleter(unsigned int param, ArgumentCompleter* completer)
48	48	{
49	49	if (param < 5)

code/trunk/src/core/ConsoleCommand.h

-                      r1549
+                      r1747
+#define SetConsoleCommand(classname, function,  bCreateShortcut) \
+    SetConsoleCommandGeneric(classname##function##consolecommand__, classname, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), #function), bCreateShortcut)
+#define SetConsoleCommand(classname, function, bCreateShortcut) \
+    SetConsoleCommandAliasMulti(classname, function, #function, 0, bCreateShortcut)
+#define SetConsoleCommandAlias(classname, function, name, bCreateShortcut) \
+    SetConsoleCommandAliasMulti(classname, function, name, 0, bCreateShortcut)
+#define SetConsoleCommandAliasMulti(classname, function, name, number, bCreateShortcut) \
+    SetConsoleCommandGeneric(classname##function##consolecommand__##number, classname, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), name), bCreateShortcut)
 #define SetConsoleCommandGeneric(fakevariable, classname, command, bCreateShortcut) \
     orxonox::ConsoleCommand& fakevariable = orxonox::ClassIdentifier<classname>::getIdentifier()->addConsoleCommand(command, bCreateShortcut)
+    orxonox::ConsoleCommand& fakevariable = orxonox::ClassIdentifier<classname>::getIdentifier(#classname)->addConsoleCommand(command, bCreateShortcut)
 #define SetConsoleCommandShortcut(classname, function) \
+    SetConsoleCommandShortcutGeneric(function##consolecommand__, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), #function))
+    SetConsoleCommandShortcutAliasMulti(classname, function, #function, 0)
+#define SetConsoleCommandShortcutAlias(classname, function, name) \
+    SetConsoleCommandShortcutAliasMulti(classname, function, name, 0)
+#define SetConsoleCommandShortcutAliasMulti(classname, function, name, number) \
+    SetConsoleCommandShortcutGeneric(function##consolecommand__##number, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), name))
 #define SetConsoleCommandShortcutExtern(function) \
+    SetConsoleCommandShortcutGeneric(function##consolecommand__, orxonox::createConsoleCommand(orxonox::createFunctor(&function), #function))
+    SetConsoleCommandShortcutExternAliasMulti(function, #function, 0)
+#define SetConsoleCommandShortcutExternAlias(function, name) \
+    SetConsoleCommandShortcutExternAliasMulti(function, name, 0)
+#define SetConsoleCommandShortcutExternAliasMulti(function, name, number) \
+    SetConsoleCommandShortcutGeneric(function##consolecommand__##number, orxonox::createConsoleCommand(orxonox::createFunctor(&function), name))
 #define SetConsoleCommandShortcutGeneric(fakevariable, command) \
 …
             ConsoleCommand(FunctorStatic* functor, const std::string& name = "");
             inline ConsoleCommand& setDescription(const std::string& description)
+            inline ConsoleCommand& description(const std::string& description)
                 { this->ExecutorStatic::setDescription(description); return (*this); }
             inline ConsoleCommand& setDescriptionParam(int param, const std::string& description)
+            inline ConsoleCommand& descriptionParam(int param, const std::string& description)
                 { this->ExecutorStatic::setDescriptionParam(param, description); return (*this); }
             inline ConsoleCommand& setDescriptionReturnvalue(const std::string& description)
+            inline ConsoleCommand& descriptionReturnvalue(const std::string& description)
                 { this->ExecutorStatic::setDescriptionReturnvalue(description); return (*this); }
             inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1)
+            inline ConsoleCommand& defaultValues(const MultiType& param1)
                 { this->ExecutorStatic::setDefaultValues(param1); return (*this); }
             inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2)
                 { this->ExecutorStatic::setDefaultValues(param1, param2); return (*this); }
             inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3); return (*this); }
             inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4); return (*this); }
             inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4, param5); return (*this); }
             inline ConsoleCommand& setDefaultValue(unsigned int index, const MultiTypeMath& param)
+            inline ConsoleCommand& defaultValue(unsigned int index, const MultiType& param)
                 { this->ExecutorStatic::setDefaultValue(index, param); return (*this); }
             inline ConsoleCommand& setAccessLevel(AccessLevel::Level level)
+            inline ConsoleCommand& accessLevel(AccessLevel::Level level)
                 { this->accessLevel_ = level; return (*this); }
             inline AccessLevel::Level getAccessLevel() const
                 { return this->accessLevel_; }
             ConsoleCommand& setArgumentCompleter(unsigned int param, ArgumentCompleter* completer);
+            ConsoleCommand& argumentCompleter(unsigned int param, ArgumentCompleter* completer);
             ArgumentCompleter* getArgumentCompleter(unsigned int param) const;
 …
                 { return this->argumentList_.end(); }
             inline ConsoleCommand& setKeybindMode(KeybindMode::Enum mode)
+            inline ConsoleCommand& keybindMode(KeybindMode::Enum mode)
                 { this->keybindMode_ = mode; return *this; }
             inline KeybindMode::Enum getKeybindMode() const
                 { return this->keybindMode_; }
             inline ConsoleCommand& setAxisParamIndex(int index)
+            inline ConsoleCommand& axisParamIndex(int index)
                 { this->axisParamIndex_ = index; return *this; }
             inline int getAxisParamIndex() const
                 { return this->axisParamIndex_; }
             inline ConsoleCommand& setIsAxisRelative(bool val)
+            inline ConsoleCommand& isAxisRelative(bool val)
                 { this->bAxisRelative_ = val; return *this; }
             inline int getIsAxisRelative() const

code/trunk/src/core/ConsoleCommandCompilation.cc

-                      r1505
+                      r1747
 #include "ConsoleCommandCompilation.h"
 #include "ConsoleCommand.h"
 #include "Debug.h"
+#include "util/Debug.h"
 #include "util/ExprParser.h"
 namespace orxonox
+{
     SetConsoleCommandShortcutExtern(source).setArgumentCompleter(0, autocompletion::files());
+    SetConsoleCommandShortcutExtern(source).argumentCompleter(0, autocompletion::files());
     SetConsoleCommandShortcutExtern(echo);
     SetConsoleCommandShortcutExtern(puts);
     SetConsoleCommandShortcutExtern(read).setArgumentCompleter(0, autocompletion::files());
     SetConsoleCommandShortcutExtern(append).setArgumentCompleter(0, autocompletion::files());
     SetConsoleCommandShortcutExtern(write).setArgumentCompleter(0, autocompletion::files());
+    SetConsoleCommandShortcutExtern(read).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommandShortcutExtern(append).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommandShortcutExtern(write).argumentCompleter(0, autocompletion::files());
     SetConsoleCommandShortcutExtern(calculate);

code/trunk/src/core/Core.cc

-                      r1535
+                      r1747
     void Core::setConfigValues()
+    {
+        SetConfigValue(softDebugLevelConsole_, 3).description("The maximal level of debug output shown in the console");
+        SetConfigValue(softDebugLevelLogfile_, 3).description("The maximal level of debug output shown in the logfile");
+        SetConfigValue(softDebugLevelShell_, 1).description("The maximal level of debug output shown in the ingame shell");
+        SetConfigValue(softDebugLevelConsole_, 3).description("The maximal level of debug output shown in the console").callback(this, &Core::debugLevelChanged);
+        SetConfigValue(softDebugLevelLogfile_, 3).description("The maximal level of debug output shown in the logfile").callback(this, &Core::debugLevelChanged);
+        SetConfigValue(softDebugLevelShell_, 1).description("The maximal level of debug output shown in the ingame shell").callback(this, &Core::debugLevelChanged);
+        SetConfigValue(language_, Language::getLanguage().defaultLanguage_).description("The language of the ingame text").callback(this, &Core::languageChanged);
+    }
+    /**
+        @brief Callback function if the debug level has changed.
+    */
+    void Core::debugLevelChanged()
+    {
         // softDebugLevel_ is the maximum of the 3 variables
         this->softDebugLevel_ = this->softDebugLevelConsole_;
 …
             this->softDebugLevel_ = this->softDebugLevelShell_;
+        std::string temp = this->language_;
+        SetConfigValue(language_, Language::getLanguage().defaultLanguage_).description("The language of the ingame text");
+        if (this->language_ != temp)
+        {
+            // Read the translation file after the language was configured
+            Language::getLanguage().readTranslatedLanguageFile();
+        }
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_All,     this->softDebugLevel_);
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_Console, this->softDebugLevelConsole_);
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_Logfile, this->softDebugLevelLogfile_);
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_Shell,   this->softDebugLevelShell_);
+    }
+    /**
+        @brief Callback function if the language has changed.
+    */
+    void Core::languageChanged()
+    {
+        // Read the translation file after the language was configured
+        Language::getLanguage().readTranslatedLanguageFile();
+    }
 …
             else if (device == OutputHandler::LD_Shell)
                 Core::getInstance().softDebugLevelShell_ = level;
+            OutputHandler::setSoftDebugLevel(device, level);
+        }
+     }
 …
+    }
+}
-/**
-    @brief Returns the soft debug level, stored in the only existing instance of the DebugLevel class, configured in the config-file.
-    @return The soft debug level
-*/
-int getSoftDebugLevel()
+{
-    return orxonox::Core::getSoftDebugLevel();
+}

code/trunk/src/core/Core.h

-                      r1535
+                      r1747
 #include "OrxonoxClass.h"
 #include "OutputHandler.h"
+#include "util/OutputHandler.h"
 namespace orxonox
 …
             static bool& isCreatingCoreSettings();
             void setConfigValues();
+            void debugLevelChanged();
+            void languageChanged();
             static int getSoftDebugLevel(OutputHandler::OutputDevice device = OutputHandler::LD_All);

code/trunk/src/core/CoreIncludes.h

-                      r1543
+                      r1747
 #include "Factory.h"
 #include "ClassFactory.h"
 #include "Debug.h"
+#include "util/Debug.h"
 …
 */
 #define InternRegisterObject(ClassName, bRootClass) \
+    this->setIdentifier(orxonox::ClassIdentifier<ClassName>::getIdentifier()->registerClass(this->getParents(), #ClassName, bRootClass)); \
+    if (orxonox::Identifier::isCreatingHierarchy() && this->getParents()) \
+        this->getParents()->insert(this->getParents()->end(), this->getIdentifier()); \
+    orxonox::ClassIdentifier<ClassName>::getIdentifier()->addObject(this); \
+    this->setIdentifier(orxonox::ClassIdentifier<ClassName>::getIdentifier(#ClassName)); \
     if (orxonox::Identifier::isCreatingHierarchy()) \
+      return
+    { \
+        if (this->getParents()) \
+        { \
+            orxonox::ClassIdentifier<ClassName>::getIdentifier(#ClassName)->initializeClassHierarchy(this->getParents(), bRootClass); \
+            this->getParents()->insert(this->getParents()->end(), this->getIdentifier()); \
+        } \
+        this->setConfigValues(); \
+        return; \
+    } \
+    orxonox::ClassIdentifier<ClassName>::getIdentifier()->addObject(this)
 /**

code/trunk/src/core/CorePrereqs.h

-                      r1543
+                      r1747
 // Forward declarations
 //-----------------------------------------------------------------------
-class SignalHandler;
 namespace orxonox
+{
 …
   class ConsoleCommand;
   class Core;
-  class Error;
   class Executor;
   template <class T>
 …
   template <class T>
   class Iterator;
+  class IteratorBase;
   class Language;
   class LanguageEntry;
 …
   class Loader;
   class MetaObjectList;
-  template <class T>
   class MetaObjectListElement;
   class Namespace;
 …
   template <class T>
   class ObjectList;
+  class ObjectListBase;
+  class ObjectListBaseElement;
   template <class T>
   class ObjectListElement;
+  template <class T>
+  class ObjectListIterator;
   class OrxonoxClass;
-  class OutputBuffer;
-  class OutputBufferListener;
-  class OutputHandler;
   class Shell;
   class ShellListener;

code/trunk/src/core/Executor.cc

-                      r1625
+                      r1747
+    }
     bool Executor::evaluate(const std::string& params, MultiTypeMath param[5], const std::string& delimiter) const
+    bool Executor::evaluate(const std::string& params, MultiType param[5], const std::string& delimiter) const
+    {
         unsigned int paramCount = this->functor_->getParamCount();
 …
+    }
     Executor& Executor::setDefaultValues(const MultiTypeMath& param1)
+    {
         this->defaultValue_[0] = param1;
         this->bAddedDefaultValue_[0] = true;
         return (*this);
+    }
     Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
+    {
         this->defaultValue_[0] = param1;
         this->bAddedDefaultValue_[0] = true;
         this->defaultValue_[1] = param2;
         this->bAddedDefaultValue_[1] = true;
         return (*this);
+    }
     Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+    Executor& Executor::setDefaultValues(const MultiType& param1)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+        return (*this);
+    }
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+        this->defaultValue_[1] = param2;
+        this->bAddedDefaultValue_[1] = true;
+        return (*this);
+    }
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
+    {
         this->defaultValue_[0] = param1;
 …
+    }
     Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
+    {
         this->defaultValue_[0] = param1;
 …
+    }
     Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
+    {
         this->defaultValue_[0] = param1;
 …
+    }
     Executor& Executor::setDefaultValue(unsigned int index, const MultiTypeMath& param)
+    Executor& Executor::setDefaultValue(unsigned int index, const MultiType& param)
+    {
         if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)

code/trunk/src/core/Executor.h

-                      r1505
+                      r1747
 #include "util/Math.h"
 #include "Functor.h"
 #include "Debug.h"
+#include "util/Debug.h"
 …
         { \
             COUT(5) << "Calling Executor " << this->name_ << " through parser with one parameter, using whole string: " << params << std::endl; \
             EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) MultiTypeMath(params)); \
+            EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) MultiType(params)); \
         } \
         else if (this->bAddedDefaultValue_[0]) \
 …
         } \
+        \
         MultiTypeMath param[MAX_FUNCTOR_ARGUMENTS]; \
+        MultiType param[MAX_FUNCTOR_ARGUMENTS]; \
         COUT(5) << "Calling Executor " << this->name_ << " through parser with " << paramCount << " parameters, using " << tokens.size() << " tokens ("; \
         for (unsigned int i = 0; i < tokens.size() && i < MAX_FUNCTOR_ARGUMENTS; i++) \
 …
             inline void operator()() const
                 { (*this->functor_)(this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(const MultiTypeMath& param1) const
+            inline void operator()(const MultiType& param1) const
                 { (*this->functor_)(param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2) const
+            inline void operator()(const MultiType& param1, const MultiType& param2) const
                 { (*this->functor_)(param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+            inline void operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3) const
                 { (*this->functor_)(param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+            inline void operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
                 { (*this->functor_)(param1, param2, param3, param4, this->defaultValue_[4]); }
             inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+            inline void operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
                 { (*this->functor_)(param1, param2, param3, param4, param5); }
             bool parse(const std::string& params, const std::string& delimiter = " ") const;
             bool evaluate(const std::string& params, MultiTypeMath param[5], const std::string& delimiter = " ") const;
+            bool evaluate(const std::string& params, MultiType param[5], const std::string& delimiter = " ") const;
             Executor& setDescription(const std::string& description);
 …
             inline FunctionType getType() const
                 { return this->functor_->getType(); }
             inline MultiTypeMath getReturnvalue() const
+            inline MultiType getReturnvalue() const
                 { return this->functor_->getReturnvalue(); }
             inline std::string getTypenameParam(unsigned int param) const
 …
                 { return this->name_; }
             Executor& setDefaultValues(const MultiTypeMath& param1);
             Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2);
             Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3);
             Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4);
             Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5);
             Executor& setDefaultValue(unsigned int index, const MultiTypeMath& param);
             inline MultiTypeMath getDefaultValue(unsigned int index) const
+            Executor& setDefaultValues(const MultiType& param1);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5);
+            Executor& setDefaultValue(unsigned int index, const MultiType& param);
+            inline MultiType getDefaultValue(unsigned int index) const
+            {
                 if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
 …
             Functor* functor_;
             std::string name_;
             MultiTypeMath defaultValue_[MAX_FUNCTOR_ARGUMENTS];
+            MultiType defaultValue_[MAX_FUNCTOR_ARGUMENTS];
             bool bAddedDefaultValue_[MAX_FUNCTOR_ARGUMENTS];
 …
             inline void operator()(T* object) const
                 { (*((FunctorMember<T>*)this->functor_))(object, this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(T* object, const MultiTypeMath& param1) const
+            inline void operator()(T* object, const MultiType& param1) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, this->defaultValue_[4]); }
             inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, param5); }
 …
             inline void operator()(const T* object) const
                 { (*((FunctorMember<T>*)this->functor_))(object, this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(const T* object, const MultiTypeMath& param1) const
+            inline void operator()(const T* object, const MultiType& param1) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
             inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, this->defaultValue_[4]); }
             inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, param5); }

code/trunk/src/core/Factory.cc

-                      r1505
+                      r1747
 #include "Factory.h"
 #include "Identifier.h"
-#include "Debug.h"
 #include "BaseObject.h"
+#include "util/Debug.h"
 namespace orxonox

code/trunk/src/core/Functor.h

-                      r1505
+                      r1747
 #include "CorePrereqs.h"
 #include "util/MultiTypeMath.h"
 #include "Debug.h"
+#include "util/MultiType.h"
+#include "util/Debug.h"
 #define MAX_FUNCTOR_ARGUMENTS 5
 …
     CreateTypeToStringTemplate(long);
     CreateTypeToStringTemplate(unsigned long);
+    CreateTypeToStringTemplate(long long);
+    CreateTypeToStringTemplate(unsigned long long);
     CreateTypeToStringTemplate(float);
     CreateTypeToStringTemplate(double);
 …
     CreateTypeToStringTemplate(Degree);
     template <> \
     inline std::string typeToString<std::string>() { return "string"; } \
     template <> \
     inline std::string typeToString<std::string&>() { return "string"; } \
     template <> \
     inline std::string typeToString<const std::string>() { return "string"; } \
     template <> \
+    template <>
+    inline std::string typeToString<std::string>() { return "string"; }
+    template <>
+    inline std::string typeToString<std::string&>() { return "string"; }
+    template <>
+    inline std::string typeToString<const std::string>() { return "string"; }
+    template <>
     inline std::string typeToString<const std::string&>() { return "string"; }
 …
             virtual ~Functor() {}
             virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+            virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
             inline unsigned int getParamCount() const { return this->numParams_; }
             inline bool hasReturnvalue() const { return this->hasReturnValue_; }
             inline FunctionType getType() const { return this->type_; }
             inline MultiTypeMath getReturnvalue() const { return this->returnedValue_; }
+            inline MultiType getReturnvalue() const { return this->returnedValue_; }
             std::string getTypenameParam(unsigned int param) const { return (param >= 0 && param < 5) ? this->typeParam_[param] : ""; }
             std::string getTypenameReturnvalue() const { return this->typeReturnvalue_; }
             virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const = 0;
+            virtual void evaluateParam(unsigned int index, MultiType& param) const = 0;
         protected:
 …
             bool hasReturnValue_;
             FunctionType type_;
             MultiTypeMath returnedValue_;
+            MultiType returnedValue_;
             std::string typeReturnvalue_;
 …
         public:
             virtual ~FunctorStatic() {}
             virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+            virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
     };
 …
             virtual ~FunctorMember() {}
             virtual void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
             virtual void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
             virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+            virtual void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
+            virtual void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
+            virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null)
+            {
                 if (this->bConstObject_)
 …
 #define FUNCTOR_EVALUATE_PARAM0
 #define FUNCTOR_EVALUATE_PARAM1 \
     if (index == 0) { P1 temp = param; param = temp; }
+    if (index == 0) { param.convert<P1>(); }
 #define FUNCTOR_EVALUATE_PARAM2 \
     if (index == 0) { P1 temp = param; param = temp; } \
     else if (index == 1) { P2 temp = param; param = temp; }
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); }
 #define FUNCTOR_EVALUATE_PARAM3 \
     if (index == 0) { P1 temp = param; param = temp; } \
     else if (index == 1) { P2 temp = param; param = temp; } \
     else if (index == 2) { P3 temp = param; param = temp; }
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); } \
+    else if (index == 2) { param.convert<P3>(); }
 #define FUNCTOR_EVALUATE_PARAM4 \
     if (index == 0) { P1 temp = param; param = temp; } \
     else if (index == 1) { P2 temp = param; param = temp; } \
     else if (index == 2) { P3 temp = param; param = temp; } \
     else if (index == 3) { P4 temp = param; param = temp; }
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); } \
+    else if (index == 2) { param.convert<P3>(); } \
+    else if (index == 3) { param.convert<P4>(); }
 #define FUNCTOR_EVALUATE_PARAM5 \
     if (index == 0) { P1 temp = param; param = temp; } \
     else if (index == 1) { P2 temp = param; param = temp; } \
     else if (index == 2) { P3 temp = param; param = temp; } \
     else if (index == 3) { P4 temp = param; param = temp; } \
     else if (index == 4) { P5 temp = param; param = temp; }
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); } \
+    else if (index == 2) { param.convert<P3>(); } \
+    else if (index == 3) { param.convert<P4>(); } \
+    else if (index == 4) { param.convert<P5>(); }
 …
             } \
+    \
             void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
+    \
             virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            virtual void evaluateParam(unsigned int index, MultiType& param) const \
             { \
                 FUNCTOR_EVALUATE_PARAM(numparams); \
 …
             } \
+    \
             void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
+    \
             void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 COUT(1) << "An error occurred in Functor.h:" << std::endl; \
 …
             } \
+    \
             virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            virtual void evaluateParam(unsigned int index, MultiType& param) const \
             { \
                 FUNCTOR_EVALUATE_PARAM(numparams); \
 …
             } \
+    \
             void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
+    \
             void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
+    \
             virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            virtual void evaluateParam(unsigned int index, MultiType& param) const \
             { \
                 FUNCTOR_EVALUATE_PARAM(numparams); \

code/trunk/src/core/IRC.cc

-                      r1505
+                      r1747
 namespace orxonox
+{
+    SetConsoleCommand(IRC, say,  true).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(IRC, msg,  false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(IRC, nick, false).setAccessLevel(AccessLevel::User);
+    IRC* instance_irc = &IRC::getInstance();
+    SetConsoleCommand(IRC, say,  true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(IRC, msg,  false).accessLevel(AccessLevel::User);
+    SetConsoleCommand(IRC, nick, false).accessLevel(AccessLevel::User);
     IRC::IRC()

code/trunk/src/core/Identifier.cc

-                      r1543
+                      r1747
 #include "Factory.h"
+#include "ConfigValueContainer.h"
 #include "ConsoleCommand.h"
 #include "CommandExecutor.h"
+#include "XMLPort.h"
 namespace orxonox
 …
     Identifier::Identifier()
+    {
+        this->objects_ = new ObjectListBase(this);
         this->bCreatedOneObject_ = false;
+        this->bSetName_ = false;
         this->factory_ = 0;
 …
         delete this->children_;
         delete this->directChildren_;
+        delete this->objects_;
+        if (this->factory_)
+            delete this->factory_;
+        for (std::map<std::string, ConsoleCommand*>::iterator it = this->consoleCommands_.begin(); it != this->consoleCommands_.end(); ++it)
+            delete (it->second);
+        for (std::map<std::string, ConfigValueContainer*>::iterator it = this->configValues_.begin(); it != this->configValues_.end(); ++it)
+            delete (it->second);
+        for (std::map<std::string, XMLPortParamContainer*>::iterator it = this->xmlportParamContainers_.begin(); it != this->xmlportParamContainers_.end(); ++it)
+            delete (it->second);
+        for (std::map<std::string, XMLPortObjectContainer*>::iterator it = this->xmlportObjectContainers_.begin(); it != this->xmlportObjectContainers_.end(); ++it)
+            delete (it->second);
+    }
 …
         @return The identifier (unique instance)
     */
     Identifier *Identifier::getIdentifier(std::string &name, Identifier *proposal)
+    Identifier* Identifier::getIdentifierSingleton(const std::string& name, Identifier* proposal)
+    {
         static std::map<std::string, Identifier*> identifiers;    //!< The map to store all Identifiers.
         std::map<std::string, Identifier*>::const_iterator it = identifiers.find(name);
+        if (it == identifiers.end())
+        {
+            // there isn't an entry yet, put the proposal in it
+        if (it != identifiers.end())
+        {
+            // There is already an entry: return it and delete the proposal
+            delete proposal;
+            return (*it).second;
+        }
+        else
+        {
+            // There is no entry: put the proposal into the map and return it
             identifiers[name] = proposal;
+        }
+        else
+        {
+            // this happens when a template exists twice --> delete the proposal
+            delete proposal;
+        }
+        return identifiers[name];
+            return proposal;
+        }
+    }
 …
                 // Tell the parent we're one of it's direct children
                 (*it)->getDirectChildrenIntern().insert((*it)->getDirectChildrenIntern().end(), this);
+                // Create the super-function dependencies
+                (*it)->createSuperFunctionCaller();
+            }
+        }
+    }
+    /**
+        @brief Destroys all Identifiers. Called when exiting the program.
+    */
+    void Identifier::destroyAllIdentifiers()
+    {
+        for (std::map<std::string, Identifier*>::iterator it = Identifier::getIdentifierMapIntern().begin(); it != Identifier::getIdentifierMapIntern().end(); ++it)
+            delete (it->second);
+    }
+    /**
+        @brief Sets the name of the class.
+        @param name The name
+    */
+    void Identifier::setName(const std::string& name)
+    {
+        if (!this->bSetName_)
+        {
+            this->name_ = name;
+            this->bSetName_ = true;
+            Identifier::getIdentifierMapIntern()[name] = this;
+            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
+        }
+    }
 …
+        {
             COUT(2) << "Warning: Overwriting config-value with name " << varname << " in class " << this->getName() << "." << std::endl;
+            delete (it->second);
+        }
 …
+        {
             COUT(2) << "Warning: Overwriting console-command with name " << command->getName() << " in class " << this->getName() << "." << std::endl;
+            delete (it->second);
+        }
 …
         else
             return 0;
+    }
+    /**
+        @brief Returns a XMLPortParamContainer that loads a parameter of this class.
+        @param paramname The name of the parameter
+        @return The container
+    */
+    XMLPortParamContainer* Identifier::getXMLPortParamContainer(const std::string& paramname)
+    {
+        std::map<std::string, XMLPortParamContainer*>::const_iterator it = xmlportParamContainers_.find(paramname);
+        if (it != xmlportParamContainers_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+    /**
+        @brief Adds a new XMLPortParamContainer that loads a parameter of this class.
+        @param paramname The name of the parameter
+        @param container The container
+    */
+    void Identifier::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
+    {
+        this->xmlportParamContainers_[paramname] = container;
+    }
+    /**
+        @brief Returns a XMLPortObjectContainer that attaches an object to this class.
+        @param sectionname The name of the section that contains the attachable objects
+        @return The container
+    */
+    XMLPortObjectContainer* Identifier::getXMLPortObjectContainer(const std::string& sectionname)
+    {
+        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = xmlportObjectContainers_.find(sectionname);
+        if (it != xmlportObjectContainers_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+    /**
+        @brief Adds a new XMLPortObjectContainer that attaches an object to this class.
+        @param sectionname The name of the section that contains the attachable objects
+        @param container The container
+    */
+    void Identifier::addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container)
+    {
+        this->xmlportObjectContainers_[sectionname] = container;
+    }

code/trunk/src/core/Identifier.h

-                      r1639
+                      r1747
 #include <stdlib.h>
+#include "ObjectList.h"
+#include "Debug.h"
+#include "MetaObjectList.h"
 #include "Iterator.h"
+#include "MetaObjectList.h"
+#include "Super.h"
+#include "util/Debug.h"
 #include "util/String.h"
 …
+    {
         template <class T>
-        friend class ClassIdentifier;
-        template <class T>
         friend class SubclassIdentifier;
 …
             bool isDirectParentOf(const Identifier* identifier) const;
             virtual const ObjectList<BaseObject>* getObjectList() const = 0;
             virtual void updateConfigValues() const = 0;
+            /** @brief Returns the list of all existing objects of this class. @return The list */
+            inline ObjectListBase* getObjects() const
+                { return this->objects_; }
             /** @brief Returns the name of the class the Identifier belongs to. @return The name */
             inline const std::string& getName() const { return this->name_; }
+            void setName(const std::string& name);
+            virtual void updateConfigValues(bool updateChildren = true) const = 0;
             /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
 …
             ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
             virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container) = 0;
             virtual XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname) = 0;
             virtual void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container) = 0;
             virtual XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname) = 0;
+            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
+            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
+            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
+            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
             ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
 …
         protected:
+            Identifier();
+            Identifier(const Identifier& identifier); // don't copy
+            virtual ~Identifier();
+            void initialize(std::set<const Identifier*>* parents);
+            static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
+            virtual void createSuperFunctionCaller() const = 0;
             /** @brief Returns the map that stores all Identifiers. @return The map */
             static std::map<std::string, Identifier*>& getIdentifierMapIntern();
 …
             static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
-        private:
-            Identifier();
-            Identifier(const Identifier& identifier); // don't copy
-            virtual ~Identifier();
-            void initialize(std::set<const Identifier*>* parents);
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
             inline std::set<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
 …
             inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
+            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
+            ObjectListBase* objects_;                                      //!< The list of all objects of this class
+        private:
             /**
                 @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
 …
+            }
             static Identifier* getIdentifier(std::string &name, Identifier *proposal);
+            static void destroyAllIdentifiers();
             std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
 …
             std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
+            bool bSetName_;                                                //!< True if the name is set
             std::string name_;                                             //!< The name of the class the Identifier belongs to
             BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
-            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
             static int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
             unsigned int classID_;                                         //!< The network ID to identify a class through the network
 …
             std::map<std::string, ConsoleCommand*> consoleCommands_;       //!< All console commands of this class
             std::map<std::string, ConsoleCommand*> consoleCommands_LC_;    //!< All console commands of this class with their names in lowercase
+            std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
+            std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
     };
 …
     class ClassIdentifier : public Identifier
+    {
+        #define SUPER_INTRUSIVE_DECLARATION_INCLUDE
+        #include "Super.h"
         public:
+            ClassIdentifier<T>* registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass);
+            static ClassIdentifier<T> *getIdentifier();
+            static ClassIdentifier<T> *getIdentifier(const std::string& name);
+            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
+            static bool isFirstCall();
             void addObject(T* object);
+            void setName(const std::string& name);
+            /** @brief Returns the list of all existing objects of this class. @return The list */
+            inline ObjectList<T>* getObjects() const { return this->objects_; }
+            /** @brief Returns a list of all existing objects of this class. @return The list */
+            inline ObjectList<BaseObject>* getObjectList() const { return (ObjectList<BaseObject>*)this->objects_; }
+            void updateConfigValues() const;
+            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
+            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
+            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
+            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
+            static ClassIdentifier<T> *getIdentifier();
+            void updateConfigValues(bool updateChildren = true) const;
         private:
-            ClassIdentifier();
             ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
+            ~ClassIdentifier() {}                                       // don't delete
+            ObjectList<T>* objects_;                                                                    //!< The ObjectList, containing all objects of type T
+            bool bSetName_;                                                                             //!< True if the name is set
+            std::map<std::string, XMLPortClassParamContainer<T>*> xmlportParamContainers_;              //!< All loadable parameters
+            std::map<std::string, XMLPortClassObjectContainer<T, class O>*> xmlportObjectContainers_;   //!< All attachable objects
+            ClassIdentifier()
+            {
+                SuperFunctionInitialization<0, T>::initialize(this);
+            }
+            ~ClassIdentifier()
+            {
+                SuperFunctionDestruction<0, T>::destroy(this);
+            }
             static ClassIdentifier<T> *classIdentifier_s;
 …
     /**
-        @brief Constructor: Creates the ObjectList.
-    */
-    template <class T>
-    ClassIdentifier<T>::ClassIdentifier()
+    {
-//        this->objects_ = ObjectList<T>::getList();
-        this->objects_ = new ObjectList<T>();
-        this->bSetName_ = false;
+    }
-    /**
         @brief Registers a class, which means that the name and the parents get stored.
         @param parents A list, containing the Identifiers of all parents of the class
-        @param name A string, containing exactly the name of the class
         @param bRootClass True if the class is either an Interface or the BaseObject itself
+        @return The ClassIdentifier itself
+    */
+    template <class T>
+    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass)
+    {
+        this->setName(name);
+    */
+    template <class T>
+    void ClassIdentifier<T>::initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass)
+    {
         // Check if at least one object of the given type was created
         if (!this->bCreatedOneObject_ && Identifier::isCreatingHierarchy())
+        {
             // If no: We have to store the informations and initialize the Identifier
             COUT(4) << "*** ClassIdentifier: Register Class in " << name << "-Singleton -> Initialize Singleton." << std::endl;
+            COUT(4) << "*** ClassIdentifier: Register Class in " << this->getName() << "-Singleton -> Initialize Singleton." << std::endl;
             if (bRootClass)
                 this->initialize(NULL); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
+                this->initialize(0); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
             else
                 this->initialize(parents);
+        }
-        return this;
+    }
     /**
+        @brief Creates the only instance of this class for the template class T and retrieves a unique Identifier for the given name.
+        @brief Returns true if the function gets called the first time, false otherwise.
+        @return True if this function got called the first time.
+    */
+    template <class T>
+    bool ClassIdentifier<T>::isFirstCall()
+    {
+        static bool bFirstCall = true;
+        if (bFirstCall)
+        {
+            bFirstCall = false;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+    /**
+        @brief Returns the only instance of this class.
         @return The unique Identifier
     */
 …
+    {
         // check if the static field has already been filled
         if (ClassIdentifier<T>::classIdentifier_s == 0)
+        if (ClassIdentifier<T>::isFirstCall())
+        {
             // Get the name of the class
 …
             // create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
             ClassIdentifier<T> *proposal = new ClassIdentifier<T>();
+            ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
             // Get the entry from the map
+            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifier(name, proposal);
+            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
+            if (ClassIdentifier<T>::classIdentifier_s == proposal)
+            {
+                COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
+            }
+            else
+            {
+                COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
+            }
+        }
 …
     /**
+        @brief Sets the name of the class.
+        @param name The name
+    */
+    template <class T>
+    void ClassIdentifier<T>::setName(const std::string& name)
+    {
+        if (!this->bSetName_)
+        {
+            this->name_ = name;
+            this->bSetName_ = true;
+            Identifier::getIdentifierMapIntern()[name] = this;
+            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
+        }
+        @brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
+        @param name The name of this Identifier
+        @return The Identifier
+    */
+    template <class T>
+    ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
+    {
+        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
+        identifier->setName(name);
+        return identifier;
+    }
 …
+    {
         COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
         object->getMetaList().add(this->objects_, this->objects_->add(object));
+        object->getMetaList().add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
+    }
 …
     */
     template <class T>
+    void ClassIdentifier<T>::updateConfigValues() const
+    {
+        for (Iterator<T> it = this->objects_->start(); it; ++it)
+            ((T*)*it)->setConfigValues();
+    }
+    /**
+        @brief Returns a XMLPortParamContainer that loads a parameter of this class.
+        @param paramname The name of the parameter
+        @return The container
+    */
+    template <class T>
+    XMLPortParamContainer* ClassIdentifier<T>::getXMLPortParamContainer(const std::string& paramname)
+    {
+        typename std::map<std::string, XMLPortClassParamContainer<T>*>::const_iterator it = xmlportParamContainers_.find(paramname);
+        if (it != xmlportParamContainers_.end())
+            return (XMLPortParamContainer*)((*it).second);
+        else
+            return 0;
+    }
+    /**
+        @brief Adds a new XMLPortParamContainer that loads a parameter of this class.
+        @param paramname The name of the parameter
+        @param container The container
+    */
+    template <class T>
+    void ClassIdentifier<T>::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
+    {
+        this->xmlportParamContainers_[paramname] = (XMLPortClassParamContainer<T>*)container;
+    }
+    /**
+        @brief Returns a XMLPortObjectContainer that attaches an object to this class.
+        @param sectionname The name of the section that contains the attachable objects
+        @return The container
+    */
+    template <class T>
+    XMLPortObjectContainer* ClassIdentifier<T>::getXMLPortObjectContainer(const std::string& sectionname)
+    {
+        typename std::map<std::string, XMLPortClassObjectContainer<T, class O>*>::const_iterator it = xmlportObjectContainers_.find(sectionname);
+        if (it != xmlportObjectContainers_.end())
+            return (XMLPortObjectContainer*)((*it).second);
+        else
+            return 0;
+    }
+    /**
+        @brief Adds a new XMLPortObjectContainer that attaches an object to this class.
+        @param sectionname The name of the section that contains the attachable objects
+        @param container The container
+    */
+    template <class T>
+    void ClassIdentifier<T>::addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container)
+    {
+        this->xmlportObjectContainers_[sectionname] = (XMLPortClassObjectContainer<T, class O>*)container;
+    void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
+    {
+        if (!this->hasConfigValues())
+            return;
+        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
+            it->setConfigValues();
+        if (updateChildren)
+            for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
+                (*it)->updateConfigValues(false);
+    }

code/trunk/src/core/Iterator.h

-                      r1625
+                      r1747
     @brief Definition and implementation of the Iterator class.
     The Iterator of a given class allows to iterate through an ObjectList, containing all objects of that type.
     This is the only way to access the objects stored in an ObjectList.
+    The Iterator of a given class allows to iterate through an ObjectList. Objects in
+    this list are casted to the template argument of the Iterator.
     Usage:
     for (Iterator<class> it = ObjectList<class>::start(); it != 0; ++it)
+    for (Iterator<myClass> it = anyidentifier->getObjects().begin(); it != anyidentifier->getObjects().end(); ++it)
+    {
         it->someFunction(...);
         class* myObject = *it;
+        myClass* myObject = *it;
+    }
-    Warning: Don't delete objects directly through the iterator.
 */
 …
 #include "CorePrereqs.h"
+#include "ObjectList.h"
+#include "ObjectListBase.h"
+#include "ObjectListIterator.h"
+#include "OrxonoxClass.h"
 namespace orxonox
+{
     //! The iterator allows to iterate through an ObjectList of a given class.
     template <class T>
+    //! The Iterator allows to iterate through a given ObjectList
+    template <class T = OrxonoxClass>
     class Iterator
+    {
 …
                 @brief Constructor: Sets the element, whereon the iterator points, to zero.
             */
             Iterator()
+            inline Iterator()
+            {
                 this->element_ = 0;
+                ClassIdentifier<T>::getIdentifier()->getObjects()->registerIterator(this);
+            }
+            /**
+                @brief Constructor: Sets the element, whereon the iterator points, to a given element.
+                @param element The element to start with
+            */
+            Iterator(ObjectListElement<T>* element)
+            {
+                this->element_ = element;
+                ClassIdentifier<T>::getIdentifier()->getObjects()->registerIterator(this);
+                this->list_ = 0;
+            }
+            /**
+                @brief Constructor: Sets this element to the exported element.
+                @param exp The exported element
+            */
+            inline Iterator(const ObjectListBase::Export& exp)
+            {
+                this->element_ = exp.element_;
+                this->list_ = exp.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+            }
+            /**
+                @brief Constructor: Sets this element to the element of another Iterator.
+                @param other The other Iterator
+            */
+            inline Iterator(const Iterator<T>& other)
+            {
+                this->element_ = other.element_;
+                this->list_ = other.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+            }
+            /**
+                @brief Constructor: Sets this element to a given element
+                @param element The element
+            */
+            template <class O>
+            inline Iterator(ObjectListElement<O>* element)
+            {
+                this->element_ = (element) ? (ObjectListBaseElement*)element : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
+            }
+            /**
+                @brief Constructor: Sets this element to the element an ObjectListIterator.
+                @param other The ObjectListIterator
+            */
+            template <class O>
+            inline Iterator(const ObjectListIterator<O>& other)
+            {
+                this->element_ = (other.element_) ? (ObjectListBaseElement*)other.element_ : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
+            }
 …
                 @brief Unregisters the Iterator from the ObjectList.
             */
+            ~Iterator()
+            {
+                ClassIdentifier<T>::getIdentifier()->getObjects()->unregisterIterator(this);
+            }
+            /**
+                @brief Assigns an element to the iterator.
+            inline ~Iterator()
+            {
+                this->list_->unregisterIterator(this->iterator_);
+            }
+            /**
+                @brief Assigns an exported element.
+                @param exp The exported element
+            */
+            inline const Iterator<T>& operator=(const ObjectListBase::Export& exp)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+                this->element_ = exp.element_;
+                this->list_ = exp.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+                return (*this);
+            }
+            /**
+                @brief Assigns the element of another Iterator.
+                @param other The other Iterator
+            */
+            inline const Iterator<T>& operator=(const Iterator<T>& other)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+                this->element_ = other.element_;
+                this->list_ = other.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+                return (*this);
+            }
+            /**
+                @brief Assigns a given element.
                 @param element The element
             */
+            Iterator<T> operator=(ObjectListElement<T>* element)
+            {
+                this->element_ = element;
+            template <class O>
+            inline const Iterator<T>& operator=(ObjectListElement<O>* element)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+                this->element_ = (element) ? (ObjectListBaseElement*)element : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
+                return (*this);
                 return *this;
+            }
+            /**
+                @brief Assigns the element of an ObjectListIterator.
+                @param other The ObjectListIterator
+            */
+            template <class O>
+            inline const Iterator<T>& operator=(const ObjectListIterator<O>& other)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+                this->element_ = (other.element_) ? (ObjectListBaseElement*)other.element_ : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
+                return (*this);
+            }
 …
                 @return The Iterator itself
             */
             Iterator<T> operator++()
+            inline const Iterator<T>& operator++()
+            {
                 if (this->element_)
 …
                 @return The Iterator itself
             */
             Iterator<T> operator++(int i)
+            inline Iterator<T> operator++(int i)
+            {
                 Iterator<T> copy = *this;
 …
                 @return The Iterator itself
             */
             Iterator<T> operator--()
+            inline const Iterator<T>& operator--()
+            {
                 if (this->element_)
 …
                 @return The Iterator itself
             */
             Iterator<T> operator--(int i)
+            inline Iterator<T> operator--(int i)
+            {
                 Iterator<T> copy = *this;
 …
                 @return The object the Iterator points at
             */
             T* operator*()
+            {
                 if (this->element_)
                     return this->element_->object_;
+            inline T* operator*() const
+            {
+                if (this->element_)
+                    return dynamic_cast<T*>(this->element_->objectBase_);
                 else
                     return 0;
 …
                 @return The object the Iterator points at
             */
             T* operator->() const
+            {
                 if (this->element_)
                     return this->element_->object_;
+            inline T* operator->() const
+            {
+                if (this->element_)
+                    return dynamic_cast<T*>(this->element_->objectBase_);
                 else
                     return 0;
+            }
             /**
                 @brief Overloading of the typecast-operator to bool: returns true if the iterator points to an existing object.
                 @return True if the iterator points to an existing object.
             */
             operator bool()
+                @return True if the Iterator points to an existing object.
+            */
+            inline operator bool() const
+            {
                 return (this->element_ != 0);
 …
             /**
+                @brief Overloading of the (it != int) operator: Used for (it != 0) instead of typecast-operator to bool.
+                @param compare The integer (must be zero, everything else makes no sense).
+                @return True if the iterator points to an existing object.
+            */
+            bool operator!=(ObjectListElement<T>* compare)
+            {
+                return (this->element_ != compare);
+            }
+        private:
+            ObjectListElement<T>* element_;     //!< The element the Iterator points at
+                @brief Overloading of the == operator to compare with another Iterator.
+                @param compare The other Iterator
+                @return True if the iterators point to the same element
+            */
+            inline bool operator==(const Iterator<T>& compare) const
+            {
+                return (this->element_ == compare.element_);
+            }
+            /**
+                @brief Overloading of the != operator to compare with another Iterator.
+                @param compare The other Iterator
+                @return True if the iterators point to different elements
+            */
+            inline bool operator!=(const Iterator<T>& compare) const
+            {
+                return (this->element_ != compare.element_);
+            }
+            /**
+                @brief Increments the Iterator if it points at the given object.
+                @param object The object to compare with
+            */
+            inline void incrementIfEqual(OrxonoxClass* object)
+            {
+                if (this->element_ && this->element_->objectBase_ == object)
+                    this->operator++();
+            }
+        protected:
+            ObjectListBaseElement* element_;       //!< The element the Iterator points at
+            ObjectListBase* list_;                 //!< The list wherein the element is
+            std::list<void*>::iterator iterator_;  //!< The iterator in the notifying list of the ObjectList
     };
+    typedef Iterator<OrxonoxClass> BaseIterator;
+}
+// Include ObjectList.h so the user only has to include one file: Iterator.h
+#include "ObjectList.h"
 #endif /* _Iterator_H__ */

code/trunk/src/core/Language.cc

-                      r1535
+                      r1747
 #include "Core.h"
+#include "Debug.h"
+#include "util/Debug.h"
 namespace orxonox
 …
         // Read the default language file to create all known LanguageEntry objects
         this->readDefaultLanguageFile();
+    }
+    /**
+        @brief Destructor: Deletes all language entries.
+    */
+    Language::~Language()
+    {
+        for (std::map<std::string, LanguageEntry*>::iterator it = this->languageEntries_.begin(); it != this->languageEntries_.end(); ++it)
+            delete (it->second);
+    }

code/trunk/src/core/Language.h

r1535	r1747
123	123	Language();
124	124	Language(const Language& language); // don't copy
125		virtual ~Language() ~~{}; // don't delete~~
	125	virtual ~Language();
126	126
127	127	void readDefaultLanguageFile();

code/trunk/src/core/Loader.cc

-                      r1625
+                      r1747
 #include "Identifier.h"
 #include "Iterator.h"
 #include "Debug.h"
+#include "ObjectList.h"
 #include "CoreIncludes.h"
 #include "Script.h"
 #include "Namespace.h"
+#include "util/Debug.h"
 #include "tinyxml/ticpp.h"
 …
     void Loader::unload(const ClassTreeMask& mask)
+    {
         for (Iterator<BaseObject> it = ObjectList<BaseObject>::begin(); it; )
+        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); )
+        {
             if (mask.isIncluded(it->getIdentifier()))
 …
     void Loader::unload(const Level* level, const ClassTreeMask& mask)
+    {
         for (Iterator<BaseObject> it = ObjectList<BaseObject>::begin(); it; )
+        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it; )
+        {
             if ((it->getLevel() == level) && mask.isIncluded(it->getIdentifier()))

code/trunk/src/core/MetaObjectList.cc

-                      r1505
+                      r1747
 #include "MetaObjectList.h"
+#include "ObjectListBase.h"
+#include "Identifier.h"
+#include "util/Debug.h"
 namespace orxonox
+{
+    // ###############################
+    // ###  MetaObjectListElement  ###
+    // ###############################
+    /**
+        @brief Destructor: Removes the ObjectListBaseElement from the ObjectListBase by linking next_ and prev_ of the ObjectListBaseElement.
+    */
+    MetaObjectListElement::~MetaObjectListElement()
+    {
+        COUT(5) << "*** MetaObjectList: Removing Object from " << this->list_->getIdentifier()->getName() << "-list." << std::endl;
+        this->list_->notifyIterators(this->element_->objectBase_);
+        if (this->element_->next_)
+            this->element_->next_->prev_ = this->element_->prev_;
+        else
+            this->list_->last_ = this->element_->prev_; // If there is no next_, we deleted the last object and have to update the last_ pointer of the list
+        if (this->element_->prev_)
+            this->element_->prev_->next_ = this->element_->next_;
+        else
+            this->list_->first_ = this->element_->next_; // If there is no prev_, we deleted the first object and have to update the first_ pointer of the list
+        delete this->element_;
+    }
+    // ###############################
+    // ###     MetaObjectList      ###
+    // ###############################
     /**
         @brief Constructor: Sets first_ to zero.
 …
     MetaObjectList::~MetaObjectList()
+    {
         BaseMetaObjectListElement* temp;
+        MetaObjectListElement* temp;
         while (this->first_)
+        {
 …
+        }
+    }
+    /**
+        @brief Adds an ObjectList and an element of that list to the MetaObjectList.
+        @param list The ObjectList wherein the element is
+        @param element The element wherein the object is
+    */
+    void MetaObjectList::add(ObjectListBase* list, ObjectListBaseElement* element)
+    {
+        MetaObjectListElement* temp = this->first_;
+        this->first_ = new MetaObjectListElement(list, element);
+        this->first_->next_ = temp;
+    }
+}

code/trunk/src/core/MetaObjectList.h

-                      r1543
+                      r1747
 #include "CorePrereqs.h"
-#include "ObjectList.h"
-#include "Identifier.h"
-#include "Debug.h"
 namespace orxonox
+{
-    //! Base-class of MetaObjectListElement, because those is a template
-    class BaseMetaObjectListElement
+    {
-        public:
-            /** @brief Default destructor */
-            virtual ~BaseMetaObjectListElement() {};
-            BaseMetaObjectListElement* next_;       //!< The next Element in the list
-    };
     // ###############################
     // ###  MetaObjectListElement  ###
     // ###############################
     //! The list-element of the MetaObjectList
+    template <class T>
+    class MetaObjectListElement : public BaseMetaObjectListElement
+    class _CoreExport MetaObjectListElement
+    {
         public:
+            MetaObjectListElement(ObjectList<T>* list, ObjectListElement<T>* element);
+            virtual ~MetaObjectListElement();
+            /**
+                @brief Constructor: Creates the list-element with given list and element.
+            */
+            MetaObjectListElement(ObjectListBase* list, ObjectListBaseElement* element) : next_(0), element_(element), list_(list) {}
+            ~MetaObjectListElement();
+            ObjectListElement<T>* element_;         //!< The list element, containing the object
+            ObjectList<T>* list_;                   //!< The list, containing the element
+            MetaObjectListElement* next_;       //!< The next Element in the list
+            ObjectListBaseElement* element_;    //!< The list element, containing the object
+            ObjectListBase* list_;              //!< The list, containing the element
     };
-    /**
-        @brief Constructor: Creates the list-element with given list and element.
-    */
-    template <class T>
-    MetaObjectListElement<T>::MetaObjectListElement(ObjectList<T>* list, ObjectListElement<T>* element)
+    {
-        this->element_ = element;
-        this->list_ = list;
-        this->next_ = 0;
+    }
-    /**
-        @brief Destructor: Removes the ObjectListElement from the ObjectList by linking next_ and prev_ of the ObjectListElement.
-    */
-    template <class T>
-    MetaObjectListElement<T>::~MetaObjectListElement()
+    {
-        COUT(5) << "*** MetaObjectList: Removing Object from " << ClassIdentifier<T>::getIdentifier()->getName() << "-list." << std::endl;
-        this->list_->notifyIterators(this->element_);
-        if (this->element_->next_)
-            this->element_->next_->prev_ = this->element_->prev_;
-        else
-            this->list_->last_ = this->element_->prev_; // If there is no next_, we deleted the last object and have to update the last_ pointer of the list
-        if (this->element_->prev_)
-            this->element_->prev_->next_ = this->element_->next_;
-        else
-            this->list_->first_ = this->element_->next_; // If there is no prev_, we deleted the first object and have to update the first_ pointer of the list
-        delete this->element_;
+    }
 …
     // ###     MetaObjectList      ###
     // ###############################
     //!  The MetaObjectList contains ObjectListElements and their ObjectLists.
+    //!  The MetaObjectList contains ObjectListBaseElements and their ObjectListBases.
     /**
         The MetaObjectList is a single-linked list, containing all list-elements and their
 …
             MetaObjectList();
             ~MetaObjectList();
+            template <class T>
+            void add(ObjectList<T>* list, ObjectListElement<T>* element);
+            void add(ObjectListBase* list, ObjectListBaseElement* element);
             BaseMetaObjectListElement* first_;      //!< The first element in the list
+            MetaObjectListElement* first_;      //!< The first element in the list
     };
-    /**
-        @brief Adds an ObjectList and an element of that list to the MetaObjectList.
-        @param list The ObjectList wherein the element is
-        @param element The element wherein the object is
-    */
-    template <class T>
-    void MetaObjectList::add(ObjectList<T>* list, ObjectListElement<T>* element)
+    {
-        BaseMetaObjectListElement* temp = this->first_;
-        this->first_ = new MetaObjectListElement<T>(list, element);
-        this->first_->next_ = temp;
+    }
+}

code/trunk/src/core/Namespace.cc

r1505	r1747
60	60	void Namespace::XMLPort(Element& xmlelement, XMLPort::Mode mode)
61	61	{
62		~~BaseObject::XMLPort(~~xmlelement, mode);
	62	SUPER(Namespace, XMLPort, xmlelement, mode);
63	63
64	64	std::string name = this->getName();

code/trunk/src/core/NamespaceNode.cc

r1505	r1747
28	28
29	29	#include "NamespaceNode.h"
30		#include "Debug.h"
	30	#include "util/Debug.h"
31	31
32	32	namespace orxonox

code/trunk/src/core/ObjectList.h

-                      r1543
+                      r1747
     @brief Definition and implementation of the ObjectList class.
+    The ObjectList 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.
+    The ObjectList is a wrapper of an ObjectListBase of a given class.
     Use Iterator<class> to iterate through all objects of the class.
 */
 …
 #define _ObjectList_H__
-#include <set>
 #include "CorePrereqs.h"
-#include "Iterator.h"
 #include "Identifier.h"
+#include "ObjectListIterator.h"
 namespace orxonox
+{
     // ###############################
-    // ###    ObjectListElement    ###
-    // ###############################
-    //! The list-element of the ObjectList
-    template <class T>
-    class ObjectListElement
+    {
-        public:
-            ObjectListElement(T* object);
-            T* object_;                     //!< The object
-            ObjectListElement* next_;       //!< The next element in the list
-            ObjectListElement* prev_;       //!< The previous element in the list
-    };
-    /**
-        @brief Constructor: Creates the list-element with an object.
-        @param object The object to store
-    */
-    template <class T>
-    ObjectListElement<T>::ObjectListElement(T* object)
+    {
-        this->object_ = object;
-        this->next_ = 0;
-        this->prev_ = 0;
+    }
-    // ###############################
     // ###       ObjectList        ###
     // ###############################
     //! The ObjectList contains all objects of a given class.
+    //! The ObjectList contains all objects of the given class.
     /**
         The ObjectList is used by Identifiers to store all objects of a given class.
         Use Iterator<class> to iterate through all objects in the list.
+        Wraps the ObjectListBase of the corresponding Identifier.
+        Use ObjectListIterator<class> to iterate through all objects in the list.
     */
     template <class T>
 …
+    {
         public:
+            ObjectList();
+            ~ObjectList();
+            typedef ObjectListIterator<T> iterator;
+            ObjectListElement<T>* add(T* object);
+            /** @brief Returns an Iterator to the first element in the list. @return The Iterator */
+            inline static ObjectListElement<T>* begin()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->begin().element_); }
             /** @brief Returns the first element in the list. @return The first element */
             inline static Iterator<T> start()
                 { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->first_); }
+            /** @brief Returns an Iterator to the element after the last element in the list. @return The Iterator */
+            inline static ObjectListElement<T>* end()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->end().element_); }
             /** @brief Returns the first element in the list. @return The first element */
             inline static Iterator<T> begin()
                 { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->first_); }
+            /** @brief Returns an Iterator to the last element in the list. @return The Iterator */
+            inline static ObjectListElement<T>* rbegin()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->rbegin().element_); }
+            /** @brief Returns the last element in the list. @return The last element */
+            inline static Iterator<T> end()
+                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->last_); }
+            inline void registerIterator(Iterator<T>* iterator)
+                { this->iterators_.insert(this->iterators_.end(), (void*)iterator); }
+            inline void unregisterIterator(Iterator<T>* iterator)
+                { this->iterators_.erase((void*)iterator); }
+            void notifyIterators(ObjectListElement<T>* element);
+            ObjectListElement<T>* first_;       //!< The first element in the list
+            ObjectListElement<T>* last_;        //!< The last element in the list
+        private:
+            std::set<void*> iterators_;  //!< A list of iterators pointing on an element in this list
+            /** @brief Returns an Iterator to the element before the first element in the list. @return The Iterator */
+            inline static ObjectListElement<T>* rend()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->rend().element_); }
     };
-    /**
-        @brief Constructor: Sets default values.
-    */
-    template <class T>
-    ObjectList<T>::ObjectList()
+    {
-        this->first_ = 0;
-        this->last_ = 0;
+    }
-    /**
-        @brief Destructor: Deletes all list-elements, but NOT THE OBJECTS.
-    */
-    template <class T>
-    ObjectList<T>::~ObjectList()
+    {
-        ObjectListElement<T>* temp;
-        while (this->first_)
+        {
-            temp = this->first_->next_;
-            delete this->first_;
-            this->first_ = temp;
+        }
+    }
-    /**
-        @brief Increases all Iterators that currently point on the given element (because it gets removed).
-        @param element The element that gets removed
-    */
-    template <class T>
-    void ObjectList<T>::notifyIterators(ObjectListElement<T>* element)
+    {
-        for (std::set<void*>::iterator it = this->iterators_.begin(); it != this->iterators_.end(); ++it)
-            if ((*(*((Iterator<T>*)(*it)))) == element->object_)
-                ++(*((Iterator<T>*)(*it)));
+    }
-    /**
-        @brief Adds a new object to the end of the list.
-        @param object The object to add
-        @return The pointer to the new ObjectListElement, needed by the MetaObjectList of the added object
-    */
-    template <class T>
-    ObjectListElement<T>* ObjectList<T>::add(T* object)
+    {
-        if (!this->last_)
+        {
-            // If the list is empty
-            this->last_ = new ObjectListElement<T>(object);
-            this->first_ = this->last_; // There's only one object in the list now
+        }
-        else
+        {
-            // If the list isn't empty
-            ObjectListElement<T>* temp = this->last_;
-            this->last_ = new ObjectListElement<T>(object);
-            this->last_->prev_ = temp;
-            temp->next_ = this->last_;
+        }
-        return this->last_;
+    }
+}

code/trunk/src/core/OrxonoxClass.cc

r1505	r1747
39	39	{
40	40	/** @brief Constructor: Sets the default values. */
41		OrxonoxClass::OrxonoxClass() :
42		identifier_(0),
43		parents_(0)
	41	OrxonoxClass::OrxonoxClass()
44	42	{
	43	this->identifier_ = 0;
	44	this->parents_ = 0;
45	45	this->metaList_ = new MetaObjectList();
46
47		~~this->setConfigValues();~~
48	46	}
49	47

code/trunk/src/core/Shell.cc

-                      r1540
+                      r1747
 #include "ConsoleCommand.h"
 #include "input/InputInterfaces.h"
+#include "util/OutputHandler.h"
 #define SHELL_UPDATE_LISTENERS(function) \
 …
     SetConsoleCommand(Shell, clearShell, true);
     SetConsoleCommand(Shell, history, true);
+    SetConsoleCommandShortcut(OutputHandler, log);
+    SetConsoleCommandShortcut(OutputHandler, error);
+    SetConsoleCommandShortcut(OutputHandler, warning);
+    SetConsoleCommandShortcut(OutputHandler, info);
+    SetConsoleCommandShortcut(OutputHandler, debug);
     Shell::Shell()
 …
         this->outputBuffer_.registerListener(this);
+        OutputHandler::getOutStream().setOutputBuffer(this->outputBuffer_);
         this->setConfigValues();
 …
     void Shell::setConfigValues()
+    {
         SetConfigValue(maxHistoryLength_, 100);
         SetConfigValue(historyOffset_, 0);
+        SetConfigValue(maxHistoryLength_, 100).callback(this, &Shell::commandHistoryLengthChanged);
+        SetConfigValue(historyOffset_, 0).callback(this, &Shell::commandHistoryOffsetChanged);
         SetConfigValueVector(commandHistory_, std::vector<std::string>());
+    }
+    void Shell::commandHistoryOffsetChanged()
+    {
         if (this->historyOffset_ >= this->maxHistoryLength_)
             this->historyOffset_ = 0;
+    }
+    void Shell::commandHistoryLengthChanged()
+    {
+        this->commandHistoryOffsetChanged();
         while (this->commandHistory_.size() > this->maxHistoryLength_)

code/trunk/src/core/Shell.h

-                      r1535
+                      r1747
 #include "OrxonoxClass.h"
 #include "input/InputBuffer.h"
 #include "OutputBuffer.h"
+#include "util/OutputBuffer.h"
 namespace orxonox
 …
             virtual void setConfigValues();
+            void commandHistoryOffsetChanged();
+            void commandHistoryLengthChanged();
             void registerListener(ShellListener* listener);

code/trunk/src/core/TclBind.cc

-                      r1505
+                      r1747
 #include "ConsoleCommand.h"
 #include "CommandExecutor.h"
-#include "Debug.h"
 #include "TclThreadManager.h"
 #include "TclBind.h"
+#include "util/Debug.h"
 #include "util/String.h"
 namespace orxonox
+{
     SetConsoleCommandShortcutGeneric(tcl, createConsoleCommand(createFunctor(&TclBind::tcl), "tcl"));
     SetConsoleCommandShortcutGeneric(bgerror, createConsoleCommand(createFunctor(&TclBind::bgerror), "bgerror"));
+    SetConsoleCommandShortcut(TclBind, tcl);
+    SetConsoleCommandShortcut(TclBind, bgerror);
     TclBind::TclBind()
 …
         if (CommandExecutor::getLastEvaluation().hasReturnvalue())
             return CommandExecutor::getLastEvaluation().getReturnvalue().toString();
+            return CommandExecutor::getLastEvaluation().getReturnvalue().getString();
         return "";

code/trunk/src/core/TclThreadManager.cc

-                      r1505
+                      r1747
 #include "ConsoleCommand.h"
 #include "CommandExecutor.h"
-#include "Debug.h"
 #include "TclBind.h"
 #include "TclThreadManager.h"
+#include "util/Debug.h"
 #include "util/Convert.h"
 …
 namespace orxonox
+{
     SetConsoleCommandShortcutGeneric(tclexecute, createConsoleCommand(createFunctor(&TclThreadManager::execute), "tclexecute")).setArgumentCompleter(0, autocompletion::tclthreads());
     SetConsoleCommandShortcutGeneric(tclquery,   createConsoleCommand(createFunctor(&TclThreadManager::query),   "tclquery"  )).setArgumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommandShortcutAlias(TclThreadManager, execute, "tclexecute").argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommandShortcutAlias(TclThreadManager, query,   "tclquery"  ).argumentCompleter(0, autocompletion::tclthreads());
     SetConsoleCommand(TclThreadManager, create,  false);
     SetConsoleCommand(TclThreadManager, destroy, false).setArgumentCompleter(0, autocompletion::tclthreads());
     SetConsoleCommand(TclThreadManager, execute, false).setArgumentCompleter(0, autocompletion::tclthreads());
     SetConsoleCommand(TclThreadManager, query,   false).setArgumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand(TclThreadManager, destroy, false).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand(TclThreadManager, execute, false).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand(TclThreadManager, query,   false).argumentCompleter(0, autocompletion::tclthreads());
     SetConsoleCommand(TclThreadManager, status,  false);
+    SetConsoleCommand(TclThreadManager, dump,    false).setArgumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand(TclThreadManager, flush,   false).setArgumentCompleter(0, autocompletion::tclthreads());
+    TclThreadManager* instance_tclthreadmanager = &TclThreadManager::getInstance();
+    SetConsoleCommand(TclThreadManager, dump,    false).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand(TclThreadManager, flush,   false).argumentCompleter(0, autocompletion::tclthreads());
     TclThreadManager::TclThreadManager()
 …
         //
 #endif
+    }
+    TclThreadManager::~TclThreadManager()
+    {
+        unsigned int threadID;
+        {
+            boost::mutex::scoped_lock bundles_lock(this->bundlesMutex_);
+            if (this->interpreterBundles_.begin() == this->interpreterBundles_.end())
+                return;
+            else
+                threadID = this->interpreterBundles_.begin()->first;
+        }
+        this->destroy(threadID);
+    }
 …
                 if (CommandExecutor::getLastEvaluation().hasReturnvalue())
                     output = CommandExecutor::getLastEvaluation().getReturnvalue().toString();
+                    output = CommandExecutor::getLastEvaluation().getReturnvalue().getString();
+            }

code/trunk/src/core/TclThreadManager.h

-                      r1625
+                      r1747
     class _CoreExport TclThreadManager : public OrxonoxClass
+    {
+        friend class IRC;
+        friend class TclBind;
         public:
             static TclThreadManager& getInstance();
 …
             static void flush(unsigned int threadID);
+            void error(const std::string& error);
+            void debug(const std::string& error);
+            virtual void tick(float dt);
+            std::list<unsigned int> getThreadList() const;
+        private:
+            TclThreadManager();
+            TclThreadManager(const TclThreadManager& other);
+            ~TclThreadManager();
             static void tcl_execute(Tcl::object const &args);
             static std::string tcl_query(int querierID, Tcl::object const &args);
 …
             TclInterpreterBundle* getInterpreterBundle(unsigned int threadID);
             std::string dumpList(const std::list<unsigned int>& list);
-            void error(const std::string& error);
-            void debug(const std::string& error);
             void pushCommandToQueue(const std::string& command);
 …
             std::string evalQuery(unsigned int querierID, const std::string& command);
             std::string evalQuery(unsigned int querierID, unsigned int threadID, const std::string& command);
-            virtual void tick(float dt);
-            std::list<unsigned int> getThreadList() const;
-        private:
-            TclThreadManager();
-            TclThreadManager(const TclThreadManager& other);
-            ~TclThreadManager() {}
             unsigned int threadCounter_;

code/trunk/src/core/XMLPort.h

-                      r1628
+                      r1747
 #include "CorePrereqs.h"
+#include "util/Debug.h"
 #include "util/XMLIncludes.h"
 #include "util/MultiTypeMath.h"
+#include "util/MultiType.h"
 #include "tinyxml/ticpp.h"
 #include "Executor.h"
-#include "Debug.h"
 #include "CoreIncludes.h"
 #include "BaseObject.h"
 …
 #define XMLPortParam(classname, paramname, loadfunction, savefunction, xmlelement, mode) \
     XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), #savefunction), xmlelement, mode)
 #define XMLPortParam_Template(classname, paramname, loadtemplate, loadfunction, savetemplate, savefunction, xmlelement, mode) \
     XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, paramname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor savetemplate (&classname::savefunction), #savefunction), xmlelement, mode)
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
+#define XMLPortParamTemplate(classname, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
 #define XMLPortParamLoadOnly(classname, paramname, loadfunction, xmlelement, mode) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
+#define XMLPortParamLoadOnly_Template(classname, paramname, loadtemplate, loadfunction, xmlelement, mode) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, paramname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
+#define XMLPortParamGeneric(containername, classname, paramname, loadexecutor, saveexecutor, xmlelement, mode) \
+    orxonox::XMLPortClassParamContainer<classname>* containername = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
+#define XMLPortParamLoadOnlyTemplate(classname, paramname, loadfunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
+#define XMLPortParamExtern(classname, externclass, object, paramname, loadfunction, savefunction, xmlelement, mode) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, externclass, object, paramname, orxonox::createExecutor(orxonox::createFunctor(&externclass::loadfunction), std::string( #externclass ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&externclass::savefunction), std::string( #externclass ) + "::" + #savefunction), xmlelement, mode);
+#define XMLPortParamExternTemplate(classname, externclass, object, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, externclass, object, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&externclass::loadfunction), std::string( #externclass ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&externclass::savefunction), std::string( #externclass ) + "::" + #savefunction), xmlelement, mode);
+#define XMLPortParamGeneric(containername, classname, objectclass, object, paramname, loadexecutor, saveexecutor, xmlelement, mode) \
+    orxonox::XMLPortClassParamContainer<objectclass>* containername = (orxonox::XMLPortClassParamContainer<objectclass>*)(ClassIdentifier<classname>::getIdentifier()->getXMLPortParamContainer(paramname)); \
     if (!containername) \
     { \
         containername = new orxonox::XMLPortClassParamContainer<classname>(std::string(paramname), loadexecutor, saveexecutor); \
         this->getIdentifier()->addXMLPortParamContainer(paramname, containername); \
+        containername = new orxonox::XMLPortClassParamContainer<objectclass>(std::string(paramname), ClassIdentifier<classname>::getIdentifier(), loadexecutor, saveexecutor); \
+        ClassIdentifier<classname>::getIdentifier()->addXMLPortParamContainer(paramname, containername); \
     } \
     containername->port(this, xmlelement, mode)
+    containername->port((BaseObject*)this, object, xmlelement, mode)
 #define XMLPortObject(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
     XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
 #define XMLPortObject_Template(classname, objectclass, sectionname, loadtemplate, loadfunction, savetemplate, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
     XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor savetemplate (&classname::savefunction), #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
+#define XMLPortObjectTemplate(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore, ...) \
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
 #define XMLPortObjectGeneric(containername, classname, objectclass, sectionname, loadexecutor, saveexecutor, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
     orxonox::XMLPortClassObjectContainer<classname, objectclass>* containername = (orxonox::XMLPortClassObjectContainer<classname, objectclass>*)(this->getIdentifier()->getXMLPortObjectContainer(sectionname)); \
+    orxonox::XMLPortClassObjectContainer<classname, objectclass>* containername = (orxonox::XMLPortClassObjectContainer<classname, objectclass>*)(ClassIdentifier<classname>::getIdentifier()->getXMLPortObjectContainer(sectionname)); \
     if (!containername) \
     { \
         containername = new orxonox::XMLPortClassObjectContainer<classname, objectclass>(std::string(sectionname), loadexecutor, saveexecutor, bApplyLoaderMask, bLoadBefore); \
         this->getIdentifier()->addXMLPortObjectContainer(sectionname, containername); \
+        containername = new orxonox::XMLPortClassObjectContainer<classname, objectclass>(std::string(sectionname), ClassIdentifier<classname>::getIdentifier(), loadexecutor, saveexecutor, bApplyLoaderMask, bLoadBefore); \
+        ClassIdentifier<classname>::getIdentifier()->addXMLPortObjectContainer(sectionname, containername); \
     } \
     containername->port(this, xmlelement, mode)
 …
             virtual const std::string& getDescription() = 0;
             virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiTypeMath& param) = 0;
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1) = 0;
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2) = 0;
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) = 0;
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) = 0;
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) = 0;
+            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) = 0;
         protected:
             std::string paramname_;
             ParseResult parseResult_;
+            Identifier* identifier_;
+            BaseObject* owner_;
     };
 …
         public:
             XMLPortClassParamContainer(const std::string paramname, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor)
+            XMLPortClassParamContainer(const std::string paramname, Identifier* identifier, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor)
+            {
                 this->paramname_ = paramname;
+                this->identifier_ = identifier;
                 this->loadexecutor_ = loadexecutor;
                 this->saveexecutor_ = saveexecutor;
+            }
+            XMLPortParamContainer& port(T* object, Element& xmlelement, XMLPort::Mode mode)
+            {
+            XMLPortParamContainer& port(BaseObject* owner, T* object, Element& xmlelement, XMLPort::Mode mode)
+            {
+                this->owner_ = owner;
                 this->parseParams_.object = object;
                 this->parseParams_.xmlelement = &xmlelement;
 …
                         if ((attribute.size() > 0) || (this->loadexecutor_->allDefaultValuesSet()))
+                        {
                             COUT(5) << ((BaseObject*)object)->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << object->getIdentifier()->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")." << std::endl << ((BaseObject*)object)->getLoaderIndentation();
+                            COUT(5) << this->owner_->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << this->identifier_->getName() << " (objectname " << this->owner_->getName() << ")." << std::endl << this->owner_->getLoaderIndentation();
                             if (this->loadexecutor_->parse(object, attribute, ","))
                                 this->parseResult_ = PR_finished;
 …
+                    {
                         COUT(1) << std::endl;
                         COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << object->getIdentifier()->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << ((BaseObject*)object)->getLevelfile() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getLevelfile() << ":" << std::endl;
                         COUT(1) << ex.what() << std::endl;
+                    }
 …
+            }
             XMLPortParamContainer& port(const ParseParams& parseParams)
+            {
                 return this->port(parseParams.object, *parseParams.xmlelement, parseParams.mode);
+            XMLPortParamContainer& port(BaseObject* owner, const ParseParams& parseParams)
+            {
+                return this->port(owner, parseParams.object, *parseParams.xmlelement, parseParams.mode);
+            }
 …
+            {
                 if (result == PR_waiting_for_default_values)
                     return this->port(params);
+                    return this->port(this->owner_, params);
                 else
                     return (*this);
 …
                 { return this->loadexecutor_->getDescription(); }
             virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiTypeMath& param)
+            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param)
+            {
                 if (!this->loadexecutor_->defaultValueSet(index))
 …
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
+            }
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1)
+            {
                 if (!this->loadexecutor_->defaultValueSet(0))
 …
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
+            }
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2)
+            {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)))
 …
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
+            }
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
+            {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)))
 …
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
+            }
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
+            {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)))
 …
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
+            }
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
+            {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)) || (!this->loadexecutor_->defaultValueSet(4)))
 …
             bool bApplyLoaderMask_;
             bool bLoadBefore_;
+            Identifier* identifier_;
     };
 …
+    {
         public:
             XMLPortClassObjectContainer(const std::string sectionname, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor, bool bApplyLoaderMask, bool bLoadBefore)
+            XMLPortClassObjectContainer(const std::string sectionname, Identifier* identifier, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor, bool bApplyLoaderMask, bool bLoadBefore)
+            {
                 this->sectionname_ = sectionname;
+                this->identifier_ = identifier;
                 this->loadexecutor_ = loadexecutor;
                 this->saveexecutor_ = saveexecutor;
 …
+                                            {
                                                 newObject->XMLPort(*child, XMLPort::LoadObject);
                                                 COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << object->getIdentifier()->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                            }
                                             else
+                                            {
                                                 COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << object->getIdentifier()->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                            }
 …
+                    {
                         COUT(1) << std::endl;
                         COUT(1) << "An error occurred in XMLPort.h while loading a '" << Class(O)->getName() << "' in '" << this->sectionname_ << "' of '" << object->getIdentifier()->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading a '" << Class(O)->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
                         COUT(1) << ex.what() << std::endl;
+                    }

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

r1535	r1747
36	36	#include "util/SubString.h"
37	37	#include "util/String.h"
38		#include "~~core~~/Debug.h"
	38	#include "util/Debug.h"
39	39	#include "core/ConsoleCommand.h"
40	40	#include "core/CommandEvaluation.h"

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

-                      r1735
+                      r1747
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
-#include "core/Debug.h"
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
 #include "core/Shell.h"               // hack!
+#include "util/Debug.h"
 #include "InputBuffer.h"
 …
     if (joySticksSize_)
+    {
       std::vector<MultiTypeMath> coeffPos;
       std::vector<MultiTypeMath> coeffNeg;
       std::vector<MultiTypeMath> zero;
+      std::vector<double> coeffPos;
+      std::vector<double> coeffNeg;
+      std::vector<int> zero;
       coeffPos.resize(24);
       coeffNeg.resize(24);
 …
           getIdentifier()->addConfigValueContainer("CoeffPos", cont);
+      }
       cont->getValue(&coeffPos);
+      cont->getValue(&coeffPos, this);
       cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
 …
           getIdentifier()->addConfigValueContainer("CoeffNeg", cont);
+      }
       cont->getValue(&coeffNeg);
+      cont->getValue(&coeffNeg, this);
       cont = getIdentifier()->getConfigValueContainer("Zero");
 …
           getIdentifier()->addConfigValueContainer("Zero", cont);
+      }
       cont->getValue(&zero);
+      cont->getValue(&zero, this);
       // copy values to our own variables

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

-                      r1567
+                      r1747
 #include <string>
 #include "util/Convert.h"
 #include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/ConfigValueIncludes.h"
 #include "core/CoreIncludes.h"
 …
     if (!infile)
+    {
       ConfigFileManager::getSingleton()->setFile(CFT_Keybindings, "def_keybindings.ini");
       ConfigFileManager::getSingleton()->save(CFT_Keybindings, "keybindings.ini");
+      ConfigFileManager::getInstance()->setFile(CFT_Keybindings, "def_keybindings.ini");
+      ConfigFileManager::getInstance()->save(CFT_Keybindings, "keybindings.ini");
+    }
     else
       infile.close();
     ConfigFileManager::getSingleton()->setFile(CFT_Keybindings, "keybindings.ini");
+    ConfigFileManager::getInstance()->setFile(CFT_Keybindings, "keybindings.ini");
     // parse key bindings
 …
   void KeyBinder::setConfigValues()
+  {
     SetConfigValueGeneric(KeyBinder, analogThreshold_, 0.05f)  .description("Threshold for analog axes until which the state is 0.");
     SetConfigValueGeneric(KeyBinder, mouseSensitivity_, 1.0f)  .description("Mouse sensitivity.");
     SetConfigValueGeneric(KeyBinder, bDeriveMouseInput_, false).description("Whether or not to derive moues movement for the absolute value.");
     SetConfigValueGeneric(KeyBinder, derivePeriod_, 0.05f).description("Accuracy of the mouse input deriver. The higher the more precise, but laggier.");
     SetConfigValueGeneric(KeyBinder, mouseSensitivityDerived_, 1.0f).description("Mouse sensitivity if mouse input is derived.");
     SetConfigValueGeneric(KeyBinder, bClipMouse_, true).description("Whether or not to clip absolute value of mouse in non derive mode.");
+    SetConfigValue(analogThreshold_, 0.05f)  .description("Threshold for analog axes until which the state is 0.");
+    SetConfigValue(mouseSensitivity_, 1.0f)  .description("Mouse sensitivity.");
+    SetConfigValue(bDeriveMouseInput_, false).description("Whether or not to derive moues movement for the absolute value.");
+    SetConfigValue(derivePeriod_, 0.05f).description("Accuracy of the mouse input deriver. The higher the more precise, but laggier.");
+    SetConfigValue(mouseSensitivityDerived_, 1.0f).description("Mouse sensitivity if mouse input is derived.");
+    SetConfigValue(bClipMouse_, true).description("Whether or not to clip absolute value of mouse in non derive mode.");
     float oldThresh = buttonThreshold_;
     SetConfigValueGeneric(KeyBinder, buttonThreshold_, 0.80f).description("Threshold for analog axes until which the button is not pressed.");
+    SetConfigValue(buttonThreshold_, 0.80f).description("Threshold for analog axes until which the button is not pressed.");
     if (oldThresh != buttonThreshold_)
       for (unsigned int i = 0; i < nHalfAxes_s; i++)
 …
     if (!cont)
+    {
       cont = new ConfigValueContainer(CFT_Keybindings, ClassIdentifier<KeyBinder>::getIdentifier(), button.name_, "");
+      cont = new ConfigValueContainer(CFT_Keybindings, ClassIdentifier<KeyBinder>::getIdentifier(), button.name_, "", button.name_);
       ClassIdentifier<KeyBinder>::getIdentifier()->addConfigValueContainer(button.name_, cont);
+    }
     std::string old = button.bindingString_;
     cont->getValue(&button.bindingString_);
+    cont->getValue(&button.bindingString_, this);
     // keybinder stuff

code/trunk/src/core/input/KeyDetector.cc

r1535	r1747
33	33
34	34	#include "KeyDetector.h"
35		#include "~~core~~/Debug.h"
	35	#include "util/Debug.h"
36	36	#include "core/CoreIncludes.h"
37	37	#include "core/CommandExecutor.h"

code/trunk/src/network/ClientConnection.cc

-                      r1534
+                      r1747
 #include "util/Sleep.h"
 #include "core/Debug.h"
+#include "util/Debug.h"
 namespace network
 …
     return getPacket(address);
   }*/
   ENetEvent *ClientConnection::getEvent(){
     if(!buffer.isEmpty())

code/trunk/src/network/ConnectionManager.cc

-                      r1735
+                      r1747
 #include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
+#include "core/Iterator.h"
 #include "objects/SpaceShip.h"
 #include "util/Math.h"
 …
+{
   //boost::thread_group network_threads;
   ConnectionManager *ConnectionManager::instance_=0;
   ConnectionManager::ConnectionManager():receiverThread_(0){
     assert(instance_==0);
 …
+  }
   boost::recursive_mutex ConnectionManager::enet_mutex;
 //   ConnectionManager::ConnectionManager(ClientInformation *head) : receiverThread_(0) {
 //     assert(instance_==0);
 …
 //     bindAddress.port = NETWORK_PORT;
 //   }
   ConnectionManager::ConnectionManager(int port){
     assert(instance_==0);
 …
     bindAddress.port = NETWORK_PORT;
+  }
   ConnectionManager::~ConnectionManager(){
     instance_=0;
 …
     return packet;
   }*/
   ENetEvent *ConnectionManager::getEvent(){
     if(!buffer.isEmpty())
 …
     return true;
+  }
 //   bool ConnectionManager::addPacket(Packet::Packet *packet){
 //     ClientInformation *temp = instance_->head_->findClient(packet->getClientID());
 …
 //     //  TODO: finish implementation
 //   }
 //
+//
   bool ConnectionManager::addPacket(ENetPacket *packet, ENetPeer *peer) {
     boost::recursive_mutex::scoped_lock lock(instance_->enet_mutex);
 …
+    }
+  }
   //### added some bugfixes here, but we cannot test them because
   //### the server crashes everytime because of some gamestates
 …
   /**
+   *
    * @param clientID
+   *
+   * @param clientID
    */
   void ConnectionManager::syncClassid(unsigned int clientID) {
 …
+  }
   bool ConnectionManager::removeShip(ClientInformation *client){
     unsigned int id=client->getShipID();
     orxonox::Iterator<orxonox::SpaceShip> it;
     for(it = orxonox::ObjectList<orxonox::SpaceShip>::start(); it; ++it){
+    orxonox::ObjectList<orxonox::SpaceShip>::iterator it;
+    for(it = orxonox::ObjectList<orxonox::SpaceShip>::begin(); it; ++it){
       if(it->objectID!=id)
         continue;
 …
     return true;
+  }
   void ConnectionManager::disconnectClient(ClientInformation *client){
+    {
 …
     removeShip(client);
+  }
+}

code/trunk/src/network/GamestateClient.cc

-                      r1735
+                      r1747
 #include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
+#include "core/Iterator.h"
 #include "Synchronisable.h"
 …
     return true;
+  }
   int GamestateClient::processGamestates(){
     if(tempGamestate_==NULL)
 …
   * @return iterator pointing to the next object in the list
   */
   void GamestateClient::removeObject(orxonox::Iterator<Synchronisable> &it) {
     orxonox::Iterator<Synchronisable> temp=it;
+  void GamestateClient::removeObject(orxonox::ObjectList<Synchronisable>::iterator &it) {
+    orxonox::ObjectList<Synchronisable>::iterator temp=it;
     ++it;
     delete  *temp;

code/trunk/src/network/GamestateClient.h

-                      r1735
+                      r1747
 #include <map>
 //
+//
 #include "NetworkPrereqs.h"
 #include "core/CorePrereqs.h"
 …
     GamestateClient();
     ~GamestateClient();
     bool add(packet::Gamestate *gs, int clientID);
     bool ack(int gamestateID, int clientID);
     int processGamestates();
     packet::Gamestate *getGamestate();
 …
   private:
     bool processGamestate(packet::Gamestate *gs);
     void removeObject(orxonox::Iterator<Synchronisable> &it);
+    void removeObject(orxonox::ObjectListIterator<Synchronisable> &it);
     void printGamestateMap();
     bool saveShipCache();
 …
     orxonox::SpaceShip *myShip_;
     unsigned char *shipCache_;
   };

code/trunk/src/network/Server.cc

-                      r1735
+                      r1747
 #include "objects/SpaceShip.h"
 #include "core/ConsoleCommand.h"
+#include "core/Iterator.h"
 #include "packet/Chat.h"
 #include "packet/Packet.h"
 …
   #define MAX_FAILURES 20;
   #define NETWORK_FREQUENCY 30
   /**
   * Constructor for default values (bindaddress is set to ENET_HOST_ANY
 …
     gamestates_ = new GamestateManager();
+  }
   Server::Server(int port){
     timeSinceLastUpdate_=0;
 …
     return message->process();
+  }
   /**
   * This function sends out a message to all clients
 …
     return;
+  }
   bool Server::queuePacket(ENetPacket *packet, int clientID){
     return connection->addPacket(packet, clientID);
 …
     return p->process();
+  }
   /**
   * sends the gamestate
 …
       assert(gs->compressData());
       if ( !gs->send() ){
         COUT(3) << "Server: packet with client id (cid): " << cid << " not sended: " << temp->getFailures() << std::endl;
+        COUT(3) << "Server: packet with client id (cid): " << cid << " not sended: " << temp->getFailures() << std::endl;
         temp->addFailure();
       }else
 …
     return true;
+  }
 //   void Server::processChat( chat *data, int clientId){
 //     char *message = new char [strlen(data->message)+10+1];
 …
 //     delete data;
 //   }
   bool Server::addClient(ENetEvent *event){
     ClientInformation *temp = ClientInformation::insertBack(new ClientInformation);
 …
     return createClient(temp->getID());
+  }
   bool Server::createClient(int clientID){
     ClientInformation *temp = ClientInformation::findClient(clientID);
 …
     return true;
+  }
   bool Server::createShip(ClientInformation *client){
     if(!client)
 …
     no->create();
     no->setBacksync(true);
     return true;
+  }
   bool Server::disconnectClient(ENetEvent *event){
     COUT(4) << "removing client from list" << std::endl;
     //return removeClient(head_->findClient(&(peer->address))->getID());
     //boost::recursive_mutex::scoped_lock lock(head_->mutex_);
     orxonox::Iterator<orxonox::SpaceShip> it = orxonox::ObjectList<orxonox::SpaceShip>::start();
+    orxonox::ObjectList<orxonox::SpaceShip>::iterator it = orxonox::ObjectList<orxonox::SpaceShip>::begin();
     ClientInformation *client = ClientInformation::findClient(&event->peer->address);
     if(!client)
 …
         continue;
+      }
       orxonox::Iterator<orxonox::SpaceShip> temp=it;
+      orxonox::ObjectList<orxonox::SpaceShip>::iterator temp=it;
       ++it;
       delete  *temp;
 …
     gamestates_->removeClient(client);
+  }
+}

code/trunk/src/network/Synchronisable.h

r1735	r1747
92	92	Synchronisable();
93	93	private:
94		/* bool removeObject(~~Iterator<Synchronisable>~~ it);*/
	94	/* bool removeObject(ObjectList<Synchronisable>::iterator it);*/
95	95
96	96	std::list<synchronisableVariable > syncList;

code/trunk/src/network/packet/Gamestate.cc

-                      r1740
+                      r1747
 #include "network/ClientInformation.h"
 #include "network/GamestateHandler.h"
+#include "core/Iterator.h"
 #include <zlib.h>
 …
   unsigned char *mem=data_;
   mem+=sizeof(GamestateHeader);
   orxonox::Iterator<Synchronisable> it;
   for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it){
+  orxonox::ObjectList<Synchronisable>::iterator it;
+  for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
     tempsize=it->getSize2(mode);
 …
       // start allocate additional memory
       COUT(3) << "G.St.Man: need additional memory" << std::endl;
       orxonox::Iterator<Synchronisable> temp = it;
+      orxonox::ObjectList<Synchronisable>::iterator temp = it;
       int addsize=tempsize;
       while(++temp)
 …
   unsigned char *mem=data_+sizeof(GamestateHeader);
     // get the start of the Synchronisable list
   orxonox::Iterator<Synchronisable> it=orxonox::ObjectList<Synchronisable>::start();
+  orxonox::ObjectList<Synchronisable>::iterator it=orxonox::ObjectList<Synchronisable>::begin();
   while(mem < data_+sizeof(GamestateHeader)+HEADER->normsize){
 …
   int size=0;
     // get the start of the Synchronisable list
   orxonox::Iterator<Synchronisable> it;
+  orxonox::ObjectList<Synchronisable>::iterator it;
     // get total size of gamestate
   for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it)
+  for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it)
     size+=it->getSize2(mode); // size of the actual data of the synchronisable
 //  size+=sizeof(GamestateHeader);
 …
  * @return iterator pointing to the next object in the list
  */
   void Gamestate::removeObject(orxonox::Iterator<Synchronisable> &it) {
     orxonox::Iterator<Synchronisable> temp=it;
+  void Gamestate::removeObject(orxonox::ObjectList<Synchronisable>::iterator &it) {
+    orxonox::ObjectList<Synchronisable>::iterator temp=it;
     ++it;
     delete  *temp;

code/trunk/src/network/packet/Gamestate.h

-                      r1735
+                      r1747
 namespace packet {
 struct GamestateHeader{
   ENUM::Type packetType;
 …
 /**
         @author
+        @author
 */
 class Gamestate: public Packet{
 …
     Gamestate();
     Gamestate(unsigned char *data, int clientID);
     ~Gamestate();
     bool collectData(int id, int mode=0x0);
     bool spreadData(int mode=0x0);
 …
     bool compressData();
     bool decompressData();
     // Packet functions
     virtual unsigned int getSize() const;
     virtual bool process();
   private:
     unsigned int calcGamestateSize(int mode=0x0);
     void removeObject(orxonox::Iterator<Synchronisable> &it);
+    void removeObject(orxonox::ObjectListIterator<Synchronisable> &it);
     //Bytestream *bs_;
     //GamestateHeader *header_;

code/trunk/src/orxonox/CMakeLists.txt

r1625	r1747
7	7	RadarViewable.cc
8	8	Settings.cc
	9	SignalHandler.cc
9	10
10	11	overlays/OrxonoxOverlay.cc

code/trunk/src/orxonox/GraphicsEngine.cc

-                      r1625
+                      r1747
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 #include "core/Debug.h"
+#include "core/Iterator.h"
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
+#include "util/Debug.h"
 #include "overlays/console/InGameConsole.h"
 …
     SetConfigValue(ogreLogLevelCritical_, 2).description("Corresponding orxonox debug level for ogre Critical");
+    unsigned int old = this->detailLevelParticle_;
+    SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high");
+    if (this->detailLevelParticle_ != old)
+      for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+        it->detailLevelChanged(this->detailLevelParticle_);
+    SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high").callback(this, &GraphicsEngine::detailLevelParticleChanged);
+  }
+  void GraphicsEngine::detailLevelParticleChanged()
+  {
+    for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
+      it->detailLevelChanged(this->detailLevelParticle_);
+  }
 …
   void GraphicsEngine::windowMoved(Ogre::RenderWindow *rw)
+  {
     for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+    for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
       it->windowMoved();
+  }
 …
   void GraphicsEngine::windowResized(Ogre::RenderWindow *rw)
+  {
     for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+    for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
       it->windowResized(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
+  }
 …
   void GraphicsEngine::windowFocusChanged(Ogre::RenderWindow *rw)
+  {
     for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+    for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
       it->windowFocusChanged();
+  }

code/trunk/src/orxonox/GraphicsEngine.h

r1625	r1747
56	56	public:
57	57	void setConfigValues();
	58	void detailLevelParticleChanged();
58	59	bool setup();
59	60	bool declareRessourceLocations();

code/trunk/src/orxonox/Main.cc

r1535	r1747
37	37
38	38	#include "util/OrxonoxPlatform.h"
39		#include "~~core/~~SignalHandler.h"
	39	#include "SignalHandler.h"
40	40	#include "Orxonox.h"
41	41

code/trunk/src/orxonox/Orxonox.cc

-                      r1735
+                      r1747
 // core
 #include "core/ConfigFileManager.h"
+#include "core/Iterator.h"
 #include "core/ConsoleCommand.h"
-#include "core/Debug.h"
 #include "core/Loader.h"
 #include "core/input/InputManager.h"
 #include "core/TclBind.h"
 #include "core/Core.h"
+#include "util/Debug.h"
 // audio
 …
 namespace orxonox
+{
   SetConsoleCommandShortcut(Orxonox, exit).setKeybindMode(KeybindMode::OnPress);
   SetConsoleCommandShortcut(Orxonox, slomo).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0).setAxisParamIndex(0).setIsAxisRelative(false);
   SetConsoleCommandShortcut(Orxonox, setTimeFactor).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0);
+  SetConsoleCommandShortcut(Orxonox, exit).keybindMode(KeybindMode::OnPress);
+  SetConsoleCommandShortcut(Orxonox, slomo).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0).axisParamIndex(0).isAxisRelative(false);
+  SetConsoleCommandShortcut(Orxonox, setTimeFactor).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);
   /**
 …
     float change = factor / Orxonox::getSingleton()->getTimeFactor();
     Orxonox::getSingleton()->timefactor_ = factor;
     for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+    for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
         it->setSpeedFactor(it->getSpeedFactor() * change);
 …
+  {
 #ifdef _DEBUG
     ConfigFileManager::getSingleton()->setFile(CFT_Settings, "orxonox_d.ini");
+    ConfigFileManager::getInstance()->setFile(CFT_Settings, "orxonox_d.ini");
 #else
     ConfigFileManager::getSingleton()->setFile(CFT_Settings, "orxonox.ini");
+    ConfigFileManager::getInstance()->setFile(CFT_Settings, "orxonox.ini");
 #endif
     Factory::createClassHierarchy();
 …
     unsigned long frameCount = 0;
     // TODO: this would very well fit into a configValue
     const unsigned long refreshTime = 200000;
 …
       // Call those objects that need the real time
       for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
+      for (ObjectList<TickableReal>::iterator it = ObjectList<TickableReal>::begin(); it; ++it)
         it->tick(dt);
       // Call the scene objects
       for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+      for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
         it->tick(dt * this->timefactor_);

code/trunk/src/orxonox/OrxonoxStableHeaders.h

-                      r1631
+                      r1747
 #include "util/Convert.h"
+#include "util/Debug.h"
 #include "util/Math.h"
 #include "util/Multitype.h"
+#include "util/MultiTypeMath.h"
+#include "util/OutputBuffer.h"
+#include "util/OutputHandler.h"
 #include "util/Sleep.h"
 #include "util/String.h"
 …
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
-#include "core/Debug.h"
-#include "core/OutputBuffer.h"
-#include "core/OutputHandler.h"
 #include "core/Executor.h"
 #include "core/XMLPort.h"

code/trunk/src/orxonox/Radar.cc

-                      r1625
+                      r1747
 #include "core/CoreIncludes.h"
 #include "core/ConsoleCommand.h"
+#include "core/Iterator.h"
 #include "RadarListener.h"
 namespace orxonox
+{
     SetConsoleCommand(Radar, cycleNavigationFocus, true).setAccessLevel(AccessLevel::User);
     SetConsoleCommand(Radar, releaseNavigationFocus, true).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(Radar, cycleNavigationFocus, true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(Radar, releaseNavigationFocus, true).accessLevel(AccessLevel::User);
     Radar* Radar::instance_s = 0;
 …
+        }
         for (Iterator<RadarListener> itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        {
             (*itListener)->radarTick(dt);
             for (Iterator<RadarViewable> itElement = ObjectList<RadarViewable>::begin(); itElement; ++itElement)
+            for (ObjectList<RadarViewable>::iterator itElement = ObjectList<RadarViewable>::begin(); itElement; ++itElement)
+            {
                 if ((*itElement) != SpaceShip::getLocalShip() && (*itListener)->getRadarSensitivity() > (*itElement)->getRadarObjectCamouflage())
 …
     void Radar::cycleFocus()
+    {
         if (*(ObjectList<RadarViewable>::begin()) == 0)
+        if (ObjectList<RadarViewable>::begin() == 0)
+        {
             // list is empty
 …
             float nextDistance = FLT_MAX;
             float minimumDistance = FLT_MAX;
             Iterator<RadarViewable> itFallback = 0;
             for (Iterator<RadarViewable> it = ObjectList<RadarViewable>::begin(); it; ++it)
+            ObjectList<RadarViewable>::iterator itFallback = 0;
+            for (ObjectList<RadarViewable>::iterator it = ObjectList<RadarViewable>::begin(); it; ++it)
+            {
                 if (*it == SpaceShip::getLocalShip())
 …
         // iterate through all Radar Objects
         unsigned int i = 0;
         for (Iterator<RadarViewable> it = ObjectList<RadarViewable>::start(); it; ++it, ++i)
+        for (ObjectList<RadarViewable>::iterator it = ObjectList<RadarViewable>::begin(); it; ++it, ++i)
+        {
             COUT(3) << i++ << ": " << (*it)->getWorldPosition() << std::endl;

code/trunk/src/orxonox/Radar.h

-                      r1625
+                      r1747
         RadarBase() { }
     };
     class _OrxonoxExport Radar : public Tickable, private virtual RadarBase
+    {
 …
         Radar();
         ~Radar();
+        virtual void tick(float dt);
         const RadarViewable* getFocus();
 …
     private:
         Radar(Radar& instance);
-        void tick(float dt);
         void releaseFocus();
 …
         void cycleFocus();
         Iterator<RadarViewable> itFocus_;
+        ObjectListIterator<RadarViewable> itFocus_;
         RadarViewable* focus_;
         std::map<std::string, RadarViewable::Shape> objectTypes_;
         int objectTypeCounter_;
+        int objectTypeCounter_;
         static Radar* instance_s;

code/trunk/src/orxonox/RadarViewable.cc

r1625	r1747
29	29	#include "OrxonoxStableHeaders.h"
30	30	#include "RadarViewable.h"
31		#include "~~core~~/Debug.h"
	31	#include "util/Debug.h"
32	32	#include "core/CoreIncludes.h"
33	33	#include "objects/WorldEntity.h"

code/trunk/src/orxonox/RadarViewable.h

r1625	r1747
33	33	#include <string>
34	34	#include "util/Math.h"
35		#include "~~core~~/Debug.h"
	35	#include "util/Debug.h"
36	36	#include "core/OrxonoxClass.h"
37	37

code/trunk/src/orxonox/Settings.cc

-                      r1535
+                      r1747
   void Settings::setConfigValues()
+  {
+    SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.");
+    SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
+  }
+  /**
+    @brief Callback function if the datapath has changed.
+  */
+  void Settings::dataPathChanged()
+  {
     if (dataPath_ != "" && dataPath_[dataPath_.size() - 1] != '/')
+    {

code/trunk/src/orxonox/Settings.h

r1535	r1747
48	48	public:
49	49	void setConfigValues();
	50	void dataPathChanged();
50	51
51	52	static const std::string& getDataPath();

code/trunk/src/orxonox/objects/Ambient.cc

-                      r1625
+                      r1747
 #include "util/Convert.h"
 #include "util/Math.h"
 #include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/CoreIncludes.h"
-#include "GraphicsEngine.h"
 #include "core/XMLPort.h"
 #include "core/ConsoleCommand.h"
+#include "GraphicsEngine.h"
 namespace orxonox
+{
     SetConsoleCommand(Ambient, setAmbientLightTest, false).setDefaultValues(ColourValue(1, 1, 1, 1)).setAccessLevel(AccessLevel::Offline);
+    SetConsoleCommandAlias(Ambient, setAmbientLightTest, "setAmbientLight", false).defaultValues(ColourValue(1, 1, 1, 1)).accessLevel(AccessLevel::Offline);
     CreateFactory(Ambient);
 …
+    }
+    bool Ambient::create(){
+      GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
+      return Synchronisable::create();
+    bool Ambient::create()
+    {
+        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
+        return Synchronisable::create();
+    }
     void Ambient::registerAllVariables(){
       registerVar(&ambientLight_, sizeof(ColourValue), network::DATA);
+    void Ambient::registerAllVariables()
+    {
+        registerVar(&ambientLight_, sizeof(ColourValue), network::DATA);
+    }
     void Ambient::setAmbientLight(const ColourValue& colour)
+    {
             GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(colour);
       ambientLight_=colour;
+        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(colour);
+        ambientLight_=colour;
+    }
 …
     void Ambient::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
         BaseObject::XMLPort(xmlelement, mode);
+        SUPER(Ambient, XMLPort, xmlelement, mode);
         XMLPortParamLoadOnly(Ambient, "colourvalue", setAmbientLight, xmlelement, mode);
+        XMLPortParam(Ambient, "colourvalue", setAmbientLight, getAmbienetLight, xmlelement, mode);
         create();
+    }

code/trunk/src/orxonox/objects/Ambient.h

-                      r1735
+                      r1747
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void setAmbientLight(const ColourValue& colour);
             virtual bool create();
             void registerAllVariables();
+            void setAmbientLight(const ColourValue& colour);
+            inline const ColourValue& getAmbienetLight() const
+                { return this->ambientLight_; }
             static void setAmbientLightTest(const ColourValue& colour)

code/trunk/src/orxonox/objects/Backlight.cc

-                      r1608
+                      r1747
     void Backlight::tick(float dt)
+    {
         WorldEntity::tick(dt);
+        SUPER(Backlight, tick, dt);
         if (this->isActive())
 …
     void Backlight::changedVisibility()
+    {
         WorldEntity::changedVisibility();
+        SUPER(Backlight, changedVisibility);
         this->billboard_.setVisible(this->isVisible());

code/trunk/src/orxonox/objects/BillboardProjectile.cc

r1559	r1747
63	63	void BillboardProjectile::changedVisibility()
64	64	{
65		~~Projectile::changedVisibility(~~);
	65	SUPER(BillboardProjectile, changedVisibility);
66	66	this->billboard_.setVisible(this->isVisible());
67	67	}

code/trunk/src/orxonox/objects/Camera.cc

r1505	r1747
42	42	#include "util/Convert.h"
43	43	#include "util/Math.h"
44		#include "~~core~~/Debug.h"
	44	#include "util/Debug.h"
45	45	#include "core/CoreIncludes.h"
46	46	#include "GraphicsEngine.h"

code/trunk/src/orxonox/objects/Model.cc

-                      r1627
+                      r1747
     void Model::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
         WorldEntity::XMLPort(xmlelement, mode);
+        SUPER(Model, XMLPort, xmlelement, mode);
         XMLPortParamLoadOnly(Model, "mesh", setMesh, xmlelement, mode);
+        XMLPortParam(Model, "mesh", setMesh, getMesh, xmlelement, mode);
         Model::create();
+    }
-    void Model::setMesh(const std::string& meshname)
+    {
-        this->meshSrc_ = meshname;
+    }
 …
     void Model::changedVisibility()
+    {
         WorldEntity::changedVisibility();
+        SUPER(Model, changedVisibility);
         if (this->isInitialized())
             this->mesh_.setVisible(this->isVisible());

code/trunk/src/orxonox/objects/Model.h

-                      r1558
+                      r1747
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void changedVisibility();
+            void setMesh(const std::string& meshname);
+            inline void setMesh(const std::string& meshname)
+                { this->meshSrc_ = meshname; }
+            inline const std::string& getMesh() const
+                { return this->meshSrc_; }
             virtual bool create();

code/trunk/src/orxonox/objects/NPC.cc

-                      r1625
+                      r1747
 #include "core/CoreIncludes.h"
+#include "core/Iterator.h"
 namespace orxonox {
 …
     movable_ = movable;
+  }
   void NPC::registerAllVariables(){
     Model::registerAllVariables();
     registerVar(&movable_, sizeof(movable_), network::DATA);
+  }
   /**
 …
     int numberOfNeighbour = 0;  //number of observed neighbours
     float distance = 0;  // distance to the actual element
     for(Iterator<WorldEntity> it = ObjectList<WorldEntity>::start(); it; ++it) {  //go through all elements
+    for(ObjectList<WorldEntity>::iterator it = ObjectList<WorldEntity>::begin(); it; ++it) {  //go through all elements
       distance = getDistance(*it);  //get distance between this and actual
       if ((distance > 0) && (distance < SEPERATIONDISTANCE)) {  //do only if actual is inside detectionradius
 …
     //float distance = 0;
     //go through all elements
     for(Iterator<NPC> it = ObjectList<NPC>::start(); it; ++it) {  //just working with 3 elements at the moment
+    for(ObjectList<NPC>::iterator it = ObjectList<NPC>::begin(); it; ++it) {  //just working with 3 elements at the moment
       float distance = getDistance(*it);  //get distance between this and actual
       if ((distance > 0) && (distance < ALIGNMENTDISTANCE)) {  //check if actual element is inside detectionradius
 …
     //float distance = 0;
     //go through all elements
     for(Iterator<NPC> it = ObjectList<NPC>::start(); it; ++it) {  //just working with 3 elements at the moment
+    for(ObjectList<NPC>::iterator it = ObjectList<NPC>::begin(); it; ++it) {  //just working with 3 elements at the moment
       float distance = getDistance(*it);  //get distance between this and actual
       if ((distance > 0) && (distance < COHESIONDISTANCE)) {  //check if actual element is inside detectionradius

code/trunk/src/orxonox/objects/NPC.h

r1625	r1747
48	48	NPC();
49	49	virtual ~NPC();
50		void tick(float dt);
	50	virtual void tick(float dt);
51	51	void update();
52	52	void setValues(Vector3 location, Vector3 speed, Vector3 acceleration, bool movable);

code/trunk/src/orxonox/objects/ParticleProjectile.cc

r1563	r1747
32	32	#include "SpaceShip.h"
33	33	#include "core/CoreIncludes.h"
	34	#include "core/ConfigValueIncludes.h"
34	35
35	36	namespace orxonox
…	…
52	53	this->particles_ = 0;
53	54	}
	55
	56	this->setConfigValues();
54	57	}
55	58
…	…
60	63	}
61	64
	65	void ParticleProjectile::setConfigValues()
	66	{
	67	SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback((Projectile*)this, &ParticleProjectile::speedChanged);
	68	}
	69
62	70	void ParticleProjectile::changedVisibility()
63	71	{
64		~~BillboardProjectile::changedVisibility(~~);
	72	SUPER(ParticleProjectile, changedVisibility);
65	73	this->particles_->setEnabled(this->isVisible());
66	74	}

code/trunk/src/orxonox/objects/ParticleProjectile.h

r1558	r1747
44	44	virtual ~ParticleProjectile();
45	45	virtual void changedVisibility();
	46	void setConfigValues();
46	47
47	48	private:

code/trunk/src/orxonox/objects/Projectile.cc

-                      r1602
+                      r1747
 #include "core/Executor.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Iterator.h"
 #include "tools/ParticleInterface.h"
 …
 namespace orxonox
+{
     float Projectile::speed_ = 5000;
+    float Projectile::speed_s = 5000;
     Projectile::Projectile(SpaceShip* owner) : owner_(owner)
 …
         SetConfigValue(damage_, 15.0).description("The damage caused by the projectile");
         SetConfigValue(lifetime_, 4.0).description("The time in seconds a projectile stays alive");
+        SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second");
+        SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback(this, &Projectile::speedChanged);
+    }
+        if(this->owner_)
+          this->setVelocity(this->owner_->getInitialDir() * this->speed_);
+    void Projectile::speedChanged()
+    {
+        Projectile::speed_s = this->speed_;
+        if (this->owner_)
+            this->setVelocity(this->owner_->getInitialDir() * this->speed_);
+    }
     void Projectile::tick(float dt)
+    {
         WorldEntity::tick(dt);
+        SUPER(Projectile, tick, dt);
         if (!this->isActive())
 …
         float radius;
         for (Iterator<Model> it = ObjectList<Model>::start(); it; ++it)
+        for (ObjectList<Model>::iterator it = ObjectList<Model>::begin(); it; ++it)
+        {
             if ((*it) != this->owner_)
+            {
                 radius = it->getScale().x * 3.0;
+                radius = it->getScale3D().x * 3.0;
                 if (this->getPosition().squaredDistance(it->getPosition()) <= (radius*radius))

code/trunk/src/orxonox/objects/Projectile.h

-                      r1552
+                      r1747
             virtual ~Projectile();
             void setConfigValues();
+            void speedChanged();
             void destroyObject();
             virtual void tick(float dt);
             static float getSpeed()
                 { return Projectile::speed_; }
+                { return Projectile::speed_s; }
         protected:
 …
             std::string explosionTemplateName_;
             std::string smokeTemplateName_;
+            static float speed_;
+        protected:
+            static float speed_s;
+            float speed_;
+        private:
             float lifetime_;
             float damage_;

code/trunk/src/orxonox/objects/RotatingProjectile.cc

-                      r1558
+                      r1747
     void RotatingProjectile::setConfigValues()
+    {
+        SetConfigValue(colour_, ColourValue(1.0, 0.0, 0.0));
+        SetConfigValue(colour_, ColourValue(1.0, 0.0, 0.0)).callback(this, &RotatingProjectile::colourChanged);
+    }
+        this->rotatingBillboard1_.getBillboardSet()->getBillboard(0)->setColour(this->colour_);
+        this->rotatingBillboard2_.getBillboardSet()->getBillboard(0)->setColour(this->colour_);
+    void RotatingProjectile::colourChanged()
+    {
+        if (this->isInitialized())
+        {
+            this->rotatingBillboard1_.getBillboardSet()->getBillboard(0)->setColour(this->colour_);
+            this->rotatingBillboard2_.getBillboardSet()->getBillboard(0)->setColour(this->colour_);
+        }
+    }
 …
+        }
         Projectile::tick(dt);
+        SUPER(RotatingProjectile, tick, dt);
+    }
     void RotatingProjectile::changedVisibility()
+    {
         BillboardProjectile::changedVisibility();
+        SUPER(RotatingProjectile, changedVisibility);
         this->rotatingBillboard1_.setVisible(this->isVisible());
         this->rotatingBillboard2_.setVisible(this->isVisible());

code/trunk/src/orxonox/objects/RotatingProjectile.h

r1558	r1747
14	14	virtual ~RotatingProjectile();
15	15	void setConfigValues();
	16	void colourChanged();
16	17	virtual void tick(float dt);
17	18	virtual void changedVisibility();

code/trunk/src/orxonox/objects/Skybox.cc

-                      r1558
+                      r1747
 #include "GraphicsEngine.h"
 #include "core/CoreIncludes.h"
-#include "core/Debug.h"
 #include "core/XMLPort.h"
+#include "util/Debug.h"
 namespace orxonox
 …
+    }
-    void Skybox::setSkyboxSrc(const std::string& src)
+    {
-        this->skyboxSrc_ = src;
+    }
     /**
         @brief XML loading and saving.
 …
     void Skybox::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
         BaseObject::XMLPort(xmlelement, mode);
+        SUPER(Skybox, XMLPort, xmlelement, mode);
         XMLPortParamLoadOnly(Skybox, "src", setSkyboxSrc, xmlelement, mode);
+        XMLPortParam(Skybox, "src", setSkyboxSrc, getSkyboxSrc, xmlelement, mode);
         create();
+    }
 …
     void Skybox::changedVisibility()
+    {
         BaseObject::changedVisibility();
+        SUPER(Skybox, changedVisibility);
         GraphicsEngine::getSingleton().getSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
+    }

code/trunk/src/orxonox/objects/Skybox.h

-                      r1558
+                      r1747
             virtual bool create();
             void registerAllVariables();
+            void setSkyboxSrc(const std::string &src);
+            inline void setSkyboxSrc(const std::string &src)
+                { this->skyboxSrc_ = src; }
+            inline const std::string& getSkyboxSrc() const
+                { return this->skyboxSrc_; }
         private:

code/trunk/src/orxonox/objects/SpaceShip.cc

-                      r1735
+                      r1747
 #include "util/Convert.h"
 #include "util/Math.h"
+#include "util/Debug.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Debug.h"
+#include "core/Iterator.h"
+#include "core/input/InputManager.h"
 #include "core/XMLPort.h"
 #include "core/ConsoleCommand.h"
-#include "network/Host.h"
 #include "tools/ParticleInterface.h"
+#include "GraphicsEngine.h"
+#include "network/Client.h"
+#include "Backlight.h"
+#include "CameraHandler.h"
+#include "ParticleSpawner.h"
 #include "RotatingProjectile.h"
 #include "ParticleProjectile.h"
+#include "ParticleSpawner.h"
+#include "Backlight.h"
+#include "CameraHandler.h"
+#include "GraphicsEngine.h"
 namespace orxonox
+{
     SetConsoleCommand(SpaceShip, setMaxSpeedTest, false).setAccessLevel(AccessLevel::Debug);
     SetConsoleCommand(SpaceShip, whereAmI, true).setAccessLevel(AccessLevel::User);
     SetConsoleCommand(SpaceShip, moveLongitudinal, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
     SetConsoleCommand(SpaceShip, moveLateral, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
     SetConsoleCommand(SpaceShip, moveYaw, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
     SetConsoleCommand(SpaceShip, movePitch, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
     SetConsoleCommand(SpaceShip, moveRoll, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
     SetConsoleCommand(SpaceShip, fire, true).setAccessLevel(AccessLevel::User).setKeybindMode(KeybindMode::OnHold);
     SetConsoleCommandGeneric(test1, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxSpeed"), false).setAccessLevel(AccessLevel::Debug);
     SetConsoleCommandGeneric(test2, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxBlubber"), false).setAccessLevel(AccessLevel::Debug);
     SetConsoleCommandGeneric(test3, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setRofl"), false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommand(SpaceShip, setMaxSpeedTest, false).accessLevel(AccessLevel::Debug);
+    SetConsoleCommand(SpaceShip, whereAmI, true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(SpaceShip, moveLongitudinal, true).accessLevel(AccessLevel::User).defaultValue(0, 1.0f).axisParamIndex(0).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, moveLateral, true).accessLevel(AccessLevel::User).defaultValue(0, 1.0f).axisParamIndex(0).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, moveYaw, true).accessLevel(AccessLevel::User).defaultValue(0, 1.0f).axisParamIndex(0).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, movePitch, true).accessLevel(AccessLevel::User).defaultValue(0, 1.0f).axisParamIndex(0).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, moveRoll, true).accessLevel(AccessLevel::User).defaultValue(0, 1.0f).axisParamIndex(0).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, fire, true).accessLevel(AccessLevel::User).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommandAliasMulti(SpaceShip, setMaxSpeedTest, "setMaxSpeed", 1, false).accessLevel(AccessLevel::Debug);
+    SetConsoleCommandAliasMulti(SpaceShip, setMaxSpeedTest, "setMaxBlubber", 2, false).accessLevel(AccessLevel::Debug);
+    SetConsoleCommandAliasMulti(SpaceShip, setMaxSpeedTest, "setRofl", 3, false).accessLevel(AccessLevel::Debug);
     CreateFactory(SpaceShip);
 …
     SpaceShip *SpaceShip::getLocalShip(){
       Iterator<SpaceShip> it;
       for(it = ObjectList<SpaceShip>::start(); it; ++it){
+      ObjectList<SpaceShip>::iterator it;
+      for(it = ObjectList<SpaceShip>::begin(); it; ++it){
         if( (it)->myShip_ )
           return *it;
 …
     void SpaceShip::changedVisibility()
+    {
         Model::changedVisibility();
+        SUPER(SpaceShip, changedVisibility);
         this->tt1_->setEnabled(this->isVisible());
 …
     void SpaceShip::changedActivity()
+    {
         Model::changedActivity();
+        SUPER(SpaceShip, changedActivity);
         this->tt1_->setEnabled(this->isVisible());
 …
     void SpaceShip::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
         Model::XMLPort(xmlelement, mode);
         XMLPortParamLoadOnly(SpaceShip, "camera", setCamera, xmlelement, mode);
         XMLPortParamLoadOnly(SpaceShip, "maxSpeed", setMaxSpeed, xmlelement, mode);
         XMLPortParamLoadOnly(SpaceShip, "maxSideAndBackSpeed", setMaxSideAndBackSpeed, xmlelement, mode);
         XMLPortParamLoadOnly(SpaceShip, "maxRotation", setMaxRotation, xmlelement, mode);
         XMLPortParamLoadOnly(SpaceShip, "transAcc", setTransAcc, xmlelement, mode);
         XMLPortParamLoadOnly(SpaceShip, "rotAcc", setRotAcc, xmlelement, mode);
         XMLPortParamLoadOnly(SpaceShip, "transDamp", setTransDamp, xmlelement, mode);
         XMLPortParamLoadOnly(SpaceShip, "rotDamp", setRotDamp, xmlelement, mode);
+        SUPER(SpaceShip, XMLPort, xmlelement, mode);
+        XMLPortParam(SpaceShip, "camera", setCamera, getCamera, xmlelement, mode);
+        XMLPortParam(SpaceShip, "maxSpeed", setMaxSpeed, getMaxSpeed, xmlelement, mode);
+        XMLPortParam(SpaceShip, "maxSideAndBackSpeed", setMaxSideAndBackSpeed, getMaxSideAndBackSpeed, xmlelement, mode);
+        XMLPortParam(SpaceShip, "maxRotation", setMaxRotation, getMaxRotation, xmlelement, mode);
+        XMLPortParam(SpaceShip, "transAcc", setTransAcc, getTransAcc, xmlelement, mode);
+        XMLPortParam(SpaceShip, "rotAcc", setRotAcc, getRotAcc, xmlelement, mode);
+        XMLPortParam(SpaceShip, "transDamp", setTransDamp, getTransDamp, xmlelement, mode);
+        XMLPortParam(SpaceShip, "rotDamp", setRotDamp, getRotDamp, xmlelement, mode);
         myShip_=true; //TODO: this is a hack
 …
         WorldEntity::tick(dt);
+        SUPER(SpaceShip, tick, dt);
         this->roll(this->mouseXRotation_ * dt);

code/trunk/src/orxonox/objects/SpaceShipAI.cc

r1608	r1747
44	44	namespace orxonox
45	45	{
46		SetConsoleCommand(SpaceShipAI, createEnemy, true).~~setD~~efaultValue(0, 1);
47		SetConsoleCommand(SpaceShipAI, killEnemies, true).~~setD~~efaultValue(0, 0);
	46	SetConsoleCommand(SpaceShipAI, createEnemy, true).defaultValue(0, 1);
	47	SetConsoleCommand(SpaceShipAI, killEnemies, true).defaultValue(0, 0);
48	48
49	49	CreateFactory(SpaceShipAI);
…	…
72	72	SpaceShipAI::~SpaceShipAI()
73	73	{
74		for (~~Iterator<SpaceShipAI>~~ it = ObjectList<SpaceShipAI>::begin(); it; ++it)
	74	for (ObjectList<SpaceShipAI>::iterator it = ObjectList<SpaceShipAI>::begin(); it; ++it)
75	75	it->shipDied(this);
76	76	}
…	…
78	78	void SpaceShipAI::XMLPort(Element& xmlelement, XMLPort::Mode mode)
79	79	{
80		S~~paceShip::XMLPort(~~xmlelement, mode);
	80	SUPER(SpaceShipAI, XMLPort, xmlelement, mode);
81	81
82	82	this->actionTimer_.setTimer(ACTION_INTERVAL, true, this, createExecutor(createFunctor(&SpaceShipAI::action)));
…	…
111	111	{
112	112	int i = 0;
113		for (~~Iterator<SpaceShipAI>~~ it = ObjectList<SpaceShipAI>::begin(); it; )
	113	for (ObjectList<SpaceShipAI>::iterator it = ObjectList<SpaceShipAI>::begin(); it; )
114	114	{
115	115	(it++)->kill();
…	…
229	229	this->doFire();
230	230
231		S~~paceShip::tick(~~dt);
	231	SUPER(SpaceShipAI, tick, dt);
232	232	}
233	233
…	…
263	263	this->forgetTarget();
264	264
265		for (~~Iterator<SpaceShip>~~ it = ObjectList<SpaceShip>::begin(); it; ++it)
	265	for (ObjectList<SpaceShip>::iterator it = ObjectList<SpaceShip>::begin(); it; ++it)
266	266	{
267	267	if (it->getTeamNr() != this->getTeamNr())

code/trunk/src/orxonox/objects/SpaceShipAI.h

-                      r1552
+                      r1747
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void tick(float dt);
             static void createEnemy(int num);
             static void killEnemies(int num);
 …
         private:
-            virtual void tick(float dt);
             virtual ColourValue getProjectileColour() const;

code/trunk/src/orxonox/objects/Tickable.h

-                      r1535
+                      r1747
 #include "core/OrxonoxClass.h"
+#include "core/Super.h"
 namespace orxonox
 …
             Tickable();
     };
+    SUPER_FUNCTION(1, Tickable, tick, true);
     //! The Tickable interface provides a tick(dt) function, that gets called every frame.

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

-                      r1625
+                      r1747
+    }
     void WorldEntity::setYawPitchRoll(const Degree& yaw, const Degree& pitch, const Degree& roll)
+    {
 …
     void WorldEntity::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
         BaseObject::XMLPort(xmlelement, mode);
+        SUPER(WorldEntity, XMLPort, xmlelement, mode);
         XMLPortParam(WorldEntity, "position", setPositionLoader2, getPosition, xmlelement, mode);
         XMLPortParamLoadOnly(WorldEntity, "direction", setDirectionLoader, xmlelement, mode);
+        XMLPortParamExternTemplate(WorldEntity, Ogre::Node, this->node_, "position", setPosition, getPosition, xmlelement, mode, Ogre::Node, const Vector3&);
+        XMLPortParamLoadOnly(WorldEntity, "direction", setDirectionSimple, xmlelement, mode);
         XMLPortParamLoadOnly(WorldEntity, "yawpitchroll", setYawPitchRoll, xmlelement, mode);
         XMLPortParam(WorldEntity, "scale", setTotalScale, getScale, xmlelement, mode);
         XMLPortParam(WorldEntity, "rotationAxis", setRotationAxisLoader, getRotationAxis, xmlelement, mode);
+        XMLPortParam(WorldEntity, "scale", setScale, getScale, xmlelement, mode);
+        XMLPortParamTemplate(WorldEntity, "rotationAxis", setRotationAxis, getRotationAxis, xmlelement, mode, WorldEntity, const Vector3&);
         XMLPortParam(WorldEntity, "rotationRate", setRotationRate, getRotationRate, xmlelement, mode);
 …
       registerVar( (void*) &(this->getRotationAxis().z), sizeof(this->getRotationAxis().z), network::DATA, 0x3);
       // register scale of node
       registerVar( (void*) &(this->getScale().x), sizeof(this->getScale().x), network::DATA, 0x3);
       registerVar( (void*) &(this->getScale().y), sizeof(this->getScale().y), network::DATA, 0x3);
       registerVar( (void*) &(this->getScale().z), sizeof(this->getScale().z), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale3D().x), sizeof(this->getScale3D().x), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale3D().y), sizeof(this->getScale3D().y), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale3D().z), sizeof(this->getScale3D().z), network::DATA, 0x3);
       //register staticity
       registerVar( (void*) &(this->bStatic_), sizeof(this->bStatic_), network::DATA, 0x3);

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

-                      r1625
+                      r1747
             inline void setPosition(const Vector3& pos)
                 { this->node_->setPosition(pos); }
-            inline void setPositionLoader1(const Vector3& pos)
-                { this->node_->setPosition(pos); }
-            inline void setPositionLoader2(Real x, Real y, Real z)
-                { this->node_->setPosition(x, y, z); }
             inline void setPosition(Real x, Real y, Real z)
                 { this->node_->setPosition(x, y, z); }
 …
             inline void rotate(const Vector3& axis, const Radian& angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
               { this->node_->rotate(axis, angle, relativeTo); }
             inline void setDirectionLoader(Real x, Real y, Real z)
+            inline void setDirectionSimple(Real x, Real y, Real z)
               { this->setDirection(x, y, z); }
             inline void setDirection(Real x, Real y, Real z, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector=Vector3::NEGATIVE_UNIT_Z)
 …
               { this->node_->lookAt(targetPoint, relativeTo, localDirectionVector); }
             inline void setScale(const Vector3& scale)
+            inline void setScale3D(const Vector3 &scale)
               { this->node_->setScale(scale); }
             inline void setScale(Real x, Real y, Real z)
+            inline void setScale3D(Real x, Real y, Real z)
               { this->node_->setScale(x, y, z); }
+            inline void setScale(Real scale)
+            inline const Vector3& getScale3D(void) const
+              { return this->node_->getScale(); }
+            inline void setScale(float scale)
               { this->node_->setScale(scale, scale, scale); }
+            inline void setTotalScale(Real scale)
+              { this->node_->setScale(scale, scale, scale); }
+            inline const Vector3& getScale(void) const
+              { return this->node_->getScale(); }
+            inline void scale(const Vector3& scale)
+            inline float getScale() const
+              { Vector3 scale = this->getScale3D(); return (scale.x == scale.y && scale.x == scale.z) ? scale.x : 1; }
+            inline void scale3D(const Vector3 &scale)
               { this->node_->scale(scale); }
             inline void scale(Real x, Real y, Real z)
+            inline void scale3D(Real x, Real y, Real z)
               { this->node_->scale(x, y, z); }
             inline void scale(Real scale)
 …
                 { return this->acceleration_; }
-            inline void setRotationAxisLoader(const Vector3& axis)
-                { this->rotationAxis_ = axis; rotationAxis_.normalise(); }
             inline void setRotationAxis(const Vector3& axis)
                 { this->rotationAxis_ = axis; rotationAxis_.normalise(); }
+                { this->rotationAxis_ = axis; this->rotationAxis_.normalise(); }
             inline void setRotationAxis(Real x, Real y, Real z)
                 { this->rotationAxis_.x = x; this->rotationAxis_.y = y; this->rotationAxis_.z = z; rotationAxis_.normalise(); }

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

-                      r1633
+                      r1747
     std::map<std::string, OrxonoxOverlay*> OrxonoxOverlay::overlays_s;
     SetConsoleCommand(OrxonoxOverlay, scaleOverlay, false).setAccessLevel(AccessLevel::User);
     SetConsoleCommand(OrxonoxOverlay, scrollOverlay, false).setAccessLevel(AccessLevel::User);
     SetConsoleCommand(OrxonoxOverlay, rotateOverlay, false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(OrxonoxOverlay, scaleOverlay, false).accessLevel(AccessLevel::User);
+    SetConsoleCommand(OrxonoxOverlay, scrollOverlay, false).accessLevel(AccessLevel::User);
+    SetConsoleCommand(OrxonoxOverlay, rotateOverlay, false).accessLevel(AccessLevel::User);
     OrxonoxOverlay::OrxonoxOverlay()
 …
     @brief
         Loads the OrxonoxOverlay.
         This has to be called before usage, otherwise strange behaviour is
         guaranteed! (there should be no segfaults however).
 …
     void OrxonoxOverlay::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    {
         BaseObject::XMLPort(xmlElement, mode);
+        SUPER(OrxonoxOverlay, XMLPort, xmlElement, mode);
         if (mode == XMLPort::LoadObject)
 …
         if (angle > Ogre::Math::PI * 0.5)
             angle = Ogre::Math::PI - angle;
         // do some mathematical fiddling for a bounding box
         Vector2 actualSize = size_ * sizeCorrection_;

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

-                      r1633
+                      r1747
         static void rotateOverlay(const std::string& name, const Degree& angle);
+        virtual void changedVisibility();
     protected:
-        virtual void changedVisibility();
         virtual void angleChanged();
         virtual void sizeCorrectionChanged();

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

-                      r1633
+                      r1747
 #include "OverlayGroup.h"
 #include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
+#include "core/Iterator.h"
 #include "core/XMLPort.h"
 #include "OrxonoxOverlay.h"
 …
     CreateFactory(OverlayGroup);
     SetConsoleCommand(OverlayGroup, toggleVisibility, false).setAccessLevel(AccessLevel::User);
     SetConsoleCommand(OverlayGroup, scaleGroup, false).setAccessLevel(AccessLevel::User);
     SetConsoleCommand(OverlayGroup, scrollGroup, false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(OverlayGroup, toggleVisibility, false).accessLevel(AccessLevel::User);
+    SetConsoleCommand(OverlayGroup, scaleGroup, false).accessLevel(AccessLevel::User);
+    SetConsoleCommand(OverlayGroup, scrollGroup, false).accessLevel(AccessLevel::User);
     OverlayGroup::OverlayGroup()
 …
     void OverlayGroup::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    {
         BaseObject::XMLPort(xmlElement, mode);
+        SUPER(OverlayGroup, XMLPort, xmlElement, mode);
         XMLPortParam(OverlayGroup, "scale",  setScale,  getScale,  xmlElement, mode).defaultValues(Vector2(1.0, 1.0));
 …
     /*static*/ void OverlayGroup::toggleVisibility(const std::string& name)
+    {
         for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        {
             if ((*it)->getName() == name)
 …
     /*static*/ void OverlayGroup::scaleGroup(const std::string& name, float scale)
+    {
         for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        {
             if ((*it)->getName() == name)
 …
     /*static*/ void OverlayGroup::scrollGroup(const std::string& name, const Vector2& scroll)
+    {
         for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        {
             if ((*it)->getName() == name)

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

-                      r1633
+                      r1747
         ~OverlayGroup() { }
         void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
         static void toggleVisibility(const std::string& name);
         static void scaleGroup(const std::string& name, float scale);
         static void scrollGroup(const std::string& name, const Vector2& scroll);
+        void changedVisibility();
     private:
 …
         OrxonoxOverlay* getElement(unsigned int index);
-        void changedVisibility();
         std::map<std::string, OrxonoxOverlay*> hudElements_;    //!< Contains all the OrxonoxOverlays of the this group.
         Vector2 scale_;                                         //!< Current scale (independant of the elements).

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

r1632	r1747
57	57	void OverlayText::XMLPort(Element& xmlElement, XMLPort::Mode mode)
58	58	{
59		~~OrxonoxOverlay::XMLPort(~~xmlElement, mode);
	59	SUPER(OverlayText, XMLPort, xmlElement, mode);
60	60
61	61	if (mode == XMLPort::LoadObject)

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

r1633	r1747
41	41	#include "util/Math.h"
42	42	#include "util/Convert.h"
43		#include "~~core~~/Debug.h"
	43	#include "util/Debug.h"
44	44	#include "core/CoreIncludes.h"
45	45	#include "core/ConfigValueIncludes.h"

code/trunk/src/orxonox/overlays/console/InGameConsole.h

r1625	r1747
50	50	void setConfigValues();
51	51
52		void tick(float dt);
	52	virtual void tick(float dt);
53	53
54	54	static InGameConsole& getInstance();

code/trunk/src/orxonox/overlays/debug/DebugFPSText.h

-                      r1625
+                      r1747
         ~DebugFPSText();
+    private:
+        void tick(float dt);
+    private:
+        virtual void tick(float dt);
     };
+}

code/trunk/src/orxonox/overlays/debug/DebugRTRText.h

-                      r1625
+                      r1747
         ~DebugRTRText();
+    private:
+        void tick(float dt);
+        virtual void tick(float dt);
     };
+}

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

-                      r1628
+                      r1747
     void BarColour::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    {
         BaseObject::XMLPort(xmlElement, mode);
+        SUPER(BarColour, XMLPort, xmlElement, mode);
         XMLPortParam(BarColour, "colour", setColour, getColour, xmlElement, mode)
 …
     void HUDBar::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    {
         OrxonoxOverlay::XMLPort(xmlElement, mode);
+        SUPER(HUDBar, XMLPort, xmlElement, mode);
         if (mode == XMLPort::LoadObject)

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

r1627	r1747
47	47	~BarColour() { }
48	48
49		void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	49	virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
50	50
51	51	void setColour(const ColourValue& colour) { this->colour_ = colour; }

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

-                      r1628
+                      r1747
     void HUDNavigation::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    {
         OrxonoxOverlay::XMLPort(xmlElement, mode);
+        SUPER(HUDNavigation, XMLPort, xmlElement, mode);
         if (mode == XMLPort::LoadObject)
 …
                 .createOverlayElement("Panel", "HUDNavigation_aimMarker_" + getUniqueNumberStr()));
             aimMarker_->setMaterialName("Orxonox/NavCrosshair");
             background_->addChild(navMarker_);
             background_->addChild(aimMarker_);

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

-                      r1627
+                      r1747
         ~HUDNavigation();
+        void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void tick(float dt);
     private:
 …
         void angleChanged() { }
         void positionChanged() { }
-        void tick(float dt);
         // XMLPort accessors

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

r1628	r1747
66	66	void HUDRadar::XMLPort(Element& xmlElement, XMLPort::Mode mode)
67	67	{
68		~~OrxonoxOverlay::XMLPort(~~xmlElement, mode);
	68	SUPER(HUDRadar, XMLPort, xmlElement, mode);
69	69
70	70	if (mode == XMLPort::LoadObject)

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

r1625	r1747
48	48	~HUDRadar();
49	49
50		void XMLPort(Element& xmlElement, XMLPort::Mode mode);
	50	virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
51	51
52	52	private:

code/trunk/src/orxonox/overlays/hud/HUDSpeedBar.h

-                      r1625
+                      r1747
         ~HUDSpeedBar();
+    private:
+        void tick(float dt);
+        virtual void tick(float dt);
     };
+}

code/trunk/src/orxonox/tools/WindowEventListener.cc

r1625	r1747
38	38	WindowEventListener::WindowEventListener()
39	39	{
40		RegisterObject(WindowEventListener);
	40	RegisterRootObject(WindowEventListener);
41	41	}
42	42	}

code/trunk/src/util/CMakeLists.txt

-                      r1505
+                      r1747
   ArgReader.cc
   Clipboard.cc
+  Error.cc
   ExprParser.cc
   Math.cc
   MultiTypePrimitive.cc
   MultiTypeString.cc
   MultiTypeMath.cc
+  MultiType.cc
+  OutputBuffer.cc
+  OutputHandler.cc
   String.cc
   SubString.cc

code/trunk/src/util/Convert.h

-                      r1625
+                      r1747
 #include "Math.h"
+#include "Debug.h"
 #include "SubString.h"
-#include "MultiTypeMath.h"
 #include "String.h"
 …
     enum { specialized = false };
     static bool convert(ToType* output, const FromType& input)
+    { return false; }
+    {
+        COUT(2) << "Warning: Couldn't convert a value: From \"" << typeid(FromType).name() << "\" to \"" << typeid(ToType).name() << "\"" << std::endl;
+        return false;
+    }
 };
 …
 // Defines the levels of all types: Default is __high__ so you don't have to define every high-level type
+template <class T> struct ConverterLevel           { enum { level = __high__ }; };
+template <> struct ConverterLevel<std::string>     { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Radian> { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Degree> { enum { level = __mid__ }; };
+template <> struct ConverterLevel<int>             { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned int>    { enum { level = __low__ }; };
+template <> struct ConverterLevel<char>            { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned char>   { enum { level = __low__ }; };
+template <> struct ConverterLevel<short>           { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned short>  { enum { level = __low__ }; };
+template <> struct ConverterLevel<long>            { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned long>   { enum { level = __low__ }; };
+template <> struct ConverterLevel<float>           { enum { level = __low__ }; };
+template <> struct ConverterLevel<double>          { enum { level = __low__ }; };
+template <> struct ConverterLevel<long double>     { enum { level = __low__ }; };
+template <> struct ConverterLevel<bool>            { enum { level = __low__ }; };
+template <class T> struct ConverterLevel              { enum { level = __high__ }; };
+template <> struct ConverterLevel<std::string>        { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Radian>    { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Degree>    { enum { level = __mid__ }; };
+template <> struct ConverterLevel<int>                { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned int>       { enum { level = __low__ }; };
+template <> struct ConverterLevel<char>               { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned char>      { enum { level = __low__ }; };
+template <> struct ConverterLevel<short>              { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned short>     { enum { level = __low__ }; };
+template <> struct ConverterLevel<long>               { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned long>      { enum { level = __low__ }; };
+template <> struct ConverterLevel<long long>          { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned long long> { enum { level = __low__ }; };
+template <> struct ConverterLevel<float>              { enum { level = __low__ }; };
+template <> struct ConverterLevel<double>             { enum { level = __low__ }; };
+template <> struct ConverterLevel<long double>        { enum { level = __low__ }; };
+template <> struct ConverterLevel<bool>               { enum { level = __low__ }; };
 …
     static bool convert(ToType* output, const FromType& input)
+    {
+        COUT(2) << "Warning: Couldn't convert a value: From \"" << typeid(FromType).name() << "\" to \"" << typeid(ToType).name() << "\"" << std::endl;
         return false;
+    }
 …
+////////////////
+// MULTITYPES //
+////////////////
+// convert from MultiTypePrimitive
+template <class ToType>
+struct ConverterSpecialized<MultiTypePrimitive, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const MultiTypePrimitive& input)
+    {
+        if (input.getType() == MT_void)
+            return ConvertValue(output, input.getVoid());
+        else if (input.getType() == MT_int)
+            return ConvertValue(output, input.getInt());
+        else if (input.getType() == MT_uint)
+            return ConvertValue(output, input.getUnsignedInt());
+        else if (input.getType() == MT_char)
+            return ConvertValue(output, input.getChar());
+        else if (input.getType() == MT_uchar)
+            return ConvertValue(output, input.getUnsignedChar());
+        else if (input.getType() == MT_short)
+            return ConvertValue(output, input.getShort());
+        else if (input.getType() == MT_ushort)
+            return ConvertValue(output, input.getUnsignedShort());
+        else if (input.getType() == MT_long)
+            return ConvertValue(output, input.getLong());
+        else if (input.getType() == MT_ulong)
+            return ConvertValue(output, input.getUnsignedLong());
+        else if (input.getType() == MT_float)
+            return ConvertValue(output, input.getFloat());
+        else if (input.getType() == MT_double)
+            return ConvertValue(output, input.getDouble());
+        else if (input.getType() == MT_longdouble)
+            return ConvertValue(output, input.getLongDouble());
+        else if (input.getType() == MT_bool)
+            return ConvertValue(output, input.getBool());
+        else
+            return false;
+    }
+};
+// convert from MultiTypeString
+template <class ToType>
+struct ConverterSpecialized<MultiTypeString, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const MultiTypeString& input)
+    {
+        if (input.getType() == MT_constchar)
+            return ConvertValue(output, input.getConstChar());
+        else if (input.getType() == MT_string)
+            return ConvertValue(output, input.getString());
+        else
+            return ConvertValue(output, (MultiTypePrimitive)input);
+    }
+};
+// convert from MultiTypeMath
+template <class ToType>
+struct ConverterSpecialized<MultiTypeMath, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const MultiTypeMath& input)
+    {
+        if (input.getType() == MT_vector2)
+            return ConvertValue(output, input.getVector2());
+        else if (input.getType() == MT_vector3)
+            return ConvertValue(output, input.getVector3());
+        else if (input.getType() == MT_vector4)
+            return ConvertValue(output, input.getVector4());
+        else if (input.getType() == MT_quaternion)
+            return ConvertValue(output, input.getQuaternion());
+        else if (input.getType() == MT_colourvalue)
+            return ConvertValue(output, input.getColourValue());
+        else if (input.getType() == MT_radian)
+            return ConvertValue(output, input.getRadian());
+        else if (input.getType() == MT_degree)
+            return ConvertValue(output, input.getDegree());
+        else
+            return ConvertValue(output, (MultiTypeString)input);
+//////////
+// MATH //
+//////////
+// convert everything to Degree
+template <class FromType>
+struct ConverterSpecialized<FromType, Ogre::Degree, _ToType_>
+{
+    enum { specialized = true };
+    static bool convert(Ogre::Degree* output, const FromType& input)
+    {
+        float angle = 0;
+        bool success = ConvertValue<FromType, float>(&angle, input);
+        (*output) = angle;
+        return success;
+    }
+};
+// convert everything to Radian
+template <class FromType>
+struct ConverterSpecialized<FromType, Ogre::Radian, _ToType_>
+{
+    enum { specialized = true };
+    static bool convert(Ogre::Radian* output, const FromType& input)
+    {
+        float angle = 0;
+        bool success = ConvertValue<FromType, float>(&angle, input);
+        (*output) = angle;
+        return success;
+    }
 };

code/trunk/src/util/MultiType.h

-                      r1505
+                      r1747
  *      ...
+ *
- *   Inspiration: MultiType by Benjamin Grauer
  */
 …
 #include "UtilPrereqs.h"
+enum _UtilExport MultiType
+#include <boost/static_assert.hpp>
+#include "Math.h"
+enum MT_Type
+{
     MT_null,
-    MT_void,
-    MT_int,
-    MT_uint,
     MT_char,
     MT_uchar,
     MT_short,
     MT_ushort,
+    MT_int,
+    MT_uint,
     MT_long,
     MT_ulong,
+    MT_longlong,
+    MT_ulonglong,
     MT_float,
     MT_double,
     MT_longdouble,
     MT_bool,
     MT_constchar,
+    MT_void,
     MT_string,
-    MT_xmlelement,
     MT_vector2,
     MT_vector3,
 …
     MT_colourvalue,
     MT_quaternion,
     MT_degree,
     MT_radian
+    MT_radian,
+    MT_degree
 };
 union _UtilExport MultiTypeValue
+class _UtilExport MultiType
+{
+    void*           void_;
+    int             int_;
+    unsigned int    uint_;
+    char            char_;
+    unsigned char   uchar_;
+    short           short_;
+    unsigned short  ushort_;
+    long            long_;
+    unsigned long   ulong_;
+    float           float_;
+    double          double_;
+    long double     longdouble_;
+    bool            bool_;
+    _UtilExport friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt);
+    template <typename T> friend struct MT_Value;
+    struct _UtilExport MT_ValueBase
+    {
+        MT_ValueBase(MT_Type type) : type_(type) {}
+        virtual ~MT_ValueBase() {}
+        virtual MT_ValueBase* clone() const = 0;
+        virtual void reset() = 0;
+        virtual void assimilate(const MultiType& other) = 0;
+        const MT_Type& getType() const { return this->type_; }
+        virtual void setValue(const char& value)                 = 0;
+        virtual void setValue(const unsigned char& value)        = 0;
+        virtual void setValue(const short& value)                = 0;
+        virtual void setValue(const unsigned short& value)       = 0;
+        virtual void setValue(const int& value)                  = 0;
+        virtual void setValue(const unsigned int& value)         = 0;
+        virtual void setValue(const long& value)                 = 0;
+        virtual void setValue(const unsigned long& value)        = 0;
+        virtual void setValue(const long long& value)            = 0;
+        virtual void setValue(const unsigned long long& value)   = 0;
+        virtual void setValue(const float& value)                = 0;
+        virtual void setValue(const double& value)               = 0;
+        virtual void setValue(const long double& value)          = 0;
+        virtual void setValue(const bool& value)                 = 0;
+        virtual void setValue(      void* const& value)          = 0;
+        virtual void setValue(const std::string& value)          = 0;
+        virtual void setValue(const orxonox::Vector2& value)     = 0;
+        virtual void setValue(const orxonox::Vector3& value)     = 0;
+        virtual void setValue(const orxonox::Vector4& value)     = 0;
+        virtual void setValue(const orxonox::ColourValue& value) = 0;
+        virtual void setValue(const orxonox::Quaternion& value)  = 0;
+        virtual void setValue(const orxonox::Radian& value)      = 0;
+        virtual void setValue(const orxonox::Degree& value)      = 0;
+        virtual operator char()                 const = 0;
+        virtual operator unsigned char()        const = 0;
+        virtual operator short()                const = 0;
+        virtual operator unsigned short()       const = 0;
+        virtual operator int()                  const = 0;
+        virtual operator unsigned int()         const = 0;
+        virtual operator long()                 const = 0;
+        virtual operator unsigned long()        const = 0;
+        virtual operator long long()            const = 0;
+        virtual operator unsigned long long()   const = 0;
+        virtual operator float()                const = 0;
+        virtual operator double()               const = 0;
+        virtual operator long double()          const = 0;
+        virtual operator bool()                 const = 0;
+        virtual operator void*()                const = 0;
+        virtual operator std::string()          const = 0;
+        virtual operator orxonox::Vector2()     const = 0;
+        virtual operator orxonox::Vector3()     const = 0;
+        virtual operator orxonox::Vector4()     const = 0;
+        virtual operator orxonox::ColourValue() const = 0;
+        virtual operator orxonox::Quaternion()  const = 0;
+        virtual operator orxonox::Radian()      const = 0;
+        virtual operator orxonox::Degree()      const = 0;
+        virtual void toString(std::ostream& outstream) const = 0;
+        MT_Type type_;
+    };
+    public:
+        inline MultiType()                                  : value_(0) {}
+        inline MultiType(const char& value)                 : value_(0) { this->assignValue(value); }
+        inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }
+        inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }
+        inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }
+        inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }
+        inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }
+        inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }
+        inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }
+        inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }
+        inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }
+        inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }
+        inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }
+        inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }
+        inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }
+        inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }
+        inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }
+        inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); }
+        inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }
+        inline MultiType(MT_Type type)                      : value_(0) { this->setType(type); }
+        inline ~MultiType() { if (this->value_) { delete this->value_; } }
+        template <typename V> inline MultiType& operator=(const V& value)         { this->setValue(value); return (*this); }
+        inline                       MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); }
+        inline                       MultiType& operator=(MT_Type type)           { this->setType(type);   return (*this); }
+        inline void                                   setValue(const char& value);
+        inline void                                   setValue(const unsigned char& value);
+        inline void                                   setValue(const short& value);
+        inline void                                   setValue(const unsigned short& value);
+        inline void                                   setValue(const int& value);
+        inline void                                   setValue(const unsigned int& value);
+        inline void                                   setValue(const long& value);
+        inline void                                   setValue(const unsigned long& value);
+        inline void                                   setValue(const long long& value);
+        inline void                                   setValue(const unsigned long long& value);
+        inline void                                   setValue(const float& value);
+        inline void                                   setValue(const double& value);
+        inline void                                   setValue(const long double& value);
+        inline void                                   setValue(const bool& value);
+        inline void                                   setValue(      void* const& value);
+        inline void                                   setValue(const std::string& value);
+        inline void                                   setValue(const orxonox::Vector2& value);
+        inline void                                   setValue(const orxonox::Vector3& value);
+        inline void                                   setValue(const orxonox::Vector4& value);
+        inline void                                   setValue(const orxonox::ColourValue& value);
+        inline void                                   setValue(const orxonox::Quaternion& value);
+        inline void                                   setValue(const orxonox::Radian& value);
+        inline void                                   setValue(const orxonox::Degree& value);
+        template <typename V> inline void             setValue(V* value)               { if (this->value_) { this->value_->setValue((void*)value); } else { this->assignValue((void*)value); } }
+        void                                          setValue(const MultiType& other) { if (this->value_) { this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } } }
+        template <typename T, typename V> inline void setValue(const V& value)         { this->setType<T>(); this->setValue(value); }
+        inline void                                   setValue(const char* value);
+        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 void convert()                       { this->setValue<T>((T)(*this));  }
+        inline void                       convert(const MultiType& other) { this->convert(other.getType()); }
+        void                              convert(MT_Type type);
+        inline void                       reset()                         { if (this->value_) { delete this->value_; this->value_ = 0; } }
+        template <typename T> inline void setType()                       { this->assignValue(T());             }
+        inline void                       setType(const MultiType& other) { this->setType(other.getType());     }
+        inline void                       setType(MT_Type type)           { this->reset(); this->convert(type); }
+        inline MT_Type                    getType()                 const { return (this->value_) ? this->value_->type_ : MT_null; }
+        inline bool                       isType(MT_Type type)      const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_null); }
+        template <typename T> inline bool isType()                  const { return false; }
+        std::string                       getTypename()             const;
+        operator char()                  const;
+        operator unsigned char()         const;
+        operator short()                 const;
+        operator unsigned short()        const;
+        operator int()                   const;
+        operator unsigned int()          const;
+        operator long()                  const;
+        operator unsigned long()         const;
+        operator long long()             const;
+        operator unsigned long long()    const;
+        operator float()                 const;
+        operator double()                const;
+        operator long double()           const;
+        operator bool()                  const;
+        operator void*()                 const;
+        operator std::string()           const;
+        operator orxonox::Vector2()      const;
+        operator orxonox::Vector3()      const;
+        operator orxonox::Vector4()      const;
+        operator orxonox::ColourValue()  const;
+        operator orxonox::Quaternion()   const;
+        operator orxonox::Radian()       const;
+        operator orxonox::Degree()       const;
+        template <class T> operator T*() const { return ((T*)this->operator void*()); }
+        inline void getValue(char*                 value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned char*        value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(short*                value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned short*       value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(int*                  value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned int*         value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(long*                 value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned long*        value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(long long*            value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned long long*   value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(float*                value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(double*               value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(long double*          value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(bool*                 value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(void*                 value) const { if (this->value_) {   value  = (*this->value_); } }
+        inline void getValue(std::string*          value) const { if (this->value_) { (*value) = this->value_->operator std::string();          } }
+        inline void getValue(orxonox::Vector2*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector2();     } }
+        inline void getValue(orxonox::Vector3*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector3();     } }
+        inline void getValue(orxonox::Vector4*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector4();     } }
+        inline void getValue(orxonox::ColourValue* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::ColourValue(); } }
+        inline void getValue(orxonox::Quaternion*  value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Quaternion();  } }
+        inline void getValue(orxonox::Radian*      value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Radian();      } }
+        inline void getValue(orxonox::Degree*      value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Degree();      } }
+        inline char                     getChar()             const { return this->operator char();                 }
+        inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        }
+        inline short                    getShort()            const { return this->operator short();                }
+        inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       }
+        inline int                      getInt()              const { return this->operator int();                  }
+        inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         }
+        inline long                     getLong()             const { return this->operator long();                 }
+        inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        }
+        inline long long                getLongLong()         const { return this->operator long long();            }
+        inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   }
+        inline float                    getFloat()            const { return this->operator float();                }
+        inline double                   getDouble()           const { return this->operator double();               }
+        inline long double              getLongDouble()       const { return this->operator long double();          }
+        inline bool                     getBool()             const { return this->operator bool();                 }
+        inline void*                    getVoid()             const { return this->operator void*();                }
+        inline std::string              getString()           const { return this->operator std::string();          }
+        inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     }
+        inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     }
+        inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     }
+        inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); }
+        inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  }
+        inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      }
+        inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      }
+        template <typename T> inline T* getPointer()          const { return ((T*)this->getVoid());                 }
+    private:
+        inline void assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_char)        { this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 } }
+        inline void assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_uchar)       { this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        } }
+        inline void assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_short)       { this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                } }
+        inline void assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_ushort)      { this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       } }
+        inline void assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_int)         { this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  } }
+        inline void assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_uint)        { this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         } }
+        inline void assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_long)        { this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 } }
+        inline void assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_ulong)       { this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        } }
+        inline void assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_longlong)    { this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            } }
+        inline void assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_ulonglong)   { this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   } }
+        inline void assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_float)       { this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                } }
+        inline void assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_double)      { this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               } }
+        inline void assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_longdouble)  { this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          } }
+        inline void assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_bool)        { this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 } }
+        inline void assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_void)        { this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                } }
+        inline void assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_string)      { this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          } }
+        inline void assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_vector2)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     } }
+        inline void assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_vector3)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     } }
+        inline void assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_vector4)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     } }
+        inline void assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_colourvalue) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); } }
+        inline void assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_quaternion)  { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  } }
+        inline void assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_radian)      { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      } }
+        inline void assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_degree)      { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      } }
+        template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
+        template <typename T>        void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
+        MT_ValueBase* value_;
 };
+_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_char);        }
+template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_uchar);       }
+template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_short);       }
+template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_ushort);      }
+template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_int);         }
+template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_uint);        }
+template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_long);        }
+template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_ulong);       }
+template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_longlong);    }
+template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_ulonglong);   }
+template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_float);       }
+template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_double);      }
+template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_longdouble);  }
+template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_bool);        }
+template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_void);        }
+template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_string);      }
+template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_vector2);     }
+template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_vector3);     }
+template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_vector4);     }
+template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_colourvalue); }
+template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_quaternion);  }
+template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_radian);      }
+template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_degree);      }
+template <> inline void MultiType::convert<std::string>()          { this->setValue<std::string>         (this->operator std::string());          }
+template <> inline void MultiType::convert<orxonox::Vector2>()     { this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     }
+template <> inline void MultiType::convert<orxonox::Vector3>()     { this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     }
+template <> inline void MultiType::convert<orxonox::Vector4>()     { this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     }
+template <> inline void MultiType::convert<orxonox::ColourValue>() { this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); }
+template <> inline void MultiType::convert<orxonox::Quaternion>()  { this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  }
+template <> inline void MultiType::convert<orxonox::Radian>()      { this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      }
+template <> inline void MultiType::convert<orxonox::Degree>()      { this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      }
+template <> inline void MultiType::convert<const std::string&>()          { this->convert<std::string>();          }
+template <> inline void MultiType::convert<const orxonox::Vector2&>()     { this->convert<orxonox::Vector2>();     }
+template <> inline void MultiType::convert<const orxonox::Vector3&>()     { this->convert<orxonox::Vector3>();     }
+template <> inline void MultiType::convert<const orxonox::Vector4&>()     { this->convert<orxonox::Vector4>();     }
+template <> inline void MultiType::convert<const orxonox::ColourValue&>() { this->convert<orxonox::ColourValue>(); }
+template <> inline void MultiType::convert<const orxonox::Quaternion&>()  { this->convert<orxonox::Quaternion>();  }
+template <> inline void MultiType::convert<const orxonox::Radian&>()      { this->convert<orxonox::Radian>();      }
+template <> inline void MultiType::convert<const orxonox::Degree&>()      { this->convert<orxonox::Degree>();      }
+template <> void MultiType::createNewValueContainer(const char& value);
+template <> void MultiType::createNewValueContainer(const unsigned char& value);
+template <> void MultiType::createNewValueContainer(const short& value);
+template <> void MultiType::createNewValueContainer(const unsigned short& value);
+template <> void MultiType::createNewValueContainer(const int& value);
+template <> void MultiType::createNewValueContainer(const unsigned int& value);
+template <> void MultiType::createNewValueContainer(const long& value);
+template <> void MultiType::createNewValueContainer(const unsigned long& value);
+template <> void MultiType::createNewValueContainer(const long long& value);
+template <> void MultiType::createNewValueContainer(const unsigned long long& value);
+template <> void MultiType::createNewValueContainer(const float& value);
+template <> void MultiType::createNewValueContainer(const double& value);
+template <> void MultiType::createNewValueContainer(const bool& value);
+template <> void MultiType::createNewValueContainer(const long double& value);
+template <> void MultiType::createNewValueContainer(      void* const& value);
+template <> void MultiType::createNewValueContainer(const std::string& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value);
+template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Radian& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Degree& value);
+inline void MultiType::setValue(const char& value)                  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const unsigned char& value)         { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const short& value)                 { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const unsigned short& value)        { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const int& value)                   { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const unsigned int& value)          { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const long& value)                  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const unsigned long& value)         { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const long long& value)             { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const unsigned long long& value)    { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const float& value)                 { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const double& value)                { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const long double& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const bool& value)                  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(      void* const& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const std::string& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const char* value)                  { if (this->value_) { this->value_->setValue(std::string(value)); } else { this->assignValue(std::string(value)); } }
 #endif /* _MultiType_H__ */

code/trunk/src/util/UtilPrereqs.h

-                      r1735
+                      r1747
 class ArgReader;
 class Convert;
+class MultiTypePrimitive;
+class MultiTypeString;
+class MultiTypeMath;
+template <class T>
+class String2Number;
+class ExprParser;
+class MultiType;
 class SubString;
+namespace orxonox
+{
+    class OutputBuffer;
+    class OutputBufferListener;
+    class Error;
+    class OutputHandler;
+}
 #endif /* _UtilPrereqs_H__ */

code/trunk/visual_studio/core_properties.vsprops

r1572	r1747
8	8	<Tool
9	9	Name="VCCLCompilerTool"
	10	AdditionalOptions="/MP2"
10	11	PreprocessorDefinitions="CORE_SHARED_BUILD"
11	12	/>

code/trunk/visual_studio/network_properties.vsprops

r1293	r1747
8	8	<Tool
9	9	Name="VCCLCompilerTool"
	10	AdditionalOptions="/MP2"
10	11	PreprocessorDefinitions="ORXONOX_NO_EXPORTS;NETWORK_STATIC_BUILD;WIN32_LEAN_AND_MEAN"
11	12	/>

code/trunk/visual_studio/orxonox_properties.vsprops

r1572	r1747
8	8	<Tool
9	9	Name="VCCLCompilerTool"
	10	AdditionalOptions="/MP2"
10	11	PreprocessorDefinitions="ORXONOX_NO_EXPORTS;NETWORK_STATIC_BUILD"
11	12	UsePrecompiledHeader="2"

code/trunk/visual_studio/vc8/core.vcproj

-                      r1631
+                      r1747
                         </File>
                         <File
-                                RelativePath="..\..\src\core\Error.cc"
+                                >
-                        </File>
-                        <File
                                 RelativePath="..\..\src\core\Language.cc"
+                                >
 …
                         </File>
                         <File
-                                RelativePath="..\..\src\core\OutputBuffer.cc"
+                                >
-                        </File>
-                        <File
-                                RelativePath="..\..\src\core\OutputHandler.cc"
+                                >
-                        </File>
-                        <File
                                 RelativePath="..\..\src\core\Script.cc"
+                                >
-                        </File>
-                        <File
-                                RelativePath="..\..\src\core\SignalHandler.cc"
+                                >
                         </File>
 …
+                                        >
                                 </File>
+                                <File
+                                        RelativePath="..\..\src\core\ObjectListBase.cc"
+                                        >
+                                </File>
                         </Filter>
                         <Filter
 …
                         </File>
                         <File
-                                RelativePath="..\..\src\core\Debug.h"
+                                >
-                        </File>
-                        <File
-                                RelativePath="..\..\src\core\Error.h"
+                                >
-                        </File>
-                        <File
                                 RelativePath="..\..\src\core\Language.h"
+                                >
 …
                         </File>
                         <File
-                                RelativePath="..\..\src\core\OutputBuffer.h"
+                                >
-                        </File>
-                        <File
-                                RelativePath="..\..\src\core\OutputHandler.h"
+                                >
-                        </File>
-                        <File
                                 RelativePath="..\..\src\core\Script.h"
+                                >
 …
                         </File>
                         <File
                                 RelativePath="..\..\src\core\SignalHandler.h"
+                                RelativePath="..\..\src\core\Super.h"
+                                >
                         </File>
 …
                                 </File>
                                 <File
+                                        RelativePath="..\..\src\core\IteratorBase.h"
+                                        >
+                                </File>
+                                <File
                                         RelativePath="..\..\src\core\MetaObjectList.h"
+                                        >
 …
                                 <File
                                         RelativePath="..\..\src\core\ObjectList.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\core\ObjectListBase.h"
+                                        >
                                 </File>

code/trunk/visual_studio/vc8/orxonox.vcproj

-                      r1625
+                      r1747
                         </File>
                         <File
+                                RelativePath="..\..\src\orxonox\SignalHandler.cc"
+                                >
+                        </File>
+                        <Filter
+                                Name="hud"
+                        <File
                                 RelativePath="..\..\src\orxonox\RadarListener.cc"
+                                >
 …
                         <File
                                 RelativePath="..\..\src\orxonox\Settings.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\orxonox\SignalHandler.h"
+                                >
                         </File>

code/trunk/visual_studio/vc8/util.vcproj

-                      r1735
+                      r1747
                         </File>
                         <File
+                                RelativePath="..\..\src\util\Error.cc"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\util\ExprParser.cc"
+                                >
 …
                         </File>
                         <File
                                 RelativePath="..\..\src\util\MultiTypeMath.cc"
+                                >
                         </File>
                         <File
                                 RelativePath="..\..\src\util\MultiTypePrimitive.cc"
+                                >
                         </File>
                         <File
                                 RelativePath="..\..\src\util\MultiTypeString.cc"
+                                RelativePath="..\..\src\util\MultiType.cc"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\util\OutputBuffer.cc"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\util\OutputHandler.cc"
+                                >
                         </File>
 …
                         </File>
                         <File
+                                RelativePath="..\..\src\util\Debug.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\util\Error.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\util\ExprParser.h"
+                                >
 …
                         </File>
                         <File
+                                RelativePath="..\..\src\util\MultiTypeMath.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\util\MultiTypePrimitive.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\util\MultiTypeString.h"
+                                RelativePath="..\..\src\util\MultiTypeValue.h"
+                                >
                         </File>
                         <File
                                 RelativePath="..\..\src\util\OrxonoxPlatform.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\util\OutputBuffer.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\util\OutputHandler.h"
+                                >
                         </File>

Context Navigation

Legend:

Download in other formats: