Changeset 5935 for code/branches/pickup/src/libraries

code/branches/pickup

Property svn:mergeinfo changed

/code/branches/core5 (added)	merged: 5768-5769,5772,5775-5780,5783-5785,5791-5792,5795-5807,5809-5814,5816-5832,5836-5839,5842-5853,5855-5899,5904-5922,5924-5928
/code/trunk (added)	merged: 5900-5901,5923,5929

code/branches/pickup/src/libraries/CMakeLists.txt

-                      r5781
+                      r5935
 ################ Sub Directories ################
+ADD_SUBDIRECTORY(util)
 ADD_SUBDIRECTORY(core)
 ADD_SUBDIRECTORY(network)
 ADD_SUBDIRECTORY(tools)
-ADD_SUBDIRECTORY(util)

code/branches/pickup/src/libraries/core/ArgumentCompletionFunctions.cc

-                      r5781
+                      r5935
             ArgumentCompletionList classlist;
             for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getIdentifierMapBegin(); it != Identifier::getIdentifierMapEnd(); ++it)
+            for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapBegin(); it != Identifier::getStringIdentifierMapEnd(); ++it)
                 if ((*it).second->hasConfigValues())
                     classlist.push_back(ArgumentCompletionListElement((*it).second->getName(), getLowercase((*it).first)));
 …
+        {
             ArgumentCompletionList configvalues;
             std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getIdentifierMap().find(classname);
+            std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getStringIdentifierMap().find(classname);
             if (identifier != Identifier::getIdentifierMapEnd() && (*identifier).second->hasConfigValues())
+            if (identifier != Identifier::getStringIdentifierMapEnd() && (*identifier).second->hasConfigValues())
+            {
                 for (std::map<std::string, ConfigValueContainer*>::const_iterator it = (*identifier).second->getConfigValueMapBegin(); it != (*identifier).second->getConfigValueMapEnd(); ++it)
 …
+        {
             ArgumentCompletionList oldvalue;
             std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseIdentifierMap().find(getLowercase(classname));
             if (identifier != Identifier::getLowercaseIdentifierMapEnd())
+            std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseStringIdentifierMap().find(getLowercase(classname));
+            if (identifier != Identifier::getLowercaseStringIdentifierMapEnd())
+            {
                 std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));

code/branches/pickup/src/libraries/core/BaseObject.cc

-                      r5781
+                      r5935
         this->bVisible_ = true;
         this->oldGametype_ = 0;
+        this->bRegisteredEventStates_ = false;
         this->lastLoadedXMLElement_ = 0;
+        this->functorSetMainState_ = 0;
+        this->functorGetMainState_ = 0;
+        this->mainStateFunctor_ = 0;
         this->setCreator(creator);
 …
             this->setFile(this->creator_->getFile());
             this->setNamespace(this->creator_->getNamespace());
             this->setScene(this->creator_->getScene());
+            this->setScene(this->creator_->getScene(), this->creator_->getSceneID());
             this->setGametype(this->creator_->getGametype());
+        }
 …
             this->namespace_ = 0;
             this->scene_ = 0;
+            this->sceneID_ = OBJECTID_UNKNOWN;
             this->gametype_ = 0;
+        }
 …
         if (this->isInitialized())
+        {
+            for (std::list<BaseObject*>::const_iterator it = this->events_.begin(); it != this->events_.end(); ++it)
+                (*it)->unregisterEventListener(this);
+            for (std::map<BaseObject*, std::string>::const_iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+                it->first->removeEvent(this);
+            if (this->functorSetMainState_)
+                delete this->functorSetMainState_;
+            if (this->functorGetMainState_)
+                delete this->functorGetMainState_;
+            for (std::map<BaseObject*, std::string>::const_iterator it = this->eventSources_.begin(); it != this->eventSources_.end(); )
+                this->removeEventSource((it++)->first);
+            for (std::set<BaseObject*>::const_iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); )
+                (*(it++))->removeEventSource(this);
+            for (std::map<std::string, EventState*>::const_iterator it = this->eventStates_.begin(); it != this->eventStates_.end(); ++it)
+                delete it->second;
+        }
+    }
 …
         @param xmlelement The XML-element
         @param loading Loading (true) or saving (false)
-        @return The XML-element
     */
     void BaseObject::XMLPort(Element& xmlelement, XMLPort::Mode mode)
 …
         XMLPortObjectTemplate(BaseObject, Template, "templates", addTemplate, getTemplate, xmlelement, mode, Template*);
+        Element* events = xmlelement.FirstChildElement("events", false);
+        XMLPortObject(BaseObject, BaseObject, "eventlisteners", addEventListener, getEventListener, xmlelement, mode);
+        Element* events = 0;
+        if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
+            events = xmlelement.FirstChildElement("events", false);
+        else if (mode == XMLPort::SaveObject)
+            {}
         if (events)
+        {
+            std::list<std::string> eventnames;
+            if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
+            {
+                for (ticpp::Iterator<ticpp::Element> child = events->FirstChildElement(false); child != child.end(); child++)
+                    eventnames.push_back(child->Value());
+            }
+            else if (mode == XMLPort::SaveObject)
+            {
+                for (std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->getIdentifier()->getXMLPortEventMapBegin(); it != this->getIdentifier()->getXMLPortEventMapEnd(); ++it)
+                    eventnames.push_back(it->first);
+            }
+            for (std::list<std::string>::iterator it = eventnames.begin(); it != eventnames.end(); ++it)
+            {
+                std::string sectionname = (*it);
+                ExecutorMember<BaseObject>* loadexecutor = createExecutor(createFunctor(&BaseObject::addEvent), std::string( "BaseObject" ) + "::" + "addEvent");
+                ExecutorMember<BaseObject>* saveexecutor = createExecutor(createFunctor(&BaseObject::getEvent), std::string( "BaseObject" ) + "::" + "getEvent");
+                loadexecutor->setDefaultValue(1, sectionname);
+                XMLPortClassObjectContainer<BaseObject, BaseObject>* container = 0;
+                container = (XMLPortClassObjectContainer<BaseObject, BaseObject>*)(this->getIdentifier()->getXMLPortEventContainer(sectionname));
+                if (!container)
+                {
+                    container = new XMLPortClassObjectContainer<BaseObject, BaseObject>(sectionname, this->getIdentifier(), loadexecutor, saveexecutor, false, true);
+                    this->getIdentifier()->addXMLPortEventContainer(sectionname, container);
+                }
+                container->port(this, *events, mode);
+            }
+        }
+            this->XMLEventPort(*events, mode);
+    }
+    /**
+        @brief Defines the possible event states of this object and parses eventsources from an XML file.
+        @param xmlelement The XML-element
+        @param loading Loading (true) or saving (false)
+    */
+    void BaseObject::XMLEventPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        XMLPortEventState(BaseObject, BaseObject, "activity", setActive, xmlelement, mode);
+        XMLPortEventState(BaseObject, BaseObject, "visibility", setVisible, xmlelement, mode);
+        XMLPortEventState(BaseObject, BaseObject, "mainstate", setMainState, xmlelement, mode);
+        this->bRegisteredEventStates_ = true;
+    }
 …
+    }
+    void BaseObject::addEvent(BaseObject* event, const std::string& sectionname)
+    {
+        event->registerEventListener(this, sectionname);
+        this->events_.push_back(event);
+    }
+    void BaseObject::removeEvent(BaseObject* event)
+    {
+        this->events_.remove(event);
+    }
+    BaseObject* BaseObject::getEvent(unsigned int index) const
+    /**
+        @brief Adds a new event source for a specific state.
+        @param source The object which sends events to this object
+        @param state The state of this object which will be affected by the events
+    */
+    void BaseObject::addEventSource(BaseObject* source, const std::string& state)
+    {
+        this->eventSources_[source] = state;
+        source->registerEventListener(this);
+    }
+    /**
+        @brief Removes an eventsource (but doesn't unregister itself at the source).
+    */
+    void BaseObject::removeEventSource(BaseObject* source)
+    {
+        this->eventSources_.erase(source);
+        source->unregisterEventListener(this);
+    }
+    /**
+        @brief Returns an eventsource with a given index.
+    */
+    BaseObject* BaseObject::getEventSource(unsigned int index, const std::string& state) const
+    {
         unsigned int i = 0;
+        for (std::list<BaseObject*>::const_iterator it = this->events_.begin(); it != this->events_.end(); ++it)
+        {
+        for (std::map<BaseObject*, std::string>::const_iterator it = this->eventSources_.begin(); it != this->eventSources_.end(); ++it)
+        {
+            if (it->second != state)
+                continue;
             if (i == index)
                 return (*it);
+                return it->first;
             ++i;
+        }
 …
+    }
+    void BaseObject::addEventContainer(const std::string& sectionname, EventContainer* container)
+    {
+        std::map<std::string, EventContainer*>::const_iterator it = this->eventContainers_.find(sectionname);
+        if (it != this->eventContainers_.end())
+        {
+            COUT(2) << "Warning: Overwriting EventContainer in class " << this->getIdentifier()->getName() << "." << std::endl;
+    /**
+        @brief Adds an object which listens to the events of this object. The events are sent to the other objects mainstate.
+    */
+    void BaseObject::addEventListener(BaseObject* listener)
+    {
+        this->eventListenersXML_.insert(listener);
+        listener->addEventSource(this, "mainstate");
+    }
+    /**
+        @brief Returns an event listener with a given index.
+    */
+    BaseObject* BaseObject::getEventListener(unsigned int index) const
+    {
+        unsigned int i = 0;
+        for (std::set<BaseObject*>::const_iterator it = this->eventListenersXML_.begin(); it != this->eventListenersXML_.end(); ++it)
+        {
+            if (i == index)
+                return *it;
+            ++i;
+        }
+        return 0;
+    }
+    /**
+        @brief Adds a new event-state to the object. Event-states are states which can be changed by events.
+        @param name  The name of the event
+        @param state The object containing information about the event-state
+    */
+    void BaseObject::addEventState(const std::string& name, EventState* state)
+    {
+        std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(name);
+        if (it != this->eventStates_.end())
+        {
+            COUT(2) << "Warning: Overwriting EventState in class " << this->getIdentifier()->getName() << "." << std::endl;
             delete (it->second);
+        }
+        this->eventContainers_[sectionname] = container;
+    }
+    EventContainer* BaseObject::getEventContainer(const std::string& sectionname) const
+    {
+        std::map<std::string, EventContainer*>::const_iterator it = this->eventContainers_.find(sectionname);
+        if (it != this->eventContainers_.end())
+        this->eventStates_[name] = state;
+    }
+    /**
+        @brief Returns the event-state with the given name.
+    */
+    EventState* BaseObject::getEventState(const std::string& name) const
+    {
+        std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(name);
+        if (it != this->eventStates_.end())
             return ((*it).second);
         else
 …
+    }
+    void BaseObject::fireEvent()
+    {
+        this->fireEvent(true);
+        this->fireEvent(false);
+    }
+    void BaseObject::fireEvent(bool activate)
+    {
+        this->fireEvent(activate, this);
+    }
+    void BaseObject::fireEvent(bool activate, BaseObject* originator)
+    {
+        Event event(activate, originator);
+        for (std::map<BaseObject*, std::string>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+        {
+            event.sectionname_ = it->second;
+            it->first->processEvent(event);
+        }
+    }
+    /**
+        @brief Fires an event (without a state).
+    */
+    void BaseObject::fireEvent(const std::string& name)
+    {
+        this->fireEvent(true, name);
+        this->fireEvent(false, name);
+    }
+    /**
+        @brief Fires an event which activates or deactivates a state.
+    */
+    void BaseObject::fireEvent(bool activate, const std::string& name)
+    {
+        this->fireEvent(activate, this, name);
+    }
+    /**
+        @brief Fires an event which activates or deactivates a state with agiven originator (the object which triggered the event).
+    */
+    void BaseObject::fireEvent(bool activate, BaseObject* originator, const std::string& name)
+    {
+        Event event(activate, originator, name);
+        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+        {
+            event.statename_ = (*it)->eventSources_[this];
+            (*it)->processEvent(event);
+        }
+    }
+    /**
+        @brief Fires an event, using the Event struct.
+    */
     void BaseObject::fireEvent(Event& event)
+    {
+        for (std::map<BaseObject*, std::string>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+            it->first->processEvent(event);
+    }
+        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+            (*it)->processEvent(event);
+    }
+    /**
+        @brief Processing an event by calling the right main state.
+        @param event The event struct which contains the information about the event
+    */
     void BaseObject::processEvent(Event& event)
+    {
+        ORXONOX_SET_EVENT(BaseObject, "activity", setActive, event);
+        ORXONOX_SET_EVENT(BaseObject, "visibility", setVisible, event);
+    }
+    void BaseObject::setMainStateName(const std::string& name)
+    {
+        if (this->mainStateName_ != name)
+        {
+            this->mainStateName_ = name;
+            if (this->functorSetMainState_)
+                delete this->functorSetMainState_;
+            if (this->functorGetMainState_)
+                delete this->functorGetMainState_;
+            this->changedMainState();
+            if (!this->functorSetMainState_)
+                COUT(2) << "Warning: \"" << name << "\" is not a valid MainState." << std::endl;
+        }
+    }
+        this->registerEventStates();
+        std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(event.statename_);
+        if (it != this->eventStates_.end())
+            it->second->process(event, this);
+        else if (event.statename_ != "")
+            COUT(2) << "Warning: \"" << event.statename_ << "\" is not a valid state in object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::endl;
+        else
+            COUT(2) << "Warning: Event with invalid source sent to object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::endl;
+    }
+    /**
+        @brief Sets the main state of the object to a given boolean value.
+        Note: The main state of an object can be set with the @ref setMainStateName function.
+        It's part of the eventsystem and used for event forwarding (when the target object can't specify a specific state,
+        the main state is used by default).
+    */
     void BaseObject::setMainState(bool state)
+    {
+        if (this->functorSetMainState_)
+            (*this->functorSetMainState_)(state);
+        if (this->mainStateFunctor_)
+        {
+            if (this->mainStateFunctor_->getParamCount() == 0)
+            {
+                if (state)
+                    (*this->mainStateFunctor_)();
+            }
+            else
+            {
+                (*this->mainStateFunctor_)(state);
+            }
+        }
         else
             COUT(2) << "Warning: No MainState defined in object \"" << this->getName() << "\" (" << this->getIdentifier()->getName() << ")" << std::endl;
+    }
+    bool BaseObject::getMainState() const
+    {
+        if (this->functorGetMainState_)
+        {
+            (*this->functorGetMainState_)();
+            return this->functorGetMainState_->getReturnvalue();
+        }
+        else
+        {
+            COUT(2) << "Warning: No MainState defined in object \"" << this->getName() << "\" (" << this->getIdentifier()->getName() << ")" << std::endl;
+            return false;
+        }
+    }
+    void BaseObject::changedMainState()
+    {
+        SetMainState(BaseObject, "activity",   setActive,  isActive);
+        SetMainState(BaseObject, "visibility", setVisible, isVisible);
+    /**
+        @brief This function gets called if the main state name of the object changes.
+    */
+    void BaseObject::changedMainStateName()
+    {
+        this->mainStateFunctor_ = 0;
+        if (this->mainStateName_ != "")
+        {
+            this->registerEventStates();
+            std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(this->mainStateName_);
+            if (it != this->eventStates_.end() && it->second->getFunctor())
+            {
+                if (it->second->getFunctor()->getParamCount() <= 1)
+                    this->mainStateFunctor_ = it->second->getFunctor();
+                else
+                    COUT(2) << "Warning: Can't use \"" << this->mainStateName_ << "\" as MainState because it needs a second argument." << std::endl;
+            }
+            else
+                COUT(2) << "Warning: \"" << this->mainStateName_ << "\" is not a valid MainState." << std::endl;
+        }
+    }
+    /**
+        @brief Calls XMLEventPort with an empty XML-element to register the event states if necessary.
+    */
+    void BaseObject::registerEventStates()
+    {
+        if (!this->bRegisteredEventStates_)
+        {
+            Element xmlelement;
+            this->XMLEventPort(xmlelement, XMLPort::NOP);
+        }
+    }
+    /**
+        @brief Manually loads all event states, even if the class doesn't officially support them. This is needed by some classes like @ref EventDispatcher or @ref EventTarget.
+    */
+    void BaseObject::loadAllEventStates(Element& xmlelement, XMLPort::Mode mode, BaseObject* object, Identifier* identifier)
+    {
+        Element* events = xmlelement.FirstChildElement("events", false);
+        if (events)
+        {
+            // get the list of all states present
+            std::list<std::string> eventnames;
+            if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
+            {
+                for (ticpp::Iterator<ticpp::Element> child = events->FirstChildElement(false); child != child.end(); child++)
+                    eventnames.push_back(child->Value());
+            }
+            else if (mode == XMLPort::SaveObject)
+            {
+            }
+            // iterate through all states and get the event sources
+            for (std::list<std::string>::iterator it = eventnames.begin(); it != eventnames.end(); ++it)
+            {
+                std::string statename = (*it);
+                // if the event state is already known, continue with the next state
+                orxonox::EventState* eventstate = object->getEventState(statename);
+                if (eventstate)
+                    continue;
+                XMLPortClassObjectContainer<BaseObject, BaseObject>* container = (XMLPortClassObjectContainer<BaseObject, BaseObject>*)(identifier->getXMLPortObjectContainer(statename));
+                if (!container)
+                {
+                    ExecutorMember<BaseObject>* setfunctor = createExecutor(createFunctor(&BaseObject::addEventSource), std::string( "BaseObject" ) + "::" + "addEventSource" + "(" + statename + ")");
+                    ExecutorMember<BaseObject>* getfunctor = createExecutor(createFunctor(&BaseObject::getEventSource), std::string( "BaseObject" ) + "::" + "getEventSource" + "(" + statename + ")");
+                    setfunctor->setDefaultValue(1, statename);
+                    getfunctor->setDefaultValue(1, statename);
+                    container = new XMLPortClassObjectContainer<BaseObject, BaseObject>(statename, identifier, setfunctor, getfunctor, false, true);
+                    identifier->addXMLPortObjectContainer(statename, container);
+                }
+                container->port(object, *events, mode);
+            }
+        }
+    }
+}

code/branches/pickup/src/libraries/core/BaseObject.h

-                      r5781
+                      r5935
 #define _BaseObject_H__
-#define SetMainState(classname, statename, setfunction, getfunction) \
-    if (this->getMainStateName() == statename) \
-    { \
-        this->functorSetMainState_ = createFunctor(&classname::setfunction)->setObject(this); \
-        this->functorGetMainState_ = createFunctor(&classname::getfunction)->setObject(this); \
+    }
 #include "CorePrereqs.h"
 …
 #include "OrxonoxClass.h"
 #include "Super.h"
+#include "SmartPtr.h"
 namespace orxonox
 …
             virtual ~BaseObject();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
             /** @brief Returns if the object was initialized (passed the object registration). @return True was the object is initialized */
 …
             void setMainState(bool state);
+            bool getMainState() const;
+            void setMainStateName(const std::string& name);
+            /** @brief Sets the name of the main state (used for event reactions). */
+            void setMainStateName(const std::string& name)
+            {
+                if (this->mainStateName_ != name)
+                {
+                    this->mainStateName_ = name;
+                    this->changedMainStateName();
+                }
+            }
+            /** @brief Returns the name of the main state. */
             inline const std::string& getMainStateName() const { return this->mainStateName_; }
+            virtual void changedMainState();
+            /** @brief This function gets called if the main state name of the object changes. */
+            virtual void changedMainStateName();
             /** @brief Sets a pointer to the xml file that loaded this object. @param file The pointer to the XMLFile */
 …
             inline BaseObject* getCreator() const { return this->creator_; }
+            inline void setScene(Scene* scene) { this->scene_ = scene; }
+            inline Scene* getScene() const { return this->scene_; }
+            inline void setGametype(Gametype* gametype)
+            inline void setScene(const SmartPtr<Scene>& scene, uint32_t sceneID) { this->scene_ = scene; this->sceneID_=sceneID; }
+            inline const SmartPtr<Scene>& getScene() const { return this->scene_; }
+            inline virtual uint32_t getSceneID() const { return this->sceneID_; }
+            inline void setGametype(const SmartPtr<Gametype>& gametype)
+            {
                 if (gametype != this->gametype_)
 …
+                }
+            }
             inline Gametype* getGametype() const { return this->gametype_; }
+            inline const SmartPtr<Gametype>& getGametype() const { return this->gametype_; }
             inline Gametype* getOldGametype() const { return this->oldGametype_; }
             virtual void changedGametype() {}
+            void fireEvent();
+            void fireEvent(bool activate);
+            void fireEvent(bool activate, BaseObject* originator);
+            void addEventSource(BaseObject* source, const std::string& state);
+            void removeEventSource(BaseObject* source);
+            BaseObject* getEventSource(unsigned int index, const std::string& state) const;
+            void addEventListener(BaseObject* listener);
+            BaseObject* getEventListener(unsigned int index) const;
+            void fireEvent(const std::string& name = "");
+            void fireEvent(bool activate, const std::string& name = "");
+            void fireEvent(bool activate, BaseObject* originator, const std::string& name = "");
             void fireEvent(Event& event);
             virtual void processEvent(Event& event);
-            inline void registerEventListener(BaseObject* object, const std::string& sectionname)
-                { this->eventListeners_[object] = sectionname; }
-            inline void unregisterEventListener(BaseObject* object)
-                { this->eventListeners_.erase(object); }
-            void addEvent(BaseObject* event, const std::string& sectionname);
-            void removeEvent(BaseObject* event);
-            BaseObject* getEvent(unsigned int index) const;
-            void addEventContainer(const std::string& sectionname, EventContainer* container);
-            EventContainer* getEventContainer(const std::string& sectionname) const;
             /** @brief Sets the indentation of the debug output in the Loader. @param indentation The indentation */
 …
             /** @brief Returns the indentation of the debug output in the Loader. @return The indentation */
             inline const std::string& getLoaderIndentation() const { return this->loaderIndentation_; }
+            static void loadAllEventStates(Element& xmlelement, XMLPort::Mode mode, BaseObject* object, Identifier* identifier);
         protected:
+            void addEventState(const std::string& name, EventState* container);
+            EventState* getEventState(const std::string& name) const;
             std::string name_;                                 //!< The name of the object
             std::string oldName_;                              //!< The old name of the object
 …
             mbool       bVisible_;                             //!< True = the object is visible
             std::string mainStateName_;
+            Functor*    functorSetMainState_;
+            Functor*    functorGetMainState_;
+            Functor*    mainStateFunctor_;
         private:
+            /** @brief Adds an object which listens to the events of this object. */
+            inline void registerEventListener(BaseObject* object)
+                { this->eventListeners_.insert(object); }
+            /** @brief Removes an event listener from this object. */
+            inline void unregisterEventListener(BaseObject* object)
+                { this->eventListeners_.erase(object); }
             void setXMLName(const std::string& name);
             Template* getTemplate(unsigned int index) const;
+            void registerEventStates();
             bool                   bInitialized_;              //!< True if the object was initialized (passed the object registration)
 …
             Namespace*             namespace_;
             BaseObject*            creator_;
+            Scene*                 scene_;
+            Gametype*              gametype_;
+            SmartPtr<Scene>        scene_;
+            uint32_t               sceneID_;
+            SmartPtr<Gametype>     gametype_;
             Gametype*              oldGametype_;
             std::set<Template*>    templates_;
+            std::map<BaseObject*,  std::string> eventListeners_;
+            std::list<BaseObject*> events_;
+            std::map<std::string, EventContainer*> eventContainers_;
+            std::map<BaseObject*, std::string>  eventSources_;           //!< List of objects which send events to this object, mapped to the state which they affect
+            std::set<BaseObject*>               eventListeners_;         //!< List of objects which listen to the events of this object
+            std::set<BaseObject*>               eventListenersXML_;      //!< List of objects which listen to the events of this object through the "eventlisteners" subsection in XML
+            std::map<std::string, EventState*>  eventStates_;            //!< Maps the name of the event states to their helper objects
+            bool                                bRegisteredEventStates_; //!< Becomes true after the object registered its event states (with XMLEventPort)
     };
 …
     SUPER_FUNCTION(2, BaseObject, changedActivity, false);
     SUPER_FUNCTION(3, BaseObject, changedVisibility, false);
+    SUPER_FUNCTION(4, BaseObject, processEvent, false);
+    SUPER_FUNCTION(6, BaseObject, changedMainState, false);
+    SUPER_FUNCTION(9, BaseObject, changedName, false);
+    SUPER_FUNCTION(10, BaseObject, changedGametype, false);
+    SUPER_FUNCTION(4, BaseObject, XMLEventPort, false);
+    SUPER_FUNCTION(8, BaseObject, changedName, false);
+    SUPER_FUNCTION(9, BaseObject, changedGametype, false);
+}

code/branches/pickup/src/libraries/core/CMakeLists.txt

-                      r5781
+                      r5935
 SET_SOURCE_FILES(CORE_SRC_FILES
-  Clock.cc
-  ConfigFileManager.cc
   ConfigValueContainer.cc
   Core.cc
 …
   Language.cc
   LuaState.cc
-  MemoryArchive.cc
   ObjectListBase.cc
   OrxonoxClass.cc
   Resource.cc
+  ScopedSingletonManager.cc
   WindowEventListener.cc
   # command
-  ArgumentCompletionFunctions.cc
   CommandEvaluation.cc
   CommandExecutor.cc
 …
   # hierarchy
-  Factory.cc
   Identifier.cc
   MetaObjectList.cc
 …
   Shell.cc
   TclBind.cc
+COMPILATION_BEGIN FilesystemCompilation.cc
+  ArgumentCompletionFunctions.cc
+  ConfigFileManager.cc
+  MemoryArchive.cc
+  PathConfig.cc
+COMPILATION_END
+  # multithreading
+  ThreadPool.cc
+COMPILATION_BEGIN ThreadCompilation.cc
   TclThreadManager.cc
-  # multithreading
   Thread.cc
+  ThreadPool.cc
+COMPILATION_END
+)
 ADD_SUBDIRECTORY(input)

code/branches/pickup/src/libraries/core/ClassFactory.h

-                      r5781
+                      r5935
 #include "util/Debug.h"
-#include "Factory.h"
 #include "Identifier.h"
 namespace orxonox
+{
+    // ###########################
+    // ###       Factory       ###
+    // ###########################
+    //! Base-class of ClassFactory.
+    class _CoreExport Factory
+    {
+        public:
+            virtual ~Factory() {};
+            virtual BaseObject* fabricate(BaseObject* creator) = 0;
+    };
     // ###############################
     // ###      ClassFactory       ###
 …
     //! The ClassFactory is able to create new objects of a specific class.
     template <class T>
     class ClassFactory : public BaseFactory
+    class ClassFactory : public Factory
+    {
         public:
+            static bool create(const std::string& name, bool bLoadable = true);
+            BaseObject* fabricate(BaseObject* creator);
+            /**
+                @brief Constructor: Adds the ClassFactory to the Identifier of the same type.
+                @param name The name of the class
+                @param bLoadable True if the class can be loaded through XML
+            */
+            ClassFactory(const std::string& name, bool bLoadable = true)
+            {
+                COUT(4) << "*** ClassFactory: Create entry for " << name << " in Factory." << std::endl;
+                ClassIdentifier<T>::getIdentifier(name)->addFactory(this);
+                ClassIdentifier<T>::getIdentifier()->setLoadable(bLoadable);
+            }
+        private:
+            ClassFactory() {}                               // Don't create
+            ClassFactory(const ClassFactory& factory) {}    // Don't copy
+            virtual ~ClassFactory() {}                      // Don't delete
+            static T* createNewObject(BaseObject* creator);
+            /**
+                @brief Creates and returns a new object of class T.
+                @return The new object
+            */
+            inline BaseObject* fabricate(BaseObject* creator)
+            {
+                return static_cast<BaseObject*>(new T(creator));
+            }
     };
-    /**
-        @brief Adds the ClassFactory to the Identifier of the same type and the Identifier to the Factory.
-        @param name The name of the class
-        @param bLoadable True if the class can be loaded through XML
-        @return Always true (this is needed because the compiler only allows assignments before main())
-    */
-    template <class T>
-    bool ClassFactory<T>::create(const std::string& name, bool bLoadable)
+    {
-        COUT(4) << "*** ClassFactory: Create entry for " << name << " in Factory." << std::endl;
-        ClassIdentifier<T>::getIdentifier(name)->addFactory(new ClassFactory<T>);
-        ClassIdentifier<T>::getIdentifier()->setLoadable(bLoadable);
-        Factory::add(name, ClassIdentifier<T>::getIdentifier());
-        return true;
+    }
-    /**
-        @brief Creates and returns a new object of class T.
-        @return The new object
-    */
-    template <class T>
-    inline BaseObject* ClassFactory<T>::fabricate(BaseObject* creator)
+    {
-        return ClassFactory<T>::createNewObject(creator);
+    }
-    /**
-        @brief Creates and returns a new object of class T; this is a wrapper for the new operator.
-        @return The new object
-    */
-    template <class T>
-    inline T* ClassFactory<T>::createNewObject(BaseObject* creator)
+    {
-        return new T(creator);
+    }
+}

code/branches/pickup/src/libraries/core/ClassTreeMask.cc

r5781	r5935
488	488
489	489	// Remove the redundant subnode from the current node
	490	delete (*it);
490	491	node->subnodes_.erase(it++);
491	492	}

code/branches/pickup/src/libraries/core/ClassTreeMask.h

-                      r5781
+                      r5935
             /** @brief Returns true if the ClassTreeMaskObjectIterator points at the given object. @param pointer The pointer of the object */
             inline bool operator==(BaseObject* pointer) const { return ((*this->objectIterator_) == pointer); }
+            inline bool operator==(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) == pointer) || (!this->objectIterator_ && pointer == 0); }
             /** @brief Returns true if the ClassTreeMaskObjectIterator doesn't point at the given object. @param pointer The pointer of the object */
             inline bool operator!=(BaseObject* pointer) const { return ((*this->objectIterator_) != pointer); }
+            inline bool operator!=(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) != pointer) || (!this->objectIterator_ && pointer != 0); }
             /** @brief Returns true if the ClassTreeMaskObjectIterator hasn't already reached the end. */
             inline operator bool() const { return (this->objectIterator_); }

code/branches/pickup/src/libraries/core/CommandExecutor.cc

-                      r5781
+                      r5935
         CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.clear();
         std::string lowercase = getLowercase(fragment);
         for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseIdentifierMapBegin(); it != Identifier::getLowercaseIdentifierMapEnd(); ++it)
+        for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMapBegin(); it != Identifier::getLowercaseStringIdentifierMapEnd(); ++it)
             if ((*it).second->hasConsoleCommands())
                 if ((*it).first.find(lowercase) == 0 || fragment == "")
 …
+    {
         std::string lowercase = getLowercase(name);
         std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseIdentifierMap().find(lowercase);
         if ((it != Identifier::getLowercaseIdentifierMapEnd()) && (*it).second->hasConsoleCommands())
+        std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMap().find(lowercase);
+        if ((it != Identifier::getLowercaseStringIdentifierMapEnd()) && (*it).second->hasConsoleCommands())
             return (*it).second;

code/branches/pickup/src/libraries/core/CommandLine.cc

-                      r5738
+                      r5935
 #include <algorithm>
 #include <sstream>
-#include <boost/filesystem.hpp>
 #include "util/Convert.h"
 …
 #include "util/StringUtils.h"
 #include "util/SubString.h"
 #include "Core.h"
+#include "PathConfig.h"
 namespace orxonox
 …
+        }
+        infoStr << std::endl;
         infoStr << "Usage: orxonox [options]" << std::endl;
         infoStr << "Available options:" << std::endl;
 …
+    {
         std::string filename = CommandLine::getValue("optionsFile").getString();
-        boost::filesystem::path filepath(Core::getConfigPath() / filename);
         // look for additional arguments in given file or start.ini as default
         // They will not overwrite the arguments given directly
         std::ifstream file;
         file.open(filepath.string().c_str());
+        file.open((PathConfig::getConfigPathString() + filename).c_str());
         std::vector<std::string> args;
         if (file)

code/branches/pickup/src/libraries/core/ConfigFileManager.cc

-                      r5781
+                      r5935
 #include "ConsoleCommand.h"
 #include "ConfigValueContainer.h"
 #include "Core.h"
+#include "PathConfig.h"
 namespace orxonox
 …
     bool config(const std::string& classname, const std::string& varname, const std::string& value)
+    {
         std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseIdentifierMap().find(getLowercase(classname));
         if (identifier != Identifier::getLowercaseIdentifierMapEnd())
+        std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseStringIdentifierMap().find(getLowercase(classname));
+        if (identifier != Identifier::getLowercaseStringIdentifierMapEnd())
+        {
             std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));
 …
     bool tconfig(const std::string& classname, const std::string& varname, const std::string& value)
+    {
         std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseIdentifierMap().find(getLowercase(classname));
         if (identifier != Identifier::getLowercaseIdentifierMapEnd())
+        std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseStringIdentifierMap().find(getLowercase(classname));
+        if (identifier != Identifier::getLowercaseStringIdentifierMapEnd())
+        {
             std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));
 …
         // Get default file if necessary and available
         boost::filesystem::path filepath(Core::getConfigPath() / this->filename_);
+        boost::filesystem::path filepath(PathConfig::getConfigPath() / this->filename_);
         if (!boost::filesystem::exists(filepath))
+        {
             // Try to get default one from the data folder
             boost::filesystem::path defaultFilepath(Core::getDataPath() / "defaultConfig" / this->filename_);
+            boost::filesystem::path defaultFilepath(PathConfig::getDataPath() / "defaultConfig" / this->filename_);
             if (boost::filesystem::exists(defaultFilepath))
+            {
 …
+    {
         std::ofstream file;
         file.open((Core::getConfigPathString() + filename_).c_str(), std::fstream::out);
+        file.open((PathConfig::getConfigPathString() + filename_).c_str(), std::fstream::out);
         file.setf(std::ios::fixed, std::ios::floatfield);
         file.precision(6);
 …
         for (std::list<ConfigFileSection*>::iterator it1 = this->sections_.begin(); it1 != this->sections_.end(); )
+        {
             std::map<std::string, Identifier*>::const_iterator it2 = Identifier::getIdentifierMap().find((*it1)->getName());
             if (it2 != Identifier::getIdentifierMapEnd() && (*it2).second->hasConfigValues())
+            std::map<std::string, Identifier*>::const_iterator it2 = Identifier::getStringIdentifierMap().find((*it1)->getName());
+            if (it2 != Identifier::getStringIdentifierMapEnd() && (*it2).second->hasConfigValues())
+            {
                 // The section exists, delete comment
 …
         if (this->type_ == ConfigFileType::Settings)
+        {
             for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getIdentifierMapBegin(); it != Identifier::getIdentifierMapEnd(); ++it)
+            for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapBegin(); it != Identifier::getStringIdentifierMapEnd(); ++it)
+            {
                 if (it->second->hasConfigValues())

code/branches/pickup/src/libraries/core/Core.cc

-                      r5781
+                      r5935
 #include <cassert>
+#include <fstream>
+#include <cstdlib>
+#include <cstdio>
+#include <boost/version.hpp>
+#include <boost/filesystem.hpp>
+#include <vector>
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
 #  undef min
 #  undef max
-#elif defined(ORXONOX_PLATFORM_APPLE)
-#  include <sys/param.h>
-#  include <mach-o/dyld.h>
-#else /* Linux */
-#  include <sys/types.h>
-#  include <unistd.h>
 #endif
 #include "SpecialConfig.h"
+#include "util/Clock.h"
 #include "util/Debug.h"
 #include "util/Exception.h"
 #include "util/SignalHandler.h"
 #include "Clock.h"
+#include "PathConfig.h"
 #include "CommandExecutor.h"
 #include "CommandLine.h"
 …
 #include "CoreIncludes.h"
 #include "DynLibManager.h"
-#include "Factory.h"
 #include "GameMode.h"
 #include "GraphicsManager.h"
 …
 #include "Language.h"
 #include "LuaState.h"
+#include "ScopedSingletonManager.h"
 #include "Shell.h"
 #include "TclBind.h"
 …
 #include "input/InputManager.h"
-// Boost 1.36 has some issues with deprecated functions that have been omitted
-#if (BOOST_VERSION == 103600)
-#  define BOOST_LEAF_FUNCTION filename
-#else
-#  define BOOST_LEAF_FUNCTION leaf
-#endif
 namespace orxonox
+{
 …
     Core* Core::singletonPtr_s  = 0;
-    SetCommandLineArgument(externalDataPath, "").information("Path to the external data files");
-    SetCommandLineOnlyArgument(writingPathSuffix, "").information("Additional subfolder for config and log files");
     SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
             RegisterRootObject(CoreConfiguration);
             this->setConfigValues();
-            // External data directory only exists for dev runs
-            if (Core::isDevelopmentRun())
+            {
-                // Possible data path override by the command line
-                if (!CommandLine::getArgument("externalDataPath")->hasDefaultValue())
-                    tsetExternalDataPath(CommandLine::getValue("externalDataPath"));
+            }
+        }
 …
+        }
-        /**
-        @brief
-            Temporary sets the external data path
-        @param path
-            The new data path
-        */
-        void tsetExternalDataPath(const std::string& path)
+        {
-            externalDataPath_ = boost::filesystem::path(path);
+        }
         void initializeRandomNumberGenerator()
+        {
 …
         std::string language_;                          //!< The language
         bool bInitializeRandomNumberGenerator_;         //!< If true, srand(time(0)) is called
-        //! Path to the parent directory of the ones above if program was installed with relativ pahts
-        boost::filesystem::path rootPath_;
-        boost::filesystem::path executablePath_;        //!< Path to the executable
-        boost::filesystem::path modulePath_;            //!< Path to the modules
-        boost::filesystem::path dataPath_;              //!< Path to the data file folder
-        boost::filesystem::path externalDataPath_;      //!< Path to the external data file folder
-        boost::filesystem::path configPath_;            //!< Path to the config file folder
-        boost::filesystem::path logPath_;               //!< Path to the log file folder
     };
 …
         , consoleCommandDestroyer_(CommandExecutor::destroyExternalCommands)
         , configuration_(new CoreConfiguration()) // Don't yet create config values!
-        , bDevRun_(false)
         , bGraphicsLoaded_(false)
+    {
         // Set the hard coded fixed paths
         this->setFixedPaths();
+        this->pathConfig_.reset(new PathConfig());
         // Create a new dynamic library manager
 …
         // Load modules
+        try
+        {
+            // We search for helper files with the following extension
+            std::string moduleextension = specialConfig::moduleExtension;
+            size_t moduleextensionlength = moduleextension.size();
+            // Search in the directory of our executable
+            boost::filesystem::path searchpath = this->configuration_->modulePath_;
+            // Add that path to the PATH variable in case a module depends on another one
+            std::string pathVariable = getenv("PATH");
+            putenv(const_cast<char*>(("PATH=" + pathVariable + ";" + configuration_->modulePath_.string()).c_str()));
+            boost::filesystem::directory_iterator file(searchpath);
+            boost::filesystem::directory_iterator end;
+            // Iterate through all files
+            while (file != end)
+        const std::vector<std::string>& modulePaths = this->pathConfig_->getModulePaths();
+        for (std::vector<std::string>::const_iterator it = modulePaths.begin(); it != modulePaths.end(); ++it)
+        {
+            try
+            {
+                std::string filename = file->BOOST_LEAF_FUNCTION();
+                // Check if the file ends with the exension in question
+                if (filename.size() > moduleextensionlength)
+                {
+                    if (filename.substr(filename.size() - moduleextensionlength) == moduleextension)
+                    {
+                        // We've found a helper file - now load the library with the same name
+                        std::string library = filename.substr(0, filename.size() - moduleextensionlength);
+                        boost::filesystem::path librarypath = searchpath / library;
+                        try
+                        {
+                            DynLibManager::getInstance().load(librarypath.string());
+                        }
+                        catch (...)
+                        {
+                            COUT(1) << "Couldn't load module \"" << librarypath.string() << "\": " << Exception::handleMessage() << std::endl;
+                        }
+                    }
+                }
+                ++file;
+                this->dynLibManager_->load(*it);
+            }
+        }
         catch (...)
+        {
             COUT(1) << "An error occurred while loading modules: " << Exception::handleMessage() << std::endl;
+            catch (...)
+            {
+                COUT(1) << "Couldn't load module \"" << *it << "\": " << Exception::handleMessage() << std::endl;
+            }
+        }
 …
         // Set configurable paths like log, config and media
         this->setConfigurablePaths();
+        this->pathConfig_->setConfigurablePaths();
         // create a signal handler (only active for linux)
         // This call is placed as soon as possible, but after the directories are set
         this->signalHandler_.reset(new SignalHandler());
         this->signalHandler_->doCatch(configuration_->executablePath_.string(), Core::getLogPathString() + "orxonox_crash.log");
+        this->signalHandler_->doCatch(PathConfig::getExecutablePathString(), PathConfig::getLogPathString() + "orxonox_crash.log");
         // Set the correct log path. Before this call, /tmp (Unix) or %TEMP% was used
         OutputHandler::getOutStream().setLogPath(Core::getLogPathString());
+        OutputHandler::getOutStream().setLogPath(PathConfig::getLogPathString());
         // Parse additional options file now that we know its path
 …
         // creates the class hierarchy for all classes with factories
         Factory::createClassHierarchy();
+        Identifier::createClassHierarchy();
         // Do this soon after the ConfigFileManager has been created to open up the
 …
         // initialise Tcl
         this->tclBind_.reset(new TclBind(Core::getDataPathString()));
+        this->tclBind_.reset(new TclBind(PathConfig::getDataPathString()));
         this->tclThreadManager_.reset(new TclThreadManager(tclBind_->getTclInterpreter()));
         // create a shell
         this->shell_.reset(new Shell());
+        // Create singletons that always exist (in other libraries)
+        this->rootScope_.reset(new Scope<ScopeID::Root>());
+    }
 …
         inputManager_.reset(new InputManager());
         // load the CEGUI interface
+        // Load the CEGUI interface
         guiManager_.reset(new GUIManager(graphicsManager_->getRenderWindow(),
             inputManager_->getMousePosition(), graphicsManager_->isFullScreen()));
+        bGraphicsLoaded_ = true;
+        GameMode::bShowsGraphics_s = true;
+        // Load some sort of a debug overlay (only denoted by its name, "debug.oxo")
+        graphicsManager_->loadDebugOverlay();
+        // Create singletons associated with graphics (in other libraries)
+        graphicsScope_.reset(new Scope<ScopeID::Graphics>());
         unloader.Dismiss();
-        bGraphicsLoaded_ = true;
+    }
     void Core::unloadGraphics()
+    {
+        this->guiManager_.reset();;
+        this->inputManager_.reset();;
+        this->graphicsScope_.reset();
+        this->guiManager_.reset();
+        this->inputManager_.reset();
         this->graphicsManager_.reset();
 …
         bGraphicsLoaded_ = false;
+        GameMode::bShowsGraphics_s = false;
+    }
 …
+    }
-    /*static*/ void Core::tsetExternalDataPath(const std::string& path)
+    {
-        getInstance().configuration_->tsetExternalDataPath(path);
+    }
-    /*static*/ const boost::filesystem::path& Core::getDataPath()
+    {
-        return getInstance().configuration_->dataPath_;
+    }
-    /*static*/ std::string Core::getDataPathString()
+    {
-        return getInstance().configuration_->dataPath_.string() + '/';
+    }
-    /*static*/ const boost::filesystem::path& Core::getExternalDataPath()
+    {
-        return getInstance().configuration_->externalDataPath_;
+    }
-    /*static*/ std::string Core::getExternalDataPathString()
+    {
-        return getInstance().configuration_->externalDataPath_.string() + '/';
+    }
-    /*static*/ const boost::filesystem::path& Core::getConfigPath()
+    {
-        return getInstance().configuration_->configPath_;
+    }
-    /*static*/ std::string Core::getConfigPathString()
+    {
-        return getInstance().configuration_->configPath_.string() + '/';
+    }
-    /*static*/ const boost::filesystem::path& Core::getLogPath()
+    {
-        return getInstance().configuration_->logPath_;
+    }
-    /*static*/ std::string Core::getLogPathString()
+    {
-        return getInstance().configuration_->logPath_.string() + '/';
+    }
-    /*static*/ const boost::filesystem::path& Core::getRootPath()
+    {
-        return getInstance().configuration_->rootPath_;
+    }
-    /*static*/ std::string Core::getRootPathString()
+    {
-        return getInstance().configuration_->rootPath_.string() + '/';
+    }
     /**
     @note
 …
+    }
-    /**
-    @brief
-        Retrievs the executable path and sets all hard coded fixed path (currently only the module path)
-        Also checks for "orxonox_dev_build.keep_me" in the executable diretory.
-        If found it means that this is not an installed run, hence we
-        don't write the logs and config files to ~/.orxonox
-    @throw
-        GeneralException
-    */
-    void Core::setFixedPaths()
+    {
-        //////////////////////////
-        // FIND EXECUTABLE PATH //
-        //////////////////////////
-#ifdef ORXONOX_PLATFORM_WINDOWS
-        // get executable module
-        TCHAR buffer[1024];
-        if (GetModuleFileName(NULL, buffer, 1024) == 0)
-            ThrowException(General, "Could not retrieve executable path.");
-#elif defined(ORXONOX_PLATFORM_APPLE)
-        char buffer[1024];
-        unsigned long path_len = 1023;
-        if (_NSGetExecutablePath(buffer, &path_len))
-            ThrowException(General, "Could not retrieve executable path.");
-#else /* Linux */
-        /* written by Nicolai Haehnle <prefect_@gmx.net> */
-        /* Get our PID and build the name of the link in /proc */
-        char linkname[64]; /* /proc/<pid>/exe */
-        if (snprintf(linkname, sizeof(linkname), "/proc/%i/exe", getpid()) < 0)
+        {
-            /* This should only happen on large word systems. I'm not sure
-               what the proper response is here.
-               Since it really is an assert-like condition, aborting the
-               program seems to be in order. */
-            assert(false);
+        }
-        /* Now read the symbolic link */
-        char buffer[1024];
-        int ret;
-        ret = readlink(linkname, buffer, 1024);
-        /* In case of an error, leave the handling up to the caller */
-        if (ret == -1)
-            ThrowException(General, "Could not retrieve executable path.");
-        /* Ensure proper NUL termination */
-        buffer[ret] = 0;
-#endif
-        configuration_->executablePath_ = boost::filesystem::path(buffer);
-#ifndef ORXONOX_PLATFORM_APPLE
-        configuration_->executablePath_ = configuration_->executablePath_.branch_path(); // remove executable name
-#endif
-        /////////////////////
-        // SET MODULE PATH //
-        /////////////////////
-        if (boost::filesystem::exists(configuration_->executablePath_ / "orxonox_dev_build.keep_me"))
+        {
-            COUT(1) << "Running from the build tree." << std::endl;
-            Core::bDevRun_ = true;
-            configuration_->modulePath_ = specialConfig::moduleDevDirectory;
+        }
-        else
+        {
-#ifdef INSTALL_COPYABLE // --> relative paths
-            // Also set the root path
-            boost::filesystem::path relativeExecutablePath(specialConfig::defaultRuntimePath);
-            configuration_->rootPath_ = configuration_->executablePath_;
-            while (!boost::filesystem::equivalent(configuration_->rootPath_ / relativeExecutablePath, configuration_->executablePath_)
-                   && !configuration_->rootPath_.empty())
-                configuration_->rootPath_ = configuration_->rootPath_.branch_path();
-            if (configuration_->rootPath_.empty())
-                ThrowException(General, "Could not derive a root directory. Might the binary installation directory contain '..' when taken relative to the installation prefix path?");
-            // Module path is fixed as well
-            configuration_->modulePath_ = configuration_->rootPath_ / specialConfig::defaultModulePath;
-#else
-            // There is no root path, so don't set it at all
-            // Module path is fixed as well
-            configuration_->modulePath_ = specialConfig::moduleInstallDirectory;
-#endif
+        }
+    }
-    /**
-    @brief
-        Sets config, log and media path and creates folders if necessary.
-    @throws
-        GeneralException
-    */
-    void Core::setConfigurablePaths()
+    {
-        if (Core::isDevelopmentRun())
+        {
-            configuration_->dataPath_  = specialConfig::dataDevDirectory;
-            configuration_->externalDataPath_ = specialConfig::externalDataDevDirectory;
-            configuration_->configPath_ = specialConfig::configDevDirectory;
-            configuration_->logPath_    = specialConfig::logDevDirectory;
+        }
-        else
+        {
-#ifdef INSTALL_COPYABLE // --> relative paths
-            // Using paths relative to the install prefix, complete them
-            configuration_->dataPath_   = configuration_->rootPath_ / specialConfig::defaultDataPath;
-            configuration_->configPath_ = configuration_->rootPath_ / specialConfig::defaultConfigPath;
-            configuration_->logPath_    = configuration_->rootPath_ / specialConfig::defaultLogPath;
-#else
-            configuration_->dataPath_  = specialConfig::dataInstallDirectory;
-            // Get user directory
-#  ifdef ORXONOX_PLATFORM_UNIX /* Apple? */
-            char* userDataPathPtr(getenv("HOME"));
-#  else
-            char* userDataPathPtr(getenv("APPDATA"));
-#  endif
-            if (userDataPathPtr == NULL)
-                ThrowException(General, "Could not retrieve user data path.");
-            boost::filesystem::path userDataPath(userDataPathPtr);
-            userDataPath /= ".orxonox";
-            configuration_->configPath_ = userDataPath / specialConfig::defaultConfigPath;
-            configuration_->logPath_    = userDataPath / specialConfig::defaultLogPath;
-#endif
+        }
-        // Option to put all the config and log files in a separate folder
-        if (!CommandLine::getArgument("writingPathSuffix")->hasDefaultValue())
+        {
-            std::string directory(CommandLine::getValue("writingPathSuffix").getString());
-            configuration_->configPath_ = configuration_->configPath_ / directory;
-            configuration_->logPath_    = configuration_->logPath_    / directory;
+        }
-        // Create directories to avoid problems when opening files in non existent folders.
-        std::vector<std::pair<boost::filesystem::path, std::string> > directories;
-        directories.push_back(std::make_pair(boost::filesystem::path(configuration_->configPath_), "config"));
-        directories.push_back(std::make_pair(boost::filesystem::path(configuration_->logPath_), "log"));
-        for (std::vector<std::pair<boost::filesystem::path, std::string> >::iterator it = directories.begin();
-            it != directories.end(); ++it)
+        {
-            if (boost::filesystem::exists(it->first) && !boost::filesystem::is_directory(it->first))
+            {
-                ThrowException(General, std::string("The ") + it->second + " directory has been preoccupied by a file! \
-                                         Please remove " + it->first.string());
+            }
-            if (boost::filesystem::create_directories(it->first)) // function may not return true at all (bug?)
+            {
-                COUT(4) << "Created " << it->second << " directory" << std::endl;
+            }
+        }
+    }
     void Core::preUpdate(const Clock& time)
+    {
+        // singletons from other libraries
+        ScopedSingletonManager::update<ScopeID::Root>(time);
         if (this->bGraphicsLoaded_)
+        {
 …
             // process gui events
             this->guiManager_->update(time);
+            // graphics singletons from other libraries
+            ScopedSingletonManager::update<ScopeID::Graphics>(time);
+        }
         // process thread commands

code/branches/pickup/src/libraries/core/Core.h

-                      r5781
+                      r5935
  */
-/**
-@file
-@brief
-    Declaration of the Core class.
-@details
-    The Core class is a singleton, only used to configure some variables
-    in the core through the config-file.
-*/
 #ifndef _Core_H__
 #define _Core_H__
 …
 #include <boost/scoped_ptr.hpp>
 #include "util/OutputHandler.h"
+#include "util/Scope.h"
 #include "util/ScopeGuard.h"
 #include "util/Singleton.h"
 …
     @brief
         The Core class is a singleton used to configure the program basics.
-    @details
-        The class provides information about the data, config and log path.
-        It determines those by the use of platform specific functions.
     @remark
         You should only create this singleton once because it destroys the identifiers!
 …
             static void  resetLanguage();
-            static void tsetExternalDataPath(const std::string& path);
-            //! Returns the path to the data files as boost::filesystem::path
-            static const boost::filesystem::path& getDataPath();
-            //! Returns the path to the external data files as boost::filesystem::path
-            static const boost::filesystem::path& getExternalDataPath();
-            //! Returns the path to the config files as boost::filesystem::path
-            static const boost::filesystem::path& getConfigPath();
-            //! Returns the path to the log files as boost::filesystem::path
-            static const boost::filesystem::path& getLogPath();
-            //! Returns the path to the root folder as boost::filesystem::path
-            static const boost::filesystem::path& getRootPath();
-            //! Returns the path to the data files as std::string
-            static std::string getDataPathString();
-            //! Returns the path to the external data files as std::string
-            static std::string getExternalDataPathString();
-            //! Returns the path to the config files as std::string
-            static std::string getConfigPathString();
-            //! Returns the path to the log files as std::string
-            static std::string getLogPathString();
-            //! Returns the path to the root folder as std::string
-            static std::string getRootPathString();
-            static bool isDevelopmentRun() { return getInstance().bDevRun_; }
         private:
             Core(const Core&); //!< Don't use (undefined symbol)
 …
             void unloadGraphics();
-            void setFixedPaths();
-            void setConfigurablePaths();
             void setThreadAffinity(int limitToCPU);
             // Mind the order for the destruction!
+            scoped_ptr<PathConfig>        pathConfig_;
             scoped_ptr<DynLibManager>     dynLibManager_;
             scoped_ptr<SignalHandler>     signalHandler_;
 …
             scoped_ptr<InputManager>      inputManager_;        //!< Interface to OIS
             scoped_ptr<GUIManager>        guiManager_;          //!< Interface to GUI
+            scoped_ptr<Scope<ScopeID::Root> >     rootScope_;
+            scoped_ptr<Scope<ScopeID::Graphics> > graphicsScope_;
-            bool                          bDevRun_;             //!< True for runs in the build directory (not installed)
             bool                          bGraphicsLoaded_;
             static Core* singletonPtr_s;
     };

code/branches/pickup/src/libraries/core/CoreIncludes.h

-                      r5781
+                      r5935
 /**
     @file
     @brief Definition of macros for Identifier and Factory.
+    @brief Definition of macros for Identifiers
     Every class needs the RegisterObject(class) macro in its constructor. If the class is an interface
 …
 #include "util/Debug.h"
 #include "Identifier.h"
 #include "Factory.h"
+#include "SubclassIdentifier.h"
 #include "ClassFactory.h"
 #include "ObjectList.h"
 …
 /**
     @brief Creates the entry in the Factory.
+    @brief Creates the Factory.
     @param ClassName The name of the class
 */
 #define CreateFactory(ClassName) \
     bool bCreated##ClassName##Factory = orxonox::ClassFactory<ClassName>::create(#ClassName, true)
+    Factory* _##ClassName##Factory = new orxonox::ClassFactory<ClassName>(#ClassName, true)
 /**
     @brief Creates the entry in the Factory for classes which should not be loaded through XML.
+    @brief Creates the Factory for classes which should not be loaded through XML.
     @param ClassName The name of the class
 */
 #define CreateUnloadableFactory(ClassName) \
     bool bCreated##ClassName##Factory = orxonox::ClassFactory<ClassName>::create(#ClassName, false)
+    Factory* _##ClassName##Factory = new orxonox::ClassFactory<ClassName>(#ClassName, false)
 /**
 …
+{
     /**
         @brief Returns the Identifier with a given name through the factory.
+        @brief Returns the Identifier with a given name.
         @param String The name of the class
     */
     inline Identifier* ClassByString(const std::string& name)
+    {
         return Factory::getIdentifier(name);
+        return Identifier::getIdentifierByString(name);
+    }
     /**
+        @brief Returns the Identifier with a given network ID through the factory.
+        @brief Returns the Identifier with a given lowercase name.
+        @param String The lowercase name of the class
+    */
+    inline Identifier* ClassByLowercaseString(const std::string& name)
+    {
+        return Identifier::getIdentifierByLowercaseString(name);
+    }
+    /**
+        @brief Returns the Identifier with a given network ID.
         @param networkID The network ID of the class
     */
     inline Identifier* ClassByID(uint32_t id)
+    {
         return Factory::getIdentifier(id);
+        return Identifier::getIdentifierByID(id);
+    }
+}

code/branches/pickup/src/libraries/core/CorePrereqs.h

-                      r5738
+                      r5935
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the core library
 */
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined( CORE_STATIC_BUILD )
 #  ifdef CORE_SHARED_BUILD
 …
 #endif
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+// Constants
+//-----------------------------------------------------------------------
+namespace orxonox
+{
+    static const uint32_t OBJECTID_UNKNOWN = static_cast<uint32_t>(-1);
+}
+//-----------------------------------------------------------------------
+// Enums
+//-----------------------------------------------------------------------
 namespace orxonox
+{
 …
         enum Mode
+        {
+            NOP,
             LoadObject,
             SaveObject,
 …
         };
     };
+}
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+namespace orxonox
+{
     typedef std::string LanguageEntryLabel;
     class ArgumentCompleter;
     class ArgumentCompletionListElement;
-    class BaseFactory;
-    class BaseMetaObjectListElement;
     class BaseObject;
     template <class T>
 …
     class ClassTreeMaskNode;
     class ClassTreeMaskObjectIterator;
-    class Clock;
     class CommandEvaluation;
-    class CommandExecutor;
     class CommandLine;
     class CommandLineArgument;
 …
     class ConfigFileManager;
     class ConfigFileSection;
+    struct ConfigFileType;
     class ConfigValueContainer;
     class ConsoleCommand;
 …
     class DynLibManager;
     struct Event;
     class EventContainer;
+    class EventState;
     class Executor;
     template <class T>
 …
     class FunctorMember;
     class FunctorStatic;
+    class Game;
+    class GameState;
+    struct GameStateInfo;
+    struct GameStateTreeNode;
     class GraphicsManager;
     class GUIManager;
 …
     template <class T>
     class Iterator;
-    class IteratorBase;
     class Language;
-    class LanguageEntry;
-    class Loader;
     class LuaState;
     class MemoryArchive;
 …
     class OgreWindowEventListener;
     class OrxonoxClass;
+    class PathConfig;
     struct ResourceInfo;
     class Shell;
     class ShellListener;
     template <class T>
+    class SmartPtr;
+    template <class T>
     class SubclassIdentifier;
     class TclBind;
 …
     class TclThreadManager;
     class Template;
+    class Thread;
+    class ThreadPool;
+    template <class T>
+    class WeakPtr;
     class WindowEventListener;
     class XMLFile;
 …
     class XMLPortParamContainer;
+    // game states
+    class Game;
+    class GameState;
+    struct GameStateInfo;
+    struct GameStateTreeNode;
+    // input
+    // Input
     class BaseCommand;
     class BufferedParamCommand;
     class Button;
-    class CalibratorCallback;
     class HalfAxis;
     class InputBuffer;
 …
     class InputManager;
     class InputState;
+    struct InputStatePriority;
+    class JoyStickQuantityListener;
     class JoyStick;
+    class KeyBinder;
+    class KeyBinderManager;
+    class Keyboard;
+    class KeyDetector;
+    class KeyEvent;
     class Mouse;
-    class Keyboard;
-    class KeyBinder;
-    class KeyDetector;
     class ParamCommand;
     class SimpleCommand;
-    // multithreading
-    class Thread;
-    class ThreadPool;
+}
 …
 namespace orxonox
+{
-    using ticpp::Document;
     using ticpp::Element;
+    using ticpp::Declaration;
+    using ticpp::StylesheetReference;
+    using ticpp::Text;
+    using ticpp::Comment;
+    using ticpp::Attribute;
+}
+}
 #endif /* _CorePrereqs_H__ */

code/branches/pickup/src/libraries/core/Event.cc

-                      r5781
+                      r5935
 #include "BaseObject.h"
 #include "Executor.h"
+#include "Identifier.h"
 namespace orxonox
+{
+    EventContainer::~EventContainer()
+    /**
+        @brief Destructor: Deletes the functor of the event state.
+    */
+    EventState::~EventState()
+    {
+        delete this->eventfunction_;
+        if (this->statefunction_)
+            delete this->statefunction_;
+    }
+    void EventContainer::process(BaseObject* object, const Event& event)
+    /**
+        @brief Processes an event (calls the set-function if the necessary conditions are met).
+        @param event     The fired event
+        @param object    The object whose state is affected by the event (only needed for debug output)
+    */
+    void EventState::process(const Event& event, BaseObject* object)
+    {
         if (this->bActive_)
+        if (this->bProcessingEvent_)
+        {
             COUT(2) << "Warning: Detected Event loop in section \"" << this->eventname_ << "\" of object \"" << object->getName() << "\" and fired by \"" << event.originator_->getName() << "\"" << std::endl;
+            COUT(2) << "Warning: Detected Event loop in section \"" << event.statename_ << "\" of object \"" << object->getName() << "\" and fired by \"" << event.originator_->getName() << "\"" << std::endl;
             return;
+        }
         this->bActive_ = true;
+        this->bProcessingEvent_ = true;
+        if (this->eventname_ == event.sectionname_)
+        // check if the originator is an instance of the requested class
+        if (event.originator_->isA(this->subclass_))
+        {
+            if (event.originator_->isA(this->subclass_))
+            // actualize the activationcounter
+            if (event.activate_)
+                ++this->activeEvents_;
+            else
+            {
+                if (event.activate_)
+                    ++this->activeEvents_;
+                else
+                --this->activeEvents_;
+                if (this->activeEvents_ < 0)
+                    this->activeEvents_ = 0;
+            }
+            if (this->statefunction_->getParamCount() == 0 && event.activate_)
+            {
+                // if the eventfunction doesn't have a state, just call it whenever an activation-event comes in
+                (*this->statefunction_)();
+            }
+            else if ((this->activeEvents_ == 1 && event.activate_) || (this->activeEvents_ == 0 && !event.activate_))
+            {
+                // if the eventfunction needs a state, we just call the function if the state changed from 0 to 1 (state = true) or from 1 to 0 (state = false) [but not if activeEvents_ is > 1]
+                if (this->statefunction_->getParamCount() == 1)
+                {
+                    --this->activeEvents_;
+                    if (this->activeEvents_ < 0)
+                        this->activeEvents_ = 0;
+                    // one argument: just the eventstate
+                    (*this->statefunction_)(this->activeEvents_);
+                }
+                if (this->eventfunction_->getParamCount() == 0 && event.activate_)
+                    (*this->eventfunction_)();
+                else if ((this->activeEvents_ == 1 && event.activate_) || (this->activeEvents_ == 0 && !event.activate_))
+                else if (this->statefunction_->getParamCount() >= 2)
+                {
+                    if (this->eventfunction_->getParamCount() == 1)
+                        (*this->eventfunction_)(this->activeEvents_);
+                    else if (this->eventfunction_->getParamCount() >= 2 && event.castedOriginator_)
+                        (*this->eventfunction_)(this->activeEvents_, event.castedOriginator_);
+                    // two arguments: the eventstate and the originator
+                    if (this->subclass_->isExactlyA(ClassIdentifier<BaseObject>::getIdentifier()))
+                    {
+                        // if the subclass is BaseObject, we don't have to cast the pointer
+                        (*this->statefunction_)(this->activeEvents_, event.originator_);
+                    }
+                    else
+                    {
+                        // else cast the pointer to the desired class
+                        void* castedOriginator = event.originator_->getDerivedPointer(this->subclass_->getClassID());
+                        (*this->statefunction_)(this->activeEvents_, castedOriginator);
+                    }
+                }
+            }
+        }
         this->bActive_ = false;
+        this->bProcessingEvent_ = false;
+    }
+}

code/branches/pickup/src/libraries/core/Event.h

-                      r5781
+                      r5935
 namespace orxonox
+{
+    /**
+        @brief The Event struct contains information about a fired Event.
+    */
     struct _CoreExport Event
+    {
             Event(bool activate, BaseObject* originator) : activate_(activate), originator_(originator), castedOriginator_(0) {}
+        Event(bool activate, BaseObject* originator, const std::string& name) : activate_(activate), originator_(originator), name_(name) {}
             bool        activate_;
             BaseObject* originator_;
             void*       castedOriginator_;
             std::string sectionname_;
+        bool        activate_;   //!< True if this is an activating event (the event source was inactive before and just triggered the event) - false otherwise
+        std::string statename_;  //!< The name of the state this event affects
+        BaseObject* originator_; //!< The object which triggered this event
+        std::string name_;       //!< The name of this event
     };
+    class _CoreExport EventContainer
+    /**
+        @brief The EventState contains information about an event state.
+        An event state is a state of an object, which can be changed by events.
+        Event states are changed through functions. Possible functions headers for set event states are:
+         - memoryless state: function()
+         - boolean state:    function(bool state)
+         - individual state: function(bool state, SomeClass originator)
+        Note that SomeClass may be any class deriving from BaseObject. You will not receive events from originators of other classes.
+        The actual class for SomeClass must be specified as the second argument of the XMLPortEventState macro.
+        The this pointer of the affected object is hidden in the functors, because the events are processed in the BaseObject, but some
+        statefunctions may be from child-classes.
+    */
+    class _CoreExport EventState
+    {
         public:
             EventContainer(const std::string& eventname, Executor* eventfunction, Identifier* subclass) : bActive_(false), eventname_(eventname), eventfunction_(eventfunction), subclass_(subclass), activeEvents_(0) {}
             virtual ~EventContainer();
+            EventState(Functor* statefunction, Identifier* subclass) : bProcessingEvent_(false), activeEvents_(0), statefunction_(statefunction), subclass_(subclass) {}
+            virtual ~EventState();
+            void process(BaseObject* object, const Event& event);
+            void process(const Event& event, BaseObject* object);
+            Functor* getFunctor() const
+                { return this->statefunction_; }
         private:
+            bool bActive_;
+            std::string eventname_;
+            Executor* eventfunction_;
+            Identifier* subclass_;
+            int activeEvents_;
+            bool        bProcessingEvent_;  //!< This becomes true while the container processes an event (used to prevent loops)
+            int         activeEvents_;      //!< The number of events which affect this state and are currently active
+            Functor*    statefunction_;     //!< A functor to set the state
+            Identifier* subclass_;          //!< Originators must be an instance of this class (usually BaseObject, but some statefunctions allow a second argument with an originator of a specific class)
     };
+}

code/branches/pickup/src/libraries/core/EventIncludes.h

-                      r5781
+                      r5935
 #include "CorePrereqs.h"
 #include "Executor.h"
+#include "XMLPort.h"
+#define ORXONOX_SET_EVENT(classname, eventname, functionname, event) \
+    ORXONOX_SET_EVENT_GENERIC(eventcontainer##classname##functionname, classname, eventname, functionname, event, BaseObject)
+/**
+    @brief Defines a new event state (a state of the object which can be changed by events).
+    @param classname    The name of this class
+    @param subclassname Usually BaseObject - if different, only instances of this class can send events to this object
+    @param statename    The name (string) of this state
+    @param function     The function which should be used to set the state
+    @param xmlelement   Argument for XMLPort
+    @param mode         Argument for XMLPort
+*/
+#define XMLPortEventState(classname, subclassname, statename, function, xmlelement, mode) \
+    orxonox::EventState* containername##function = this->getEventState(statename); \
+    if (!containername##function) \
+    { \
+        containername##function = new orxonox::EventState(orxonox::createFunctor(&classname::function, this), orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
+        this->addEventState(statename, containername##function); \
+    } \
+    XMLPortEventStateIntern(xmlportevent##function, classname, statename, xmlelement, mode)
+#define ORXONOX_SET_EVENT_TEMPLATE(classname, eventname, functionname, event, ...) \
+    ORXONOX_SET_EVENT_GENERIC_TEMPLATE(eventcontainer##classname##functionname, classname, eventname, functionname, event, BaseObject, __VA_ARGS__)
+/**
+    @brief Like XMLPortEventState but with additional template arguments to identify the function of the state (if ambiguous).
+*/
+#define XMLPortEventStateTemplate(classname, subclassname, statename, function, xmlelement, mode, ...) \
+    orxonox::EventState* containername##function = this->getEventState(statename); \
+    if (!containername##function) \
+    { \
+        containername##function = new orxonox::EventState(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::function, this), orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
+        this->addEventState(statename, containername##function); \
+    } \
+    XMLPortEventStateIntern(xmlportevent##function, classname, statename, xmlelement, mode)
+#define ORXONOX_SET_SUBCLASS_EVENT(classname, eventname, functionname, event, subclassname) \
+    ORXONOX_SET_EVENT_GENERIC(eventcontainer##classname##functionname, classname, eventname, functionname, event, subclassname)
+#define XMLPortEventStateIntern(name, classname, statename, xmlelement, mode) \
+    static orxonox::ExecutorMember<classname>* xmlsetfunctor##name = (orxonox::ExecutorMember<classname>*)&orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + "(" + statename + ")")->setDefaultValue(1, statename); \
+    static orxonox::ExecutorMember<classname>* xmlgetfunctor##name = (orxonox::ExecutorMember<classname>*)&orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + "(" + statename + ")")->setDefaultValue(1, statename); \
+    XMLPortObjectGeneric(xmlport##name, classname, orxonox::BaseObject, statename, xmlsetfunctor##name, xmlgetfunctor##name, xmlelement, mode, false, true)
+#define ORXONOX_SET_SUBCLASS_EVENT_TEMPLATE(classname, eventname, functionname, event, subclassname, ...) \
+    ORXONOX_SET_EVENT_GENERIC_TEMPLATE(eventcontainer##classname##functionname, classname, eventname, functionname, event, subclassname, __VA_ARGS__)
+/**
+    @brief Defines a new event name for a class. Named events can only have names which were defined with this macro.
+    @param classname The name of the class
+    @param name      The name of the event
+*/
+#define CreateEventName(classname, name) \
+    static std::string eventname##classname##name = #name
+#define ORXONOX_SET_EVENT_GENERIC(containername, classname, eventname, functionname, event, subclassname) \
+    orxonox::EventContainer* containername = this->getEventContainer(eventname); \
+    if (!containername) \
+    { \
+        ExecutorMember<classname>* executor = orxonox::createExecutor(orxonox::createFunctor(&classname::functionname), std::string( #classname ) + "::" + #functionname); \
+        executor->setObject(this); \
+        containername = new orxonox::EventContainer(std::string(eventname), executor, orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
+        this->addEventContainer(eventname, containername); \
+    } \
+    event.castedOriginator_ = orxonox::orxonox_cast<subclassname*>(event.originator_); \
+    containername->process(this, event)
+#define ORXONOX_SET_EVENT_GENERIC_TEMPLATE(containername, classname, eventname, functionname, event, subclassname, ...) \
+    orxonox::EventContainer* containername = this->getEventContainer(eventname); \
+    if (!containername) \
+    { \
+        ExecutorMember<classname>* executor = orxonox::createExecutor(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::functionname), std::string( #classname ) + "::" + #functionname); \
+        executor->setObject(this); \
+        containername = new orxonox::EventContainer(std::string(eventname), executor, orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
+        this->addEventContainer(eventname, containername); \
+    } \
+    event.castedOriginator_ = orxonox::orxonox_cast<subclassname*>(event.originator_); \
+    containername->process(this, event)
+/**
+    @brief This macro is needed to fire an event with this name. The event name must previously be declared with @ref CreateEventName.
+*/
+#define FireEventName(classname, name) \
+    eventname##classname##name
 #endif /* _EventIncludes_H__ */

code/branches/pickup/src/libraries/core/Functor.h

-                      r5738
+                      r5935
+#define FUNCTOR_TEMPLATE(ismember, returnvalue, numparams) FUNCTOR_TEMPLATE##ismember##returnvalue##numparams
+#define FUNCTOR_TEMPLATE000
+#define FUNCTOR_TEMPLATE001 template <class P1>
+#define FUNCTOR_TEMPLATE002 template <class P1, class P2>
+#define FUNCTOR_TEMPLATE003 template <class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE004 template <class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE005 template <class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE010 template <class R>
+#define FUNCTOR_TEMPLATE011 template <class R, class P1>
+#define FUNCTOR_TEMPLATE012 template <class R, class P1, class P2>
+#define FUNCTOR_TEMPLATE013 template <class R, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE014 template <class R, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE015 template <class R, class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE100 template <class T>
+#define FUNCTOR_TEMPLATE101 template <class T, class P1>
+#define FUNCTOR_TEMPLATE102 template <class T, class P1, class P2>
+#define FUNCTOR_TEMPLATE103 template <class T, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE104 template <class T, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE105 template <class T, class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE110 template <class T, class R>
+#define FUNCTOR_TEMPLATE111 template <class T, class R, class P1>
+#define FUNCTOR_TEMPLATE112 template <class T, class R, class P1, class P2>
+#define FUNCTOR_TEMPLATE113 template <class T, class R, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE114 template <class T, class R, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE115 template <class T, class R, class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE(ismember, returnvalue, numparams, additionalobject) FUNCTOR_TEMPLATE##ismember##returnvalue##numparams(additionalobject)
+#define FUNCTOR_TEMPLATE000(additionalobject)
+#define FUNCTOR_TEMPLATE001(additionalobject) template <class P1>
+#define FUNCTOR_TEMPLATE002(additionalobject) template <class P1, class P2>
+#define FUNCTOR_TEMPLATE003(additionalobject) template <class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE004(additionalobject) template <class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE005(additionalobject) template <class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE010(additionalobject) template <class R>
+#define FUNCTOR_TEMPLATE011(additionalobject) template <class R, class P1>
+#define FUNCTOR_TEMPLATE012(additionalobject) template <class R, class P1, class P2>
+#define FUNCTOR_TEMPLATE013(additionalobject) template <class R, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE014(additionalobject) template <class R, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE015(additionalobject) template <class R, class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE100(additionalobject) template <class T FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE101(additionalobject) template <class T, class P1 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE102(additionalobject) template <class T, class P1, class P2 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE103(additionalobject) template <class T, class P1, class P2, class P3 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE104(additionalobject) template <class T, class P1, class P2, class P3, class P4 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE105(additionalobject) template <class T, class P1, class P2, class P3, class P4, class P5 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE110(additionalobject) template <class T, class R FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE111(additionalobject) template <class T, class R, class P1 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE112(additionalobject) template <class T, class R, class P1, class P2 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE113(additionalobject) template <class T, class R, class P1, class P2, class P3 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE114(additionalobject) template <class T, class R, class P1, class P2, class P3, class P4 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE115(additionalobject) template <class T, class R, class P1, class P2, class P3, class P4, class P5 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT##additionalobject
+#define FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT0
+#define FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT1 , class O
 …
 #define CREATE_STATIC_FUNCTOR(returnvalue, numparams) \
     FUNCTOR_TEMPLATE(0, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(0, returnvalue, numparams, 0) \
     class FunctorStatic##returnvalue##numparams : public FunctorStatic \
     { \
 …
+    \
+    \
     FUNCTOR_TEMPLATE(0, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(0, returnvalue, numparams, 0) \
     inline FunctorStatic##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(0, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
     { \
 …
 #define CREATE_MEMBER_FUNCTOR(returnvalue, numparams) \
     FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
     class FunctorMember##returnvalue##numparams : public FunctorMember<T> \
     { \
 …
+    \
+    \
     FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
     class FunctorConstMember##returnvalue##numparams : public FunctorMember<T> \
     { \
 …
+    \
+    \
     FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
     inline FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
     { \
 …
+    \
+    \
     FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
     inline FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const) \
     { \
         return new FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
+    } \
+    \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 1) \
+    inline FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)), O* object) \
+    { \
+        FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* functor = new FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
+        functor->setObject(object); \
+        return functor; \
+    } \
+    \
+    \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 1) \
+    inline FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const, O* object) \
+    { \
+        FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* functor = new FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
+        functor->setObject(object); \
+        return functor; \
+    }

code/branches/pickup/src/libraries/core/GUIManager.cc

-                      r5781
+                      r5935
 #endif
+#include "util/Clock.h"
 #include "util/Debug.h"
 #include "util/Exception.h"
 #include "util/OrxAssert.h"
 #include "Core.h"
-#include "Clock.h"
 #include "LuaState.h"
+#include "PathConfig.h"
 #include "Resource.h"
 …
+    {
     public:
             void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
+        void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
+        {
             int orxonoxLevel = CEGUI::Standard;
 …
         : renderWindow_(renderWindow)
         , resourceProvider_(0)
+        , camera_(NULL)
+    {
         using namespace CEGUI;
 …
         // Create our own logger to specify the filepath
         std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
         ceguiLogger->setLogFilename(Core::getLogPathString() + "cegui.log");
+        ceguiLogger->setLogFilename(PathConfig::getLogPathString() + "cegui.log");
         // set the log level according to ours (translate by subtracting 1)
         ceguiLogger->setLoggingLevel(
 …
     void GUIManager::setCamera(Ogre::Camera* camera)
+    {
+        this->camera_ = camera;
         if (camera == NULL)
             this->guiRenderer_->setTargetSceneManager(0);

code/branches/pickup/src/libraries/core/GUIManager.h

-                      r5781
+                      r5935
         void setCamera(Ogre::Camera* camera);
+        Ogre::Camera* getCamera() { return this->camera_; }
         static GUIManager* getInstancePtr() { return singletonPtr_s; }
 …
         CEGUI::Logger*                       ceguiLogger_;      //!< CEGUI's logger to be able to log CEGUI errors in our log
         std::map<std::string, PlayerInfo*>   players_;          //!< Stores the player (owner) for each gui
+        Ogre::Camera*                        camera_;           //!< Camera used to render the scene with the GUI
         static GUIManager*                   singletonPtr_s;    //!< Singleton reference to GUIManager

code/branches/pickup/src/libraries/core/Game.cc

-                      r5781
+                      r5935
 #include <boost/weak_ptr.hpp>
+#include "util/Clock.h"
 #include "util/Debug.h"
 #include "util/Exception.h"
 …
 #include "util/Sleep.h"
 #include "util/SubString.h"
-#include "Clock.h"
 #include "CommandLine.h"
 #include "ConsoleCommand.h"
 …
         { Game::getInstance().stop(); }
     SetConsoleCommandShortcutExternAlias(stop_game, "exit");
+    static void printFPS()
+        { COUT(0) << Game::getInstance().getAvgFPS() << std::endl; }
+    SetConsoleCommandShortcutExternAlias(printFPS, "printFPS");
+    static void printTickTime()
+        { COUT(0) << Game::getInstance().getAvgTickTime() << std::endl; }
+    SetConsoleCommandShortcutExternAlias(printTickTime, "printTickTime");
     std::map<std::string, GameStateInfo> Game::gameStateDeclarations_s;
 …
     Game::Game(const std::string& cmdLine)
         // Destroy factories before the Core!
         : gsFactoryDestroyer_(Game::GameStateFactory::factories_s, &std::map<std::string, shared_ptr<GameStateFactory> >::clear)
+        : gsFactoryDestroyer_(Game::GameStateFactory::getFactories(), &std::map<std::string, shared_ptr<GameStateFactory> >::clear)
+    {
         this->bAbort_ = false;
 …
                 requestedNodes.push_back(currentNode);
+            }
+            if (currentNode == NULL)
+                requestedNodes.clear();
+        }
 …
+    {
         // Split string into pieces of the form whitespacesText
         std::vector<std::pair<std::string, unsigned> > stateStrings;
+        std::vector<std::pair<std::string, int> > stateStrings;
         size_t pos = 0;
         size_t startPos = 0;
         while (pos < str.size())
+        {
             unsigned indentation = 0;
+            int indentation = 0;
             while(pos < str.size() && str[pos] == ' ')
                 ++indentation, ++pos;
 …
             stateStrings.push_back(std::make_pair(str.substr(startPos, pos - startPos), indentation));
+        }
+        unsigned int currentLevel = 0;
+        shared_ptr<GameStateTreeNode> currentNode = this->rootStateNode_;
+        for (std::vector<std::pair<std::string, unsigned> >::const_iterator it = stateStrings.begin(); it != stateStrings.end(); ++it)
+        {
+            std::string newStateName = it->first;
+            unsigned newLevel = it->second + 1; // empty root is 0
+            if (!this->checkState(newStateName))
+                ThrowException(GameState, "GameState with name '" << newStateName << "' not found!");
+            if (newStateName == this->rootStateNode_->name_)
+        if (stateStrings.empty())
+            ThrowException(GameState, "Emtpy GameState hierarchy provided, terminating.");
+        // Add element with large identation to detect the last with just an iterator
+        stateStrings.push_back(std::make_pair("", -1));
+        // Parse elements recursively
+        std::vector<std::pair<std::string, int> >::const_iterator begin = stateStrings.begin();
+        parseStates(begin, this->rootStateNode_);
+    }
+    /*** Internal ***/
+    void Game::parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode)
+    {
+        SubString tokens(it->first, ",");
+        std::vector<std::pair<std::string, int> >::const_iterator startIt = it;
+        for (unsigned int i = 0; i < tokens.size(); ++i)
+        {
+            it = startIt; // Reset iterator to the beginning of the sub tree
+            if (!this->checkState(tokens[i]))
+                ThrowException(GameState, "GameState with name '" << tokens[i] << "' not found!");
+            if (tokens[i] == this->rootStateNode_->name_)
                 ThrowException(GameState, "You shouldn't use 'emptyRootGameState' in the hierarchy...");
+            shared_ptr<GameStateTreeNode> newNode(new GameStateTreeNode);
+            newNode->name_ = newStateName;
+            if (newLevel <= currentLevel)
+            {
+                do
+                    currentNode = currentNode->parent_.lock();
+                while (newLevel <= --currentLevel);
+            }
+            if (newLevel == currentLevel + 1)
+            {
+                // Add the child
+                newNode->parent_ = currentNode;
+                currentNode->children_.push_back(newNode);
+            }
+            else
+                ThrowException(GameState, "Indentation error while parsing the hierarchy.");
+            currentNode = newNode;
+            currentLevel = newLevel;
+        }
+    }
+    /*** Internal ***/
+            shared_ptr<GameStateTreeNode> node(new GameStateTreeNode());
+            node->name_ = tokens[i];
+            node->parent_ = currentNode;
+            currentNode->children_.push_back(node);
+            int currentLevel = it->second;
+            ++it;
+            while (it->second != -1)
+            {
+                if (it->second <= currentLevel)
+                    break;
+                else if (it->second == currentLevel + 1)
+                    parseStates(it, node);
+                else
+                    ThrowException(GameState, "Indentation error while parsing the hierarchy.");
+            }
+        }
+    }
     void Game::loadGraphics()
+    {
         if (!GameMode::bShowsGraphics_s)
+        if (!GameMode::showsGraphics())
+        {
             core_->loadGraphics();
             Loki::ScopeGuard graphicsUnloader = Loki::MakeObjGuard(*this, &Game::unloadGraphics);
-            GameMode::bShowsGraphics_s = true;
             // Construct all the GameStates that require graphics
 …
     void Game::unloadGraphics()
+    {
         if (GameMode::bShowsGraphics_s)
+        if (GameMode::showsGraphics())
+        {
             // Destroy all the GameStates that require graphics
 …
             core_->unloadGraphics();
-            GameMode::bShowsGraphics_s = false;
+        }
+    }
 …
+    }
+    std::map<std::string, shared_ptr<Game::GameStateFactory> > Game::GameStateFactory::factories_s;
+    /*static*/ std::map<std::string, shared_ptr<Game::GameStateFactory> >& Game::GameStateFactory::getFactories()
+    {
+        static std::map<std::string, shared_ptr<GameStateFactory> > factories;
+        return factories;
+    }
     /*static*/ shared_ptr<GameState> Game::GameStateFactory::fabricate(const GameStateInfo& info)
+    {
         std::map<std::string, shared_ptr<Game::GameStateFactory> >::const_iterator it = factories_s.find(info.className);
         assert(it != factories_s.end());
+        std::map<std::string, shared_ptr<Game::GameStateFactory> >::const_iterator it = getFactories().find(info.className);
+        assert(it != getFactories().end());
         return it->second->fabricateInternal(info);
+    }

code/branches/pickup/src/libraries/core/Game.h

-                      r5747
+                      r5935
             template <class T>
             static void createFactory(const std::string& className)
                 { factories_s[className].reset(new TemplateGameStateFactory<T>()); }
+                { getFactories()[className].reset(new TemplateGameStateFactory<T>()); }
             virtual shared_ptr<GameState> fabricateInternal(const GameStateInfo& info) = 0;
             static std::map<std::string, shared_ptr<GameStateFactory> > factories_s;
+            static std::map<std::string, shared_ptr<GameStateFactory> >& getFactories();
         };
         template <class T>
 …
         void unloadGraphics();
+        void parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode);
         bool checkState(const std::string& name) const;
         void loadState(const std::string& name);

code/branches/pickup/src/libraries/core/GameMode.cc

-                      r5781
+                      r5935
  */
-/**
-    @file
-    @brief Implementation of the GameMode class.
-*/
 #include "GameMode.h"
 …
+{
     bool GameMode::bShowsGraphics_s = false;
+    bool GameMode::bPlaysSound_s    = false;
     bool GameMode::bHasServer_s     = false;
     bool GameMode::bIsClient_s      = false;

code/branches/pickup/src/libraries/core/GameMode.h

-                      r5781
+                      r5935
     class _CoreExport GameMode
+    {
         friend class Game;
+        friend class Core;
         public:
             static bool showsGraphics() { return bShowsGraphics_s; }
+            static bool playsSound()    { return bPlaysSound_s; }
             static bool hasServer()     { return bHasServer_s; }
             static bool isClient()      { return bIsClient_s; }
 …
             static bool isMaster()      { return bIsMaster_s; }
+            static void setPlaysSound   (bool val) { bPlaysSound_s    = val; }
             static void setHasServer    (bool val) { bHasServer_s     = val; updateIsMaster(); }
             static void setIsClient     (bool val) { bIsClient_s      = val; updateIsMaster(); }
 …
             static bool bShowsGraphics_s;                   //!< global variable that tells whether to show graphics
+            static bool bPlaysSound_s;                      //!< global variable that tells whether to sound works
             static bool bHasServer_s;                       //!< global variable that tells whether this is a server
             static bool bIsClient_s;

code/branches/pickup/src/libraries/core/GameState.h

r5738	r5935
40	40	#include <map>
41	41	#include <string>
	42	#include "util/UtilPrereqs.h"
42	43
43	44	namespace orxonox

code/branches/pickup/src/libraries/core/GraphicsManager.cc

-                      r5781
+                      r5935
 #include "SpecialConfig.h"
+#include "util/Clock.h"
 #include "util/Exception.h"
 #include "util/StringUtils.h"
 #include "util/SubString.h"
-#include "Clock.h"
 #include "ConsoleCommand.h"
 #include "ConfigValueIncludes.h"
 #include "CoreIncludes.h"
-#include "Core.h"
 #include "Game.h"
 #include "GameMode.h"
 #include "Loader.h"
 #include "MemoryArchive.h"
+#include "PathConfig.h"
 #include "WindowEventListener.h"
 #include "XMLFile.h"
 …
         // At first, add the root paths of the data directories as resource locations
         Ogre::ResourceGroupManager::getSingleton().addResourceLocation(Core::getDataPathString(), "FileSystem", "dataRoot", false);
+        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getDataPathString(), "FileSystem", "dataRoot", false);
         // Load resources
         resources_.reset(new XMLFile("resources.oxr", "dataRoot"));
 …
         // Only for development runs
         if (Core::isDevelopmentRun())
+        {
             Ogre::ResourceGroupManager::getSingleton().addResourceLocation(Core::getExternalDataPathString(), "FileSystem", "externalDataRoot", false);
+        if (PathConfig::isDevelopmentRun())
+        {
+            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getExternalDataPathString(), "FileSystem", "externalDataRoot", false);
             extResources_.reset(new XMLFile("resources.oxr", "externalDataRoot"));
             extResources_->setLuaSupport(false);
 …
     GraphicsManager::~GraphicsManager()
+    {
+        Loader::unload(debugOverlay_.get());
         Ogre::WindowEventUtilities::removeWindowEventListener(renderWindow_, ogreWindowEventListener_.get());
         // TODO: Destroy the console command
+        // Undeclare the resources
+        Loader::unload(resources_.get());
+        if (PathConfig::isDevelopmentRun())
+            Loader::unload(extResources_.get());
+    }
 …
+        }
         boost::filesystem::path ogreConfigFilepath(Core::getConfigPath() / this->ogreConfigFile_);
         boost::filesystem::path ogreLogFilepath(Core::getLogPath() / this->ogreLogFile_);
+        boost::filesystem::path ogreConfigFilepath(PathConfig::getConfigPath() / this->ogreConfigFile_);
+        boost::filesystem::path ogreLogFilepath(PathConfig::getLogPath() / this->ogreLogFile_);
         // create a new logManager
 …
         // add console commands
+        FunctorMember<GraphicsManager>* functor1 = createFunctor(&GraphicsManager::printScreen);
+        ccPrintScreen_ = createConsoleCommand(functor1->setObject(this), "printScreen");
+        ccPrintScreen_ = createConsoleCommand(createFunctor(&GraphicsManager::printScreen, this), "printScreen");
         CommandExecutor::addConsoleCommandShortcut(ccPrintScreen_);
+    }
+    void GraphicsManager::loadDebugOverlay()
+    {
+        // Load debug overlay to show info about fps and tick time
+        COUT(4) << "Loading Debug Overlay..." << std::endl;
+        debugOverlay_.reset(new XMLFile("debug.oxo"));
+        Loader::open(debugOverlay_.get());
+    }
+    /**
+    @note
+        A note about the Ogre::FrameListener: Even though we don't use them,
+        they still get called. However, the delta times are not correct (except
+        for timeSinceLastFrame, which is the most important). A little research
+        as shown that there is probably only one FrameListener that doesn't even
+        need the time. So we shouldn't run into problems.
+    */
     void GraphicsManager::update(const Clock& time)
+    {
 …
         assert(this->renderWindow_);
         this->renderWindow_->writeContentsToTimestampedFile(Core::getLogPathString() + "screenShot_", ".jpg");
+        this->renderWindow_->writeContentsToTimestampedFile(PathConfig::getLogPathString() + "screenShot_", ".jpg");
+    }
+}

code/branches/pickup/src/libraries/core/GraphicsManager.h

-                      r5781
+                      r5935
         void upgradeToGraphics();
+        void loadDebugOverlay();
         bool rendererLoaded() const { return renderWindow_ != NULL; }
 …
         Ogre::Viewport*     viewport_;                 //!< default full size viewport
         // XML files for the resources
+        // XML files for the resources and the debug overlay
         shared_ptr<XMLFile> resources_;                //!< XML with resource locations
         shared_ptr<XMLFile> extResources_;             //!< XML with resource locations in the external path (only for dev runs)
+        shared_ptr<XMLFile> debugOverlay_;             //!< XML with various debug overlays
         // config values

code/branches/pickup/src/libraries/core/Identifier.cc

-                      r5781
+                      r5935
 #include "ConfigValueContainer.h"
 #include "ConsoleCommand.h"
 #include "Factory.h"
+#include "ClassFactory.h"
 #include "XMLPort.h"
 …
         this->bSetName_ = false;
         this->factory_ = 0;
         this->bLoadable_ = true;
+        this->bLoadable_ = false;
         this->bHasConfigValues_ = false;
         this->bHasConsoleCommands_ = false;
-        this->children_ = new std::set<const Identifier*>();
-        this->directChildren_ = new std::set<const Identifier*>();
         // Default network ID is the class ID
         this->networkID_ = this->classID_;
 …
     Identifier::~Identifier()
+    {
-        delete this->children_;
-        delete this->directChildren_;
         delete this->objects_;
 …
             // There is already an entry: return it and delete the proposal
             delete proposal;
             return (*it).second;
+            return it->second;
+        }
         else
 …
+            {
                 // Tell the parent we're one of it's children
                 (*it)->getChildrenIntern().insert((*it)->getChildrenIntern().end(), this);
+                (*it)->children_.insert((*it)->children_.end(), this);
                 // Erase all parents of our parent from our direct-parent-list
 …
+            {
                 // Tell the parent we're one of it's direct children
                 (*it)->getDirectChildrenIntern().insert((*it)->getDirectChildrenIntern().end(), this);
+                (*it)->directChildren_.insert((*it)->directChildren_.end(), this);
                 // Create the super-function dependencies
 …
     /**
+        @brief Creates the class-hierarchy by creating and destroying one object of each type.
+    */
+    void Identifier::createClassHierarchy()
+    {
+        COUT(3) << "*** Identifier: Create class-hierarchy" << std::endl;
+        Identifier::startCreatingHierarchy();
+        for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMap().begin(); it != Identifier::getStringIdentifierMap().end(); ++it)
+        {
+            // To create the new branch of the class-hierarchy, we create a new object and delete it afterwards.
+            if (it->second->hasFactory())
+            {
+                BaseObject* temp = it->second->fabricate(0);
+                temp->destroy();
+            }
+        }
+        Identifier::stopCreatingHierarchy();
+        COUT(3) << "*** Identifier: Finished class-hierarchy creation" << std::endl;
+    }
+    /**
         @brief Destroys all Identifiers. Called when exiting the program.
     */
 …
             this->name_ = name;
             this->bSetName_ = true;
+            Identifier::getIdentifierMapIntern()[name] = this;
+            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
+            Identifier::getStringIdentifierMapIntern()[name] = this;
+            Identifier::getLowercaseStringIdentifierMapIntern()[getLowercase(name)] = this;
+            Identifier::getIDIdentifierMapIntern()[this->networkID_] = this;
+        }
+    }
 …
             COUT(1) << "Aborting..." << std::endl;
             abort();
             return NULL;
+        }
+    }
     /**
         @brief Sets the network ID to a new value and changes the entry in the Factory.
+            return 0;
+        }
+    }
+    /**
+        @brief Sets the network ID to a new value and changes the entry in the ID-Identifier-map.
         @param id The new network ID
     */
     void Identifier::setNetworkID(uint32_t id)
+    {
+        Factory::changeNetworkID(this, this->networkID_, id);
+//        Identifier::getIDIdentifierMapIntern().erase(this->networkID_);
+        Identifier::getIDIdentifierMapIntern()[id] = this;
         this->networkID_ = id;
+    }
 …
     bool Identifier::isParentOf(const Identifier* identifier) const
+    {
         return (this->children_->find(identifier) != this->children_->end());
+        return (this->children_.find(identifier) != this->children_.end());
+    }
 …
     bool Identifier::isDirectParentOf(const Identifier* identifier) const
+    {
         return (this->directChildren_->find(identifier) != this->directChildren_->end());
+    }
     /**
         @brief Returns the map that stores all Identifiers.
+        return (this->directChildren_.find(identifier) != this->directChildren_.end());
+    }
+    /**
+        @brief Returns the map that stores all Identifiers with their names.
         @return The map
     */
     std::map<std::string, Identifier*>& Identifier::getIdentifierMapIntern()
+    std::map<std::string, Identifier*>& Identifier::getStringIdentifierMapIntern()
+    {
         static std::map<std::string, Identifier*> identifierMap;
 …
     /**
         @brief Returns the map that stores all Identifiers.
+        @brief Returns the map that stores all Identifiers with their names in lowercase.
         @return The map
     */
     std::map<std::string, Identifier*>& Identifier::getLowercaseIdentifierMapIntern()
+    std::map<std::string, Identifier*>& Identifier::getLowercaseStringIdentifierMapIntern()
+    {
         static std::map<std::string, Identifier*> lowercaseIdentifierMap;
         return lowercaseIdentifierMap;
+    }
+    /**
+        @brief Returns the map that stores all Identifiers with their network IDs.
+        @return The map
+    */
+    std::map<uint32_t, Identifier*>& Identifier::getIDIdentifierMapIntern()
+    {
+        static std::map<uint32_t, Identifier*> identifierMap;
+        return identifierMap;
+    }
+    /**
+        @brief Returns the Identifier with a given name.
+        @param name The name of the wanted Identifier
+        @return The Identifier
+    */
+    Identifier* Identifier::getIdentifierByString(const std::string& name)
+    {
+        std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapIntern().find(name);
+        if (it != Identifier::getStringIdentifierMapIntern().end())
+            return it->second;
+        else
+            return 0;
+    }
+    /**
+        @brief Returns the Identifier with a given name in lowercase.
+        @param name The name of the wanted Identifier
+        @return The Identifier
+    */
+    Identifier* Identifier::getIdentifierByLowercaseString(const std::string& name)
+    {
+        std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMapIntern().find(name);
+        if (it != Identifier::getLowercaseStringIdentifierMapIntern().end())
+            return it->second;
+        else
+            return 0;
+    }
+    /**
+        @brief Returns the Identifier with a given network ID.
+        @param id The network ID of the wanted Identifier
+        @return The Identifier
+    */
+    Identifier* Identifier::getIdentifierByID(const uint32_t id)
+    {
+        std::map<uint32_t, Identifier*>::const_iterator it = Identifier::getIDIdentifierMapIntern().find(id);
+        if (it != Identifier::getIDIdentifierMapIntern().end())
+            return it->second;
+        else
+            return 0;
+    }
+    /**
+        @brief Cleans the NetworkID map (needed on clients for correct initialization)
+    */
+    void Identifier::clearNetworkIDs()
+    {
+        Identifier::getIDIdentifierMapIntern().clear();
+    }
 …
         std::map<std::string, ConfigValueContainer*>::const_iterator it = configValues_.find(varname);
         if (it != configValues_.end())
             return ((*it).second);
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, ConfigValueContainer*>::const_iterator it = configValues_LC_.find(varname);
         if (it != configValues_LC_.end())
             return ((*it).second);
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, ConsoleCommand*>::const_iterator it = this->consoleCommands_.find(name);
         if (it != this->consoleCommands_.end())
             return (*it).second;
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, ConsoleCommand*>::const_iterator it = this->consoleCommands_LC_.find(name);
         if (it != this->consoleCommands_LC_.end())
             return (*it).second;
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, XMLPortParamContainer*>::const_iterator it = this->xmlportParamContainers_.find(paramname);
         if (it != this->xmlportParamContainers_.end())
             return ((*it).second);
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportObjectContainers_.find(sectionname);
         if (it != this->xmlportObjectContainers_.end())
             return ((*it).second);
+            return it->second;
         else
             return 0;
 …
         this->xmlportObjectContainers_[sectionname] = container;
+    }
-    /**
-        @brief Returns a XMLPortEventContainer that attaches an event to this class.
-        @param sectionname The name of the section that contains the event
-        @return The container
-    */
-    XMLPortObjectContainer* Identifier::getXMLPortEventContainer(const std::string& eventname)
+    {
-        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportEventContainers_.find(eventname);
-        if (it != this->xmlportEventContainers_.end())
-            return ((*it).second);
-        else
-            return 0;
+    }
-    /**
-        @brief Adds a new XMLPortEventContainer that attaches an event to this class.
-        @param sectionname The name of the section that contains the event
-        @param container The container
-    */
-    void Identifier::addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container)
+    {
-        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportEventContainers_.find(eventname);
-        if (it != this->xmlportEventContainers_.end())
+        {
-            COUT(2) << "Warning: Overwriting XMLPortEventContainer in class " << this->getName() << "." << std::endl;
-            delete (it->second);
+        }
-        this->xmlportEventContainers_[eventname] = container;
+    }
 …
+    {
         for (std::set<const Identifier*>::const_iterator it = list.begin(); it != list.end(); ++it)
+            out << (*it)->getName() << " ";
+        {
+            if (it != list.begin())
+                out << " ";
+            out << (*it)->getName();
+        }
         return out;

code/branches/pickup/src/libraries/core/Identifier.h

-                      r5781
+                      r5935
 /**
     @file
     @brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
+    @brief Definition of the Identifier class, definition and implementation of the ClassIdentifier class.
     The Identifier contains all needed information about the class it belongs to:
 …
     Every Identifier is in fact a ClassIdentifier, but they are derived from Identifier.
-    SubclassIdentifier is a separated class, acting like an Identifier, but has a given class.
-    You can only assign Identifiers of exactly the given class or of a derivative to a SubclassIdentifier.
 */
 …
     class _CoreExport Identifier
+    {
-        template <class T>
-        friend class SubclassIdentifier;
-        friend class Factory;
         public:
+            /** @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);
+            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
+            inline const uint32_t getNetworkID() const { return this->networkID_; }
+            void setNetworkID(uint32_t id);
+            /** @brief Returns the unique ID of the class */
+            FORCEINLINE unsigned int getClassID() const { return this->classID_; }
+            /** @brief Returns the list of all existing objects of this class. @return The list */
+            inline ObjectListBase* getObjects() const { return this->objects_; }
             /** @brief Sets the Factory. @param factory The factory to assign */
+            inline void addFactory(BaseFactory* factory) { this->factory_ = factory; }
+            inline void addFactory(Factory* factory) { this->factory_ = factory; }
+            /** @brief Returns true if the Identifier has a Factory. */
+            inline bool hasFactory() const { return (this->factory_ != 0); }
             BaseObject* fabricate(BaseObject* creator);
+            /** @brief Returns true if the class can be loaded through XML. */
+            inline bool isLoadable() const { return this->bLoadable_; }
+            /** @brief Set the class to be loadable through XML or not. */
+            inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
             bool isA(const Identifier* identifier) const;
             bool isExactlyA(const Identifier* identifier) const;
 …
             bool isDirectParentOf(const Identifier* identifier) const;
+            /** @brief Returns true if the class can be loaded through XML. */
+            inline bool isLoadable() const { return this->bLoadable_; }
+            /** @brief Set the class to be loadable through XML or not. */
+            inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
+            /** @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;
+            /////////////////////////////
+            ////// Class Hierarchy //////
+            /////////////////////////////
+            static void createClassHierarchy();
+            /** @brief Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. @return The status of the class-hierarchy creation */
+            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
             /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
 …
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
             inline const std::set<const Identifier*>& getChildren() const { return (*this->children_); }
+            inline const std::set<const Identifier*>& getChildren() const { return this->children_; }
             /** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
             inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_->begin(); }
+            inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_.begin(); }
             /** @brief Returns the end-iterator of the children-list. @return The end-iterator */
             inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_->end(); }
+            inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_.end(); }
             /** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
 …
             /** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
             inline const std::set<const Identifier*>& getDirectChildren() const { return (*this->directChildren_); }
+            inline const std::set<const Identifier*>& getDirectChildren() const { return this->directChildren_; }
             /** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
             inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_->begin(); }
+            inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_.begin(); }
             /** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
+            inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_->end(); }
+            /** @brief Returns the map that stores all Identifiers. @return The map */
+            static inline const std::map<std::string, Identifier*>& getIdentifierMap() { return Identifier::getIdentifierMapIntern(); }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapBegin() { return Identifier::getIdentifierMap().begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapEnd() { return Identifier::getIdentifierMap().end(); }
+            inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_.end(); }
+            //////////////////////////
+            ///// Identifier Map /////
+            //////////////////////////
+            static void destroyAllIdentifiers();
+            static Identifier* getIdentifierByString(const std::string& name);
+            static Identifier* getIdentifierByLowercaseString(const std::string& name);
+            static Identifier* getIdentifierByID(uint32_t id);
+            static void clearNetworkIDs();
+            /** @brief Returns the map that stores all Identifiers with their names. @return The map */
+            static inline const std::map<std::string, Identifier*>& getStringIdentifierMap() { return Identifier::getStringIdentifierMapIntern(); }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapBegin() { return Identifier::getStringIdentifierMap().begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapEnd() { return Identifier::getStringIdentifierMap().end(); }
             /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
             static inline const std::map<std::string, Identifier*>& getLowercaseIdentifierMap() { return Identifier::getLowercaseIdentifierMapIntern(); }
+            static inline const std::map<std::string, Identifier*>& getLowercaseStringIdentifierMap() { return Identifier::getLowercaseStringIdentifierMapIntern(); }
             /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
             static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapBegin() { return Identifier::getLowercaseIdentifierMap().begin(); }
+            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapBegin() { return Identifier::getLowercaseStringIdentifierMap().begin(); }
             /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapEnd() { return Identifier::getLowercaseIdentifierMap().end(); }
+            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapEnd() { return Identifier::getLowercaseStringIdentifierMap().end(); }
+            /** @brief Returns the map that stores all Identifiers with their IDs. @return The map */
+            static inline const std::map<uint32_t, Identifier*>& getIDIdentifierMap() { return Identifier::getIDIdentifierMapIntern(); }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their IDs. @return The const_iterator */
+            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapBegin() { return Identifier::getIDIdentifierMap().begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their IDs. @return The const_iterator */
+            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapEnd() { return Identifier::getIDIdentifierMap().end(); }
+            /////////////////////////
+            ///// Config Values /////
+            /////////////////////////
+            virtual void updateConfigValues(bool updateChildren = true) const = 0;
+            /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
+            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
             /** @brief Returns the map that stores all config values. @return The const_iterator */
 …
             inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapEnd() const { return this->configValues_LC_.end(); }
+            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
+            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
+            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
+            ////////////////////////////
+            ///// Console Commands /////
+            ////////////////////////////
+            /** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
+            inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
             /** @brief Returns the map that stores all console commands. @return The const_iterator */
 …
             inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
+            ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
+            ConsoleCommand* getConsoleCommand(const std::string& name) const;
+            ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
+            ///////////////////
+            ///// XMLPort /////
+            ///////////////////
             /** @brief Returns the map that stores all XMLPort params. @return The const_iterator */
             inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
 …
             inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
-            /** @brief Returns the map that stores all XMLPort events. @return The const_iterator */
-            inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortEventMap() const { return this->xmlportEventContainers_; }
-            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort events. @return The const_iterator */
-            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapBegin() const { return this->xmlportEventContainers_.begin(); }
-            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort events. @return The const_iterator */
-            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapEnd() const { return this->xmlportEventContainers_.end(); }
-            /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
-            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
-            /** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
-            inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
-            /** @brief Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. @return The status of the class-hierarchy creation */
-            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
-            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
-            inline const uint32_t getNetworkID() const { return this->networkID_; }
-            /** @brief Sets the network ID to a new value. @param id The new value */
-            void setNetworkID(uint32_t id);
-            /** @brief Returns the unique ID of the class */
-            FORCEINLINE unsigned int getClassID() const { return this->classID_; }
-            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
-            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
-            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
             void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
             XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
 …
             XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
-            void addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container);
-            XMLPortObjectContainer* getXMLPortEventContainer(const std::string& eventname);
-            ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
-            ConsoleCommand* getConsoleCommand(const std::string& name) const;
-            ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
-            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
-            static void destroyAllIdentifiers();
         protected:
 …
             virtual void createSuperFunctionCaller() const = 0;
+            /** @brief Returns the map that stores all Identifiers. @return The map */
+            static std::map<std::string, Identifier*>& getIdentifierMapIntern();
+            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
+            /** @brief Returns the map that stores all Identifiers with their names. @return The map */
+            static std::map<std::string, Identifier*>& getStringIdentifierMapIntern();
             /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
+            static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
+            static std::map<std::string, Identifier*>& getLowercaseStringIdentifierMapIntern();
+            /** @brief Returns the map that stores all Identifiers with their network IDs. @return The map */
+            static std::map<uint32_t, Identifier*>& getIDIdentifierMapIntern();
             /** @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*>& getChildrenIntern() const { return this->children_; }
             /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
             inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
+            inline std::set<const Identifier*>& getDirectChildrenIntern() const { return this->directChildren_; }
             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.
+            */
+            inline static void startCreatingHierarchy()
+            {
+                hierarchyCreatingCounter_s++;
+                COUT(4) << "*** Identifier: Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
+            }
+            /**
+                @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
+            */
+            inline static void stopCreatingHierarchy()
+            {
+                hierarchyCreatingCounter_s--;
+                COUT(4) << "*** Identifier: Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
+            }
+            /** @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents. */
+            inline static void startCreatingHierarchy() { hierarchyCreatingCounter_s++; }
+            /** @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents. */
+            inline static void stopCreatingHierarchy()  { hierarchyCreatingCounter_s--; }
             static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
 …
             std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
             std::set<const Identifier*>* children_;                        //!< The children of the class the Identifier belongs to
+            mutable std::set<const Identifier*> children_;                 //!< The children of the class the Identifier belongs to
             std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
             std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
+            mutable std::set<const Identifier*> directChildren_;           //!< The direct children of the class the Identifier belongs to
             bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
 …
             bool bLoadable_;                                               //!< False = it's not permitted to load the object through XML
             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)
+            Factory* factory_;                                             //!< The Factory, able to create new objects of the given class (if available)
             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)
             uint32_t networkID_;                                           //!< The network ID to identify a class through the network
 …
             std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
             std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
-            std::map<std::string, XMLPortObjectContainer*> xmlportEventContainers_;    //!< All events
     };
 …
         public:
             static ClassIdentifier<T> *getIdentifier();
             static ClassIdentifier<T> *getIdentifier(const std::string& name);
+            static ClassIdentifier<T>* getIdentifier();
+            static ClassIdentifier<T>* getIdentifier(const std::string& name);
             bool initialiseObject(T* object, const std::string& className, bool bRootClass);
 …
     inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
+    {
         // check if the static field has already been filled
         if (ClassIdentifier<T>::classIdentifier_s == 0)
+        // check if the Identifier already exists
+        if (!ClassIdentifier<T>::classIdentifier_s)
             ClassIdentifier<T>::initialiseIdentifier();
 …
 #endif
+    }
-    // ###############################
-    // ###   SubclassIdentifier    ###
-    // ###############################
-    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
-    /**
-        You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
-        If you assign something else, the program aborts.
-        Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
-    */
-    template <class T>
-    class SubclassIdentifier
+    {
-        public:
-            /**
-                @brief Constructor: Automaticaly assigns the Identifier of the given class.
-            */
-            SubclassIdentifier()
+            {
-                this->identifier_ = ClassIdentifier<T>::getIdentifier();
+            }
-            /**
-                @brief Copyconstructor: Assigns the given Identifier.
-                @param identifier The Identifier
-            */
-            SubclassIdentifier(Identifier* identifier)
+            {
-                this->operator=(identifier);
+            }
-            /**
-                @brief Overloading of the = operator: assigns the identifier and checks its type.
-                @param identifier The Identifier to assign
-                @return The SubclassIdentifier itself
-            */
-            SubclassIdentifier<T>& operator=(Identifier* identifier)
+            {
-                if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
+                {
-                    COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
-                    if (identifier)
+                    {
-                        COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
-                        COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
+                    }
-                    else
+                    {
-                        COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
+                    }
+                }
-                else
+                {
-                    this->identifier_ = identifier;
+                }
-                return *this;
+            }
-            /**
-                @brief Overloading of the * operator: returns the assigned identifier.
-            */
-            inline Identifier* operator*() const
+            {
-                return this->identifier_;
+            }
-            /**
-                @brief Overloading of the -> operator: returns the assigned identifier.
-            */
-            inline Identifier* operator->() const
+            {
-                return this->identifier_;
+            }
-            /**
-                @brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
-            */
-            inline operator Identifier*() const
+            {
-                return this->identifier_;
+            }
-            /**
-                @brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
-                @return The new object
-            */
-            T* fabricate(BaseObject* creator) const
+            {
-                BaseObject* newObject = this->identifier_->fabricate(creator);
-                // Check if the creation was successful
-                if (newObject)
+                {
-                    return orxonox_cast<T*>(newObject);
+                }
-                else
+                {
-                    // Something went terribly wrong
-                    if (this->identifier_)
+                    {
-                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
-                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
-                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
-                        COUT(1) << "Aborting..." << std::endl;
+                    }
-                    else
+                    {
-                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
-                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
-                        COUT(1) << "Aborting..." << std::endl;
+                    }
-                    assert(false);
-                    return 0;
+                }
+            }
-            /** @brief Returns the assigned identifier. @return The identifier */
-            inline Identifier* getIdentifier() const
-                { return this->identifier_; }
-//            /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
-//            inline bool isA(const Identifier* identifier) const
-//                { return this->identifier_->isA(identifier); }
-//
-//            /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
-//            inline bool isExactlyA(const Identifier* identifier) const
-//                { return this->identifier_->isExactlyA(identifier); }
-//
-//            /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
-//            inline bool isChildOf(const Identifier* identifier) const
-//                { return this->identifier_->isChildOf(identifier); }
-//
-//            /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
-//            inline bool isDirectChildOf(const Identifier* identifier) const
-//                { return this->identifier_->isDirectChildOf(identifier); }
-//
-//            /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
-//            inline bool isParentOf(const Identifier* identifier) const
-//                { return this->identifier_->isParentOf(identifier); }
-//
-//            /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
-//            inline bool isDirectParentOf(const Identifier* identifier) const
-//                { return this->identifier_->isDirectParentOf(identifier); }
-        private:
-            Identifier* identifier_;            //!< The assigned identifier
-    };
+}

code/branches/pickup/src/libraries/core/Iterator.h

r5738	r5935
167	167
168	168	return (*this);
169		~~return *this;~~
170	169	}
171	170
…	…
193	192	inline const Iterator<T>& operator++()
194	193	{
195		if (this->element_)
196		this->element_ = this->element_->next_;
	194	this->element_ = this->element_->next_;
197	195	return *this;
198	196	}
…	…
205	203	{
206	204	Iterator<T> copy = *this;
207		if (this->element_)
208		this->element_ = this->element_->next_;
	205	this->element_ = this->element_->next_;
209	206	return copy;
210	207	}
…	…
216	213	inline const Iterator<T>& operator--()
217	214	{
218		if (this->element_)
219		this->element_ = this->element_->prev_;
	215	this->element_ = this->element_->prev_;
220	216	return *this;
221	217	}
…	…
228	224	{
229	225	Iterator<T> copy = *this;
230		if (this->element_)
231		this->element_ = this->element_->prev_;
	226	this->element_ = this->element_->prev_;
232	227	return copy;
233	228	}
…	…
239	234	inline T* operator*() const
240	235	{
241		if (this->element_)
242		return orxonox_cast<T*>(this->element_->objectBase_);
243		else
244		return 0;
	236	return orxonox_cast<T*>(this->element_->objectBase_);
245	237	}
246	238
…	…
251	243	inline T* operator->() const
252	244	{
253		if (this->element_)
254		return orxonox_cast<T*>(this->element_->objectBase_);
255		else
256		return 0;
	245	return orxonox_cast<T*>(this->element_->objectBase_);
257	246	}
258	247

code/branches/pickup/src/libraries/core/Language.cc

-                      r5738
+                      r5935
 #include <fstream>
-#include <boost/filesystem.hpp>
 #include "util/Debug.h"
 #include "Core.h"
+#include "PathConfig.h"
 namespace orxonox
 …
         COUT(4) << "Read default language file." << std::endl;
         boost::filesystem::path filepath(Core::getConfigPath() / getFilename(this->defaultLanguage_));
+        std::string filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
         // This creates the file if it's not existing
         std::ofstream createFile;
         createFile.open(filepath.string().c_str(), std::fstream::app);
+        createFile.open(filepath.c_str(), std::fstream::app);
         createFile.close();
         // Open the file
         std::ifstream file;
         file.open(filepath.string().c_str(), std::fstream::in);
+        file.open(filepath.c_str(), std::fstream::in);
         if (!file.is_open())
 …
         COUT(4) << "Read translated language file (" << Core::getLanguage() << ")." << std::endl;
         boost::filesystem::path filepath(Core::getConfigPath() / getFilename(Core::getLanguage()));
+        std::string filepath = PathConfig::getConfigPathString() + getFilename(Core::getLanguage());
         // Open the file
         std::ifstream file;
         file.open(filepath.string().c_str(), std::fstream::in);
+        file.open(filepath.c_str(), std::fstream::in);
         if (!file.is_open())
 …
         COUT(4) << "Language: Write default language file." << std::endl;
         boost::filesystem::path filepath(Core::getConfigPath() / getFilename(this->defaultLanguage_));
+        std::string filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
         // Open the file
         std::ofstream file;
         file.open(filepath.string().c_str(), std::fstream::out);
+        file.open(filepath.c_str(), std::fstream::out);
         if (!file.is_open())

code/branches/pickup/src/libraries/core/Loader.cc

-                      r5781
+                      r5935
+        {
             if (mask.isIncluded(it->getIdentifier()))
                 delete (*(it++));
+                (it++)->destroy();
             else
                 ++it;
 …
+        {
             if ((it->getFile() == file) && mask.isIncluded(it->getIdentifier()))
                 delete (*(it++));
+                (it++)->destroy();
             else
                 ++it;

code/branches/pickup/src/libraries/core/LuaState.cc

r5781	r5935
37	37
38	38	#include "util/Debug.h"
39		~~#include "Core.h"~~
40	39	#include "Resource.h"
41	40	#include "ToluaBindCore.h"

code/branches/pickup/src/libraries/core/MemoryArchive.cc

-                      r5781
+                      r5935
                 continue;
             if (bDirs)
                 file = file.parent_path();
+                file = file.branch_path();
             if (file.empty())
                 continue;
             if (file.has_parent_path() && !bRecursive)
+            if (file.has_branch_path() && !bRecursive)
                 continue;
             if (simpleList)
 …
                 fi.archive = this;
                 fi.filename = file.string();
                 fi.basename = file.filename();
                 fi.path = file.parent_path().string();
+                fi.basename = file.leaf();
+                fi.path = file.branch_path().string();
                 fi.compressedSize = it->second.second;
                 fi.uncompressedSize = it->second.second;
 …
     bool MemoryArchive::exists(const String& filename)
+        {
+    {
         const FileMap& files = archives_s[this->getName()];
         return files.find(filename) != files.end();
+        }
+    }
     const Ogre::String& MemoryArchiveFactory::getType(void) const

code/branches/pickup/src/libraries/core/ObjectListIterator.h

r5738	r5935
123	123	inline const ObjectListIterator<T>& operator++()
124	124	{
125		if (this->element_)
126		this->element_ = static_cast<ObjectListElement<T>*>(this->element_->next_);
	125	this->element_ = static_cast<ObjectListElement<T>*>(this->element_->next_);
127	126	return *this;
128	127	}
…	…
135	134	{
136	135	ObjectListIterator<T> copy = *this;
137		if (this->element_)
138		this->element_ = static_cast<ObjectListElement<T>*>(this->element_->next_);
	136	this->element_ = static_cast<ObjectListElement<T>*>(this->element_->next_);
139	137	return copy;
140	138	}
…	…
146	144	inline const ObjectListIterator<T>& operator--()
147	145	{
148		if (this->element_)
149		this->element_ = static_cast<ObjectListElement<T>*>(this->element_->prev_);
	146	this->element_ = static_cast<ObjectListElement<T>*>(this->element_->prev_);
150	147	return *this;
151	148	}
…	…
158	155	{
159	156	ObjectListIterator<T> copy = *this;
160		if (this->element_)
161		this->element_ = static_cast<ObjectListElement<T>*>(this->element_->prev_);
	157	this->element_ = static_cast<ObjectListElement<T>*>(this->element_->prev_);
162	158	return copy;
163	159	}
…	…
169	165	inline T* operator*() const
170	166	{
171		if (this->element_)
172		return this->element_->object_;
173		else
174		return 0;
	167	return this->element_->object_;
175	168	}
176	169
…	…
181	174	inline T* operator->() const
182	175	{
183		if (this->element_)
184		return this->element_->object_;
185		else
186		return 0;
	176	return this->element_->object_;
187	177	}
188	178

code/branches/pickup/src/libraries/core/OrxonoxClass.cc

-                      r5738
+                      r5935
 #include "MetaObjectList.h"
 #include "Identifier.h"
+#include "WeakPtr.h"
 namespace orxonox
 …
         this->parents_ = 0;
         this->metaList_ = new MetaObjectList();
+        this->referenceCount_ = 0;
+        this->requestedDestruction_ = false;
+    }
 …
     OrxonoxClass::~OrxonoxClass()
+    {
+//        if (!this->requestedDestruction_)
+//            COUT(2) << "Warning: Destroyed object without destroy() (" << this->getIdentifier()->getName() << ")" << std::endl;
+        assert(this->referenceCount_ <= 0);
         delete this->metaList_;
 …
         if (this->parents_)
             delete this->parents_;
+        // reset all weak pointers pointing to this object
+        for (std::set<WeakPtr<OrxonoxClass>*>::iterator it = this->weakPointers_.begin(); it != this->weakPointers_.end(); )
+            (*(it++))->objectDeleted();
+    }
+    /** @brief Deletes the object if no smart pointers point to this object. Otherwise schedules the object to be deleted as soon as possible. */
+    void OrxonoxClass::destroy()
+    {
+        this->requestedDestruction_ = true;
+        if (this->referenceCount_ == 0)
+            delete this;
+    }
 …
     /** @brief Returns true if the objects class is of the given type or a derivative. */
-    template <class B> bool OrxonoxClass::isA(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isA(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is exactly of the given type. */
-    template <class B> bool OrxonoxClass::isExactlyA(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isExactlyA(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is a child of the given type. */
-    template <class B> bool OrxonoxClass::isChildOf(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isChildOf(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is a direct child of the given type. */
-    template <class B> bool OrxonoxClass::isDirectChildOf(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isDirectChildOf(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is a parent of the given type. */
-    template <class B> bool OrxonoxClass::isParentOf(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isParentOf(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is a direct parent of the given type. */
-    template <class B> bool OrxonoxClass::isDirectParentOf(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isDirectParentOf(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is of the given type or a derivative. */
-    template <class B> bool OrxonoxClass::isA(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isA(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is exactly of the given type. */
-    template <class B> bool OrxonoxClass::isExactlyA(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isExactlyA(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is a child of the given type. */
-    template <class B> bool OrxonoxClass::isChildOf(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isChildOf(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is a direct child of the given type. */
-    template <class B> bool OrxonoxClass::isDirectChildOf(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isDirectChildOf(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is a parent of the given type. */
-    template <class B> bool OrxonoxClass::isParentOf(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isParentOf(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is a direct parent of the given type. */
-    template <class B> bool OrxonoxClass::isDirectParentOf(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isDirectParentOf(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is of the given type or a derivative. */
     bool OrxonoxClass::isA(const OrxonoxClass* object)
         { return this->getIdentifier()->isA(object->getIdentifier()); }

code/branches/pickup/src/libraries/core/OrxonoxClass.h

-                      r5738
+                      r5935
         friend class ClassIdentifier;
+        template <class T>
+        friend class SmartPtr;
+        template <class T>
+        friend class WeakPtr;
         public:
             OrxonoxClass();
             virtual ~OrxonoxClass();
+            void destroy();
             /** @brief Function to collect the SetConfigValue-macro calls. */
 …
             bool isDirectParentOf(const Identifier* identifier);
+            template <class B> bool isA(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isExactlyA(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isChildOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isDirectChildOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isParentOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isDirectParentOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isA(const SubclassIdentifier<B> identifier);
+            template <class B> bool isExactlyA(const SubclassIdentifier<B> identifier);
+            template <class B> bool isChildOf(const SubclassIdentifier<B> identifier);
+            template <class B> bool isDirectChildOf(const SubclassIdentifier<B> identifier);
+            template <class B> bool isParentOf(const SubclassIdentifier<B> identifier);
+            template <class B> bool isDirectParentOf(const SubclassIdentifier<B> identifier);
+            template <class B> inline bool isA(const SubclassIdentifier<B>* identifier)
+                { return this->isA(*identifier); }
+            template <class B> inline bool isExactlyA(const SubclassIdentifier<B>* identifier)
+                { return this->isExactlyA(*identifier); }
+            template <class B> inline bool isChildOf(const SubclassIdentifier<B>* identifier)
+                { return this->isChildOf(*identifier); }
+            template <class B> inline bool isDirectChildOf(const SubclassIdentifier<B>* identifier)
+                { return this->isDirectChildOf(*identifier); }
+            template <class B> inline bool isParentOf(const SubclassIdentifier<B>* identifier)
+                { return this->isParentOf(*identifier); }
+            template <class B> inline bool isDirectParentOf(const SubclassIdentifier<B>* identifier)
+                { return this->isDirectParentOf(*identifier); }
             bool isA(const OrxonoxClass* object);
 …
             bool isDirectParentOf(const OrxonoxClass* object);
+            inline unsigned int getReferenceCount() const
+                { return this->referenceCount_; }
             /**
             @brief
 …
                 Returns NULL if the no pointer was found.
             */
+            template <class T>
+            FORCEINLINE T* getDerivedPointer(unsigned int classID)
+            FORCEINLINE void* getDerivedPointer(unsigned int classID)
+            {
                 for (int i = this->objectPointers_.size() - 1; i >= 0; --i)
+                {
                     if (this->objectPointers_[i].first == classID)
                         return static_cast<T*>(this->objectPointers_[i].second);
+                        return this->objectPointers_[i].second;
+                }
                 return NULL;
+            }
+            //! Const version of getDerivedPointer
+            template <class T>
+            FORCEINLINE const T* getDerivedPointer(unsigned int classID) const
+            {
+                return const_cast<OrxonoxClass*>(this)->getDerivedPointer<T>(classID);
+            }
+            //! Version of getDerivedPointer with template
+            template <class T> FORCEINLINE T* getDerivedPointer(unsigned int classID)
+            {   return static_cast<T*>(this->getDerivedPointer(classID));   }
+            //! Const version of getDerivedPointer with template
+            template <class T> FORCEINLINE const T* getDerivedPointer(unsigned int classID) const
+            {   return const_cast<OrxonoxClass*>(this)->getDerivedPointer<T>(classID);   }
         private:
+            /** @brief Increments the reference counter (for smart pointers). */
+            inline void incrementReferenceCount()
+                { ++this->referenceCount_; }
+            /** @brief Decrements the reference counter (for smart pointers). */
+            inline void decrementReferenceCount()
+                { --this->referenceCount_; if (this->referenceCount_ == 0 && this->requestedDestruction_) { delete this; } }
+            /** @brief Register a weak pointer which points to this object. */
+            template <class T>
+            inline void registerWeakPtr(WeakPtr<T>* pointer)
+                { this->weakPointers_.insert(reinterpret_cast<WeakPtr<OrxonoxClass>*>(pointer)); }
+            /** @brief Unegister a weak pointer which pointed to this object before. */
+            template <class T>
+            inline void unregisterWeakPtr(WeakPtr<T>* pointer)
+                { this->weakPointers_.erase(reinterpret_cast<WeakPtr<OrxonoxClass>*>(pointer)); }
             Identifier* identifier_;                   //!< The Identifier of the object
             std::set<const Identifier*>* parents_;     //!< List of all parents of the object
             MetaObjectList* metaList_;                 //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
+            int referenceCount_;                       //!< Counts the references from smart pointers to this object
+            bool requestedDestruction_;                //!< Becomes true after someone called delete on this object
+            std::set<WeakPtr<OrxonoxClass>*> weakPointers_; //!< All weak pointers which point to this object (and like to get notified if it dies)
             //! 'Fast map' that holds this-pointers of all derived types
             std::vector<std::pair<unsigned int, void*> > objectPointers_;

code/branches/pickup/src/libraries/core/Resource.h

-                      r5781
+                      r5935
         // Docs by Ogre::ResourceGroupManager.h
     public:
                 /**
+        /**
         @brief
             Open a single resource by name and return a DataStream
 …
             Shared pointer to data stream containing the data. Will be
             destroyed automatically when no longer referenced.
                 */
+        */
         static DataStreamPtr open(const std::string& name,
             const std::string& group = Resource::DEFAULT_GROUP,
             bool bSearchGroupsIfNotFound = false);
                 /**
+        /**
         @brief
             Open all resources matching a given pattern (which can contain
 …
             Shared pointer to a data stream list , will be
             destroyed automatically when no longer referenced
                 */
+        */
         static DataStreamListPtr openMulti(const std::string& pattern, const std::string& group = Resource::DEFAULT_GROUP);

code/branches/pickup/src/libraries/core/Shell.cc

r5781	r5935
88	88	OutputHandler::getOutStream().setOutputBuffer(0);
89	89	if (this->inputBuffer_)
90		~~delete this->inputBuffer_~~;
	90	this->inputBuffer_->destroy();
91	91	}
92	92

code/branches/pickup/src/libraries/core/Super.h

-                      r5781
+                      r5935
         SUPER_NOARGS(classname, functionname)
     #define SUPER_processEvent(classname, functionname, ...) \
+    #define SUPER_XMLEventPort(classname, functionname, ...) \
         SUPER_ARGS(classname, functionname, __VA_ARGS__)
     #define SUPER_changedScale(classname, functionname, ...) \
-        SUPER_NOARGS(classname, functionname)
-    #define SUPER_changedMainState(classname, functionname, ...) \
         SUPER_NOARGS(classname, functionname)
 …
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(4, processEvent, true, Event& event)
             (event)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(4, XMLEventPort, true, Element& xmlelement, XMLPort::Mode mode)
+            (xmlelement, mode)
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
 …
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(6, changedMainState, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(7, changedOwner, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(8, changedOverlayGroup, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(9, changedName, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(10, changedGametype, false)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(6, changedOwner, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(7, changedOverlayGroup, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(8, changedName, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(9, changedGametype, false)
             ()
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
 …
     SUPER_INTRUSIVE_DECLARATION(changedActivity);
     SUPER_INTRUSIVE_DECLARATION(changedVisibility);
     SUPER_INTRUSIVE_DECLARATION(processEvent);
+    SUPER_INTRUSIVE_DECLARATION(XMLEventPort);
     SUPER_INTRUSIVE_DECLARATION(changedScale);
-    SUPER_INTRUSIVE_DECLARATION(changedMainState);
     SUPER_INTRUSIVE_DECLARATION(changedOwner);
     SUPER_INTRUSIVE_DECLARATION(changedOverlayGroup);

code/branches/pickup/src/libraries/core/TclBind.cc

-                      r5781
+                      r5935
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"
 #include "Core.h"
+#include "PathConfig.h"
 #include "TclThreadManager.h"
 …
+    {
 #ifdef DEPENDENCY_PACKAGE_ENABLE
         if (Core::isDevelopmentRun())
+        if (PathConfig::isDevelopmentRun())
             return (std::string(specialConfig::dependencyLibraryDirectory) + "/tcl");
         else
             return (Core::getRootPathString() + "lib/tcl");
+            return (PathConfig::getRootPathString() + "lib/tcl");
 #else
         return "";

code/branches/pickup/src/libraries/core/TclThreadManager.cc

-                      r5781
+                      r5935
 #include <cpptcl/cpptcl.h>
+#include "util/Clock.h"
 #include "util/Convert.h"
 #include "util/Exception.h"
-#include "Clock.h"
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"

code/branches/pickup/src/libraries/core/XMLPort.h

r5781	r5935
51	51	#include "util/MultiType.h"
52	52	#include "util/OrxAssert.h"
53		~~#include "Factory.h"~~
54	53	#include "Identifier.h"
55	54	#include "Executor.h"
…	…
377	376	this->owner_->xmlAttributes_.clear();
378	377	// Iterate through the attributes manually in order to make them case insensitive
379		Attribute* attribute = xmlelement.FirstAttribute(false);
	378	ticpp::Attribute* attribute = xmlelement.FirstAttribute(false);
380	379	while (attribute != 0)
381	380	{
…	…
412	411	}
413	412	}
414		else
	413	else if (mode == XMLPort::SaveObject)
415	414	{
416	415	if (this->saveexecutor_)
…	…
548	547	for (ticpp::Iterator<ticpp::Element> child = xmlsubelement->FirstChildElement(false); child != child.end(); child++)
549	548	{
550		Identifier* identifier = ~~Factory::getIdentifier~~(child->Value());
	549	Identifier* identifier = Identifier::getIdentifierByString(child->Value());
551	550	if (identifier)
552	551	{
…	…
629	628	}
630	629	}
631		else
	630	else if (mode == XMLPort::SaveObject)
632	631	{
633	632	}

code/branches/pickup/src/libraries/core/input/Button.cc

-                      r5781
+                      r5935
                 // evaluate the command
                 CommandEvaluation eval = CommandExecutor::evaluate(commandStr);
+                const CommandEvaluation& eval = CommandExecutor::evaluate(commandStr);
                 if (!eval.isValid())
+                {
                     parseError("Command evaluation failed.", true);
+                    parseError("Command evaluation of \"" + commandStr + "\"failed.", true);
                     continue;
+                }

code/branches/pickup/src/libraries/core/input/CMakeLists.txt

r5781	r5935
9	9	JoyStickQuantityListener.cc
10	10	KeyBinder.cc
	11	KeyBinderManager.cc
11	12	Keyboard.cc
12	13	KeyDetector.cc

code/branches/pickup/src/libraries/core/input/InputDevice.h

-                      r5781
+                      r5935
 #include <ois/OISInputManager.h>
+#include "util/Clock.h"
 #include "util/Debug.h"
 #include "util/Exception.h"
-#include "core/Clock.h"
 #include "InputState.h"

code/branches/pickup/src/libraries/core/input/InputManager.cc

-                      r5781
+                      r5935
 #include <boost/foreach.hpp>
+#include "util/Clock.h"
 #include "util/Convert.h"
 #include "util/Exception.h"
 #include "util/ScopeGuard.h"
-#include "core/Clock.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 …
 #include "InputBuffer.h"
-#include "KeyDetector.h"
 #include "JoyStick.h"
 #include "JoyStickQuantityListener.h"
 …
         , oisInputManager_(0)
         , devices_(2)
         , bExclusiveMouse_(false)
+        , mouseMode_(MouseMode::Nonexclusive)
         , emptyState_(0)
-        , keyDetector_(0)
         , calibratorCallbackHandler_(0)
+    {
 …
         this->setConfigValues();
+        if (GraphicsManager::getInstance().isFullScreen())
+            mouseMode_ = MouseMode::Exclusive;
         this->loadDevices();
 …
         emptyState_->setHandler(&InputHandler::EMPTY);
         activeStates_[emptyState_->getPriority()] = emptyState_;
-        // KeyDetector to evaluate a pressed key's name
-        InputState* detector = createInputState("detector", false, false, InputStatePriority::Detector);
-        // Create a callback to avoid buttonHeld events after the key has been detected
-        FunctorMember<InputManager>* bufferFunctor = createFunctor(&InputManager::clearBuffers);
-        bufferFunctor->setObject(this);
-        detector->setLeaveFunctor(bufferFunctor);
-        keyDetector_ = new KeyDetector();
-        detector->setHandler(keyDetector_);
         // Joy stick calibration helper callback
 …
         this->updateActiveStates();
+        {
+            // calibrate console command
+            FunctorMember<InputManager>* functor = createFunctor(&InputManager::calibrate);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "calibrate"), true);
+        }
+        {
+            // reload console command
+            FunctorMember<InputManager>* functor = createFunctor(&InputManager::reload);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "reload"), false);
+        }
+        // calibrate console command
+        this->getIdentifier()->addConsoleCommand(createConsoleCommand(createFunctor(&InputManager::calibrate, this), "calibrate"), true);
+        // reload console command
+        this->getIdentifier()->addConsoleCommand(createConsoleCommand(createFunctor(&InputManager::reload, this), "reload"), false);
         CCOUT(4) << "Construction complete." << std::endl;
 …
         paramList.insert(std::make_pair("w32_keyboard", "DISCL_FOREGROUND"));
         paramList.insert(std::make_pair("w32_mouse", "DISCL_FOREGROUND"));
         if (bExclusiveMouse_ || GraphicsManager::getInstance().isFullScreen())
+        if (mouseMode_ == MouseMode::Exclusive || GraphicsManager::getInstance().isFullScreen())
+        {
             // Disable Windows key plus special keys (like play, stop, next, etc.)
 …
         paramList.insert(std::make_pair("XAutoRepeatOn", "true"));
         if (bExclusiveMouse_ || GraphicsManager::getInstance().isFullScreen())
+        if (mouseMode_ == MouseMode::Exclusive || GraphicsManager::getInstance().isFullScreen())
+        {
             if (CommandLine::getValue("keyboard_no_grab").getBool())
 …
+    }
-    void InputManager::setKeyDetectorCallback(const std::string& command)
+    {
-        this->keyDetector_->setCallbackCommand(command);
+    }
     // ############################################################
     // #####                    Destruction                   #####
 …
         // Destroy calibrator helper handler and state
-        delete keyDetector_;
         this->destroyState("calibrator");
         // Destroy KeyDetector and state
+        delete calibratorCallbackHandler_;
+        this->destroyState("detector");
+        calibratorCallbackHandler_->destroy();
         // destroy the empty InputState
         this->destroyStateInternal(this->emptyState_);
 …
         // Check whether we have to change the mouse mode
+        MouseMode::Value requestedMode = MouseMode::Dontcare;
         std::vector<InputState*>& mouseStates = devices_[InputDeviceEnumerator::Mouse]->getStateListRef();
+        if (mouseStates.empty() && bExclusiveMouse_ ||
+            !mouseStates.empty() && mouseStates.front()->getIsExclusiveMouse() != bExclusiveMouse_)
+        {
+            bExclusiveMouse_ = !bExclusiveMouse_;
+        if (mouseStates.empty())
+            requestedMode = MouseMode::Nonexclusive;
+        else
+            requestedMode = mouseStates.front()->getMouseMode();
+        if (requestedMode != MouseMode::Dontcare && mouseMode_ != requestedMode)
+        {
+            mouseMode_ = requestedMode;
             if (!GraphicsManager::getInstance().isFullScreen())
                 this->reloadInternal();
 …
+        }
         statesByName_.erase(state->getName());
         delete state;
+        state->destroy();
+    }
+}

code/branches/pickup/src/libraries/core/input/InputManager.h

-                      r5781
+                      r5935
         // Various getters and setters
         //-------------------------------
-        //! Sets the the name of the command used by the KeyDetector as callback.
-        void setKeyDetectorCallback(const std::string& command);
         //! Returns the number of joy stick that have been created since the c'tor or last call to reload().
         unsigned int getJoyStickQuantity() const
 …
         OIS::InputManager*                  oisInputManager_;      //!< OIS input manager
         std::vector<InputDevice*>           devices_;              //!< List of all input devices (keyboard, mouse, joy sticks)
         bool                                bExclusiveMouse_;      //!< Currently applied mouse mode
+        MouseMode::Value                    mouseMode_;            //!< Currently applied mouse mode
         // some internally handled states and handlers
         InputState*                         emptyState_;           //!< Lowest priority states (makes handling easier)
-        KeyDetector*                        keyDetector_;          //!< KeyDetector instance
         //! InputBuffer that reacts to the Enter key when calibrating the joy sticks
         InputBuffer*                        calibratorCallbackHandler_;

code/branches/pickup/src/libraries/core/input/InputState.cc

r5781	r5935
37	37	, bAlwaysGetsInput_(bAlwaysGetsInput)
38	38	, bTransparent_(bTransparent)
39		, ~~bExclusiveMouse_(tru~~e)
	39	, mouseMode_(MouseMode::Dontcare)
40	40	, bExpired_(true)
41	41	, handlers_(2)

code/branches/pickup/src/libraries/core/input/InputState.h

-                      r5781
+                      r5935
         static const int Detector     = HighPriority + 2;
     };
+    namespace MouseMode
+    {
+        enum Value
+        {
+            Exclusive,
+            Nonexclusive,
+            Dontcare
+        };
+    }
     /**
 …
         void setHandler        (InputHandler* handler);
         void setIsExclusiveMouse(bool value) { bExclusiveMouse_ = value; this->bExpired_ = true; }
         bool getIsExclusiveMouse() const { return bExclusiveMouse_; }
+        void setMouseMode(MouseMode::Value value) { mouseMode_ = value; this->bExpired_ = true; }
+        MouseMode::Value getMouseMode() const { return mouseMode_; }
         //! Returns the name of the state (which is unique!)
 …
         const bool                  bAlwaysGetsInput_;      //!< See class declaration for explanation
         const bool                  bTransparent_;          //!< See class declaration for explanation
         bool                        bExclusiveMouse_;       //!< See class declaration for explanation
+        MouseMode::Value            mouseMode_;             //!< See class declaration for explanation
         int                         priority_;              //!< Current priority (might change)
         bool                        bExpired_;              //!< See hasExpired()

code/branches/pickup/src/libraries/core/input/KeyBinder.cc

-                      r5781
+                      r5935
  */
-/**
- @file
- @brief Implementation of the different input handlers.
- */
 #include "KeyBinder.h"
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Exception.h"
 #include "core/ConfigValueIncludes.h"
 #include "core/CoreIncludes.h"
 …
         Constructor that does as little as necessary.
     */
     KeyBinder::KeyBinder()
+    KeyBinder::KeyBinder(const std::string& filename)
         : deriveTime_(0.0f)
+        , filename_(filename)
+    {
         mouseRelative_[0] = 0;
 …
         // set them here to use allHalfAxes_
         setConfigValues();
+        // Load the bindings if filename was given
+        if (!this->filename_.empty())
+            this->loadBindings();
+    }
 …
     @brief
         Loads the key and button bindings.
+    @return
+        True if loading succeeded.
+    */
+    void KeyBinder::loadBindings(const std::string& filename)
+    */
+    void KeyBinder::loadBindings()
+    {
         COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
+        if (filename.empty())
+            return;
+        if (this->configFile_ == ConfigFileType::NoType)
+        {
+            // Get a new ConfigFileType from the ConfigFileManager
+            this->configFile_ = ConfigFileManager::getInstance().getNewConfigFileType();
+        }
+        ConfigFileManager::getInstance().setFilename(this->configFile_, filename);
+        // Get a new ConfigFileType from the ConfigFileManager
+        this->configFile_ = ConfigFileManager::getInstance().getNewConfigFileType();
+        ConfigFileManager::getInstance().setFilename(this->configFile_, this->filename_);
         // Parse bindings and create the ConfigValueContainers if necessary
-        clearBindings();
         for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
             it->second->readConfigValue(this->configFile_);

code/branches/pickup/src/libraries/core/input/KeyBinder.h

-                      r5781
+                      r5935
+ *
  */
-/**
-@file
-@brief
-    Different definitions of input processing.
-*/
 #ifndef _KeyBinder_H__
 …
     /**
     @brief
+        Handles mouse, keyboard and joy stick input while in the actual game mode.
+        Manages the key bindings.
+        Maps mouse, keyboard and joy stick input to command strings and executes them.
+        The bindings are stored in ini-files (like the one for configValues) in the config Path.
+    @remarks
+        You cannot change the filename because the KeyBinderManager maps these filenames to the
+        KeyBinders. If you need to load other bindings, just create a new one.
     */
     class _CoreExport KeyBinder : public InputHandler, public JoyStickQuantityListener
+    {
     public:
         KeyBinder ();
+        KeyBinder (const std::string& filename);
         virtual ~KeyBinder();
-        void loadBindings(const std::string& filename);
         void clearBindings();
         bool setBinding(const std::string& binding, const std::string& name, bool bTemporary = false);
+        const std::string& getBindingsFilename()
+            { return this->filename_; }
         void setConfigValues();
         void resetJoyStickAxes();
     protected: // functions
+        void loadBindings();
+        void buttonThresholdChanged();
+        void initialiseJoyStickBindings();
+        void compilePointerLists();
+        // from JoyStickQuantityListener interface
+        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
         void allDevicesUpdated(float dt);
         void mouseUpdated(float dt);
 …
         // internal
         void tickHalfAxis(HalfAxis& halfAxis);
-        void buttonThresholdChanged();
-        // from JoyStickQuantityListener interface
-        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
-        void initialiseJoyStickBindings();
-        void compilePointerLists();
         void buttonPressed (const KeyEvent& evt);
 …
         float deriveTime_;
+        //! Name of the file used in this KeyBinder (constant!)
+        const std::string filename_;
         //! Config file used. ConfigFileType::NoType in case of KeyDetector. Also indicates whether we've already loaded.
         ConfigFileType configFile_;
 …
     };
     inline void KeyBinder::buttonPressed (const KeyEvent& evt)
     { assert(!keys_[evt.getKeyCode()].name_.empty()); keys_[evt.getKeyCode()].execute(KeybindMode::OnPress); }

code/branches/pickup/src/libraries/core/input/KeyDetector.cc

-                      r5781
+                      r5935
 #include "KeyDetector.h"
 #include "util/Debug.h"
+#include "core/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
+#include "core/ScopedSingletonManager.h"
 #include "Button.h"
+#include "InputManager.h"
+#include "InputState.h"
 namespace orxonox
+{
     /**
     @brief
         Constructor
+    */
+    std::string KeyDetector::callbackCommand_s = "KeyDetectorKeyPressed";
+    KeyDetector* KeyDetector::singletonPtr_s = 0;
+    ManageScopedSingleton(KeyDetector, ScopeID::Graphics, false);
     KeyDetector::KeyDetector()
+        : KeyBinder("")
+    {
         RegisterObject(KeyDetector);
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(createFunctor(&KeyDetector::callback,  this), callbackCommand_s));
+        this->assignCommands();
+        inputState_ = InputManager::getInstance().createInputState("detector", false, false, InputStatePriority::Detector);
+        // Create a callback to avoid buttonHeld events after the key has been detected
+        inputState_->setLeaveFunctor(createFunctor(&InputManager::clearBuffers, &InputManager::getInstance()));
+        inputState_->setHandler(this);
+    }
-    /**
-    @brief
-        Destructor
-    */
     KeyDetector::~KeyDetector()
+    {
+        inputState_->setHandler(NULL);
+        InputManager::getInstance().destroyState("detector");
+    }
+    /**
+    @brief
+        Assigns all the buttons 'command' plus the button's name.
+    */
+    void KeyDetector::setCallbackCommand(const std::string& command)
+    void KeyDetector::assignCommands()
+    {
         callbackCommand_ = command;
+        // Assign every button/axis the same command, but with its name as argument
         clearBindings();
         for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
+        {
             it->second->bindingString_ = callbackCommand_ + it->second->groupName_ + "." + it->second->name_;
+            it->second->bindingString_ = callbackCommand_s + " " + it->second->groupName_ + "." + it->second->name_;
             it->second->parse();
+        }
+    }
+    void KeyDetector::callback(const std::string& name)
+    {
+        // Call the registered function
+        if (this->callbackFunction_)
+            (*this->callbackFunction_)(name);
+    }
 …
+    {
         KeyBinder::JoyStickQuantityChanged(joyStickList);
+        if (!callbackCommand_.empty())
+            setCallbackCommand(callbackCommand_);
+        this->assignCommands();
+    }
+}

code/branches/pickup/src/libraries/core/input/KeyDetector.h

-                      r5781
+                      r5935
 #include "InputPrereqs.h"
 #include <string>
+#include "util/Singleton.h"
 #include "KeyBinder.h"
 namespace orxonox
+{
     class _CoreExport KeyDetector : public KeyBinder
+    class _CoreExport KeyDetector : public KeyBinder, public Singleton<KeyDetector>
+    {
+        friend class Singleton<KeyDetector>;
     public:
         KeyDetector();
         ~KeyDetector();
+        void setCallbackCommand(const std::string& command);
         void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
+        void setCallback(Functor* function) { this->callbackFunction_ = function; }
     private:
+        std::string callbackCommand_;
+        KeyDetector(const KeyDetector&);
+        void callback(const std::string& name);
+        void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
+        void assignCommands();
+        Functor* callbackFunction_;
+        InputState* inputState_;
+        static std::string callbackCommand_s;
+        static KeyDetector* singletonPtr_s;
     };
+}

code/branches/pickup/src/libraries/core/input/Mouse.cc

-                      r5781
+                      r5935
 #ifdef ORXONOX_PLATFORM_LINUX
+        {
+            // Mouse grab console command
+            FunctorMember<Mouse>* functor = createFunctor(&Mouse::grab);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "grab"), false);
+        }
+        {
+            // Mouse ungrab console command
+            FunctorMember<Mouse>* functor = createFunctor(&Mouse::ungrab);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "ungrab"), false);
+        }
+        // Mouse grab console command
+        this->getIdentifier()->addConsoleCommand(createConsoleCommand(createFunctor(&Mouse::grab, this), "grab"), false);
+        // Mouse ungrab console command
+        this->getIdentifier()->addConsoleCommand(createConsoleCommand(createFunctor(&Mouse::ungrab, this), "ungrab"), false);
 #endif
+    }

code/branches/pickup/src/libraries/network/Client.cc

-                      r5781
+                      r5935
 #include <cassert>
+#include "util/Clock.h"
 #include "util/Debug.h"
-#include "core/Clock.h"
 #include "synchronisable/Synchronisable.h"
 #include "packet/Chat.h"
 #include "packet/Gamestate.h"
 #include "FunctionCallManager.h"
+#include "core/CoreIncludes.h"
+#include "core/Game.h"
 namespace orxonox
 …
     return;
+  }
+  void Client::connectionClosed()
+  {
+    ObjectList<Synchronisable>::iterator it;
+    for(it = ObjectList<Synchronisable>::begin(); it; )
+    {
+      if( it->getSyncMode() != 0x0 )
+        (it++)->destroy();
+      else
+      {
+        ++it;
+      }
+    }
+    Game::getInstance().popState();
+    Game::getInstance().popState();
+  }
+}

code/branches/pickup/src/libraries/network/Client.h

-                      r5781
+                      r5935
 #include <string>
+#include "util/UtilPrereqs.h"
 #include "ClientConnection.h"
 #include "GamestateClient.h"
 …
     void update(const Clock& time);
+  protected:
+    virtual void connectionClosed();
   private:
     Client(const Client& copy); // not used

code/branches/pickup/src/libraries/network/ClientConnection.cc

r5781	r5935
118	118	case ENET_EVENT_TYPE_DISCONNECT:
119	119	COUT(4) << "received disconnect confirmation from server" << endl;
	120	this->connectionClosed();
120	121	return true;
121	122	}
…	…
123	124	}
124	125	enet_peer_reset( this->server_ );
	126	this->connectionClosed();
125	127	return false;
126	128	}
…	…
133	135	}
134	136
135		void ClientConnection::add~~Client~~(ENetEvent* event)
	137	void ClientConnection::addPeer(ENetEvent* event)
136	138	{
137	139	assert(0);
138	140	}
139		void ClientConnection::~~disconnect~~Peer(ENetEvent* event)
	141	void ClientConnection::removePeer(ENetEvent* event)
140	142	{
141	143	this->established_=false;
142	144	COUT(1) << "Received disconnect Packet from Server!" << endl;
143	145	// server closed the connection
	146	this->connectionClosed();
144	147	}
145	148

code/branches/pickup/src/libraries/network/ClientConnection.h

-                      r5781
+                      r5935
     bool addPacket(ENetPacket *packet);
     inline bool isConnected(){ return this->established_; }
+  protected:
+    virtual void connectionClosed()=0;
   private:
     virtual void addClient(ENetEvent* event);
     virtual void disconnectPeer(ENetEvent* event);
+    virtual void addPeer(ENetEvent* event);
+    virtual void removePeer(ENetEvent* event);
     bool disconnectConnection();

code/branches/pickup/src/libraries/network/ClientConnectionListener.cc

-                      r5781
+                      r5935
 #include "ClientInformation.h"
+namespace orxonox{
+namespace orxonox
+{
+    ClientConnectionListener::ClientConnectionListener()
+    {
+        RegisterRootObject(ClientConnectionListener);
+    }
+  ClientConnectionListener::ClientConnectionListener()
+  {
+    RegisterRootObject(ClientConnectionListener);
+  }
+    void ClientConnectionListener::broadcastClientConnected(unsigned int clientID)
+    {
+        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
+            it->clientConnected(clientID);
+    }
+    void ClientConnectionListener::broadcastClientDisconnected(unsigned int clientID)
+    {
+        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
+            it->clientDisconnected(clientID);
+    }
+  void ClientConnectionListener::getConnectedClients(){
+    if(GameMode::showsGraphics())
+      this->clientConnected(0); //server client id
+    ClientInformation *client = ClientInformation::getBegin();
+    while(client){
+      this->clientConnected(client->getID());
+      client=client->next();
+    void ClientConnectionListener::getConnectedClients()
+    {
+        ClientInformation* client = ClientInformation::getBegin();
+        while (client)
+        {
+            this->clientConnected(client->getID());
+            client = client->next();
+        }
+    }
+  }
+}

code/branches/pickup/src/libraries/network/ClientConnectionListener.h

-                      r5781
+                      r5935
 #include "core/OrxonoxClass.h"
+namespace orxonox{
+namespace orxonox
+{
+    class _NetworkExport ClientConnectionListener : virtual public OrxonoxClass
+    {
+        public:
+            ClientConnectionListener();
+            virtual ~ClientConnectionListener() {}
+            static void broadcastClientConnected(unsigned int clientID);
+            static void broadcastClientDisconnected(unsigned int clientID);
+  class _NetworkExport ClientConnectionListener : virtual public OrxonoxClass
+  {
+    friend class Server;
+            virtual void clientConnected(unsigned int clientID) = 0;
+            virtual void clientDisconnected(unsigned int clientID) = 0;
+  public:
+    ClientConnectionListener();
+    virtual ~ClientConnectionListener() {}
+    void getConnectedClients();
+  protected:
+    virtual void clientConnected(unsigned int clientID) = 0;
+    virtual void clientDisconnected(unsigned int clientID) = 0;
+  };
+        protected:
+            void getConnectedClients();
+    };
+}

code/branches/pickup/src/libraries/network/Connection.cc

Property svn:eol-style set to native

-                      r5781
+                      r5935
         // log handling ================
         case ENET_EVENT_TYPE_CONNECT:
           addClient( &event );
+          addPeer( &event );
           break;
         case ENET_EVENT_TYPE_DISCONNECT:
           disconnectPeer( &event );
+          removePeer( &event );
           break;
         case ENET_EVENT_TYPE_RECEIVE:

code/branches/pickup/src/libraries/network/Connection.h

Property svn:eol-style set to native

-                      r5781
+                      r5935
     int service(ENetEvent* event);
     void disconnectPeer(ENetPeer *peer);
+    virtual void disconnectPeer(ENetPeer *peer);
     void processQueue();
     virtual void addClient(ENetEvent* event)=0;
     virtual void disconnectPeer(ENetEvent* event)=0;
+    virtual void addPeer(ENetEvent* event)=0;
+    virtual void removePeer(ENetEvent* event)=0;
     virtual bool processPacket(ENetEvent* event);

code/branches/pickup/src/libraries/network/GamestateClient.cc

r5781	r5935
108	108	ObjectList<Synchronisable>::iterator temp=it;
109	109	++it;
110		~~delete *temp;~~
	110	temp->destroy(); // or delete?
111	111	}
112	112

code/branches/pickup/src/libraries/network/GamestateManager.cc

-                      r5781
+                      r5935
         delete (*it2).second;
+    }
     delete this->trafficControl_;
+    this->trafficControl_->destroy();
 //     delete this->threadMutex_;
 //     delete this->threadPool_;
 …
       finishGamestate( cid, &clientGamestates.back(), client, reference );
       //FunctorMember<GamestateManager>* functor =
+//       ExecutorMember<GamestateManager>* executor = createExecutor( createFunctor(&GamestateManager::finishGamestate) );
+//       executor->setObject(this);
+//       ExecutorMember<GamestateManager>* executor = createExecutor( createFunctor(&GamestateManager::finishGamestate, this) );
 //       executor->setDefaultValues( cid, &clientGamestates.back(), client, reference );
 //       (*static_cast<Executor*>(executor))();

code/branches/pickup/src/libraries/network/NetworkFunction.cc

r5781	r5935
60	60	std::map<std::string, NetworkFunctionBase*>::iterator it;
61	61	for( it=NetworkFunctionBase::nameMap_.begin(); it!=NetworkFunctionBase::nameMap_.end(); ++it )
62		~~delete it->second~~;
	62	it->second->destroy();
63	63	}
64	64

code/branches/pickup/src/libraries/network/NetworkPrereqs.h

-                      r5781
+                      r5935
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the network library
 */
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined( NETWORK_STATIC_BUILD )
 #  ifdef NETWORK_SHARED_BUILD
 …
 //-----------------------------------------------------------------------
 // Library global contants
+// Constants
 //-----------------------------------------------------------------------
 namespace orxonox
+{
   static const unsigned int GAMESTATEID_INITIAL = static_cast<unsigned int>(-1);
   static const unsigned int CLIENTID_UNKNOWN    = static_cast<unsigned int>(-2);
+  static const uint32_t     OBJECTID_UNKNOWN    = static_cast<uint32_t>(-1);
+}
+//-----------------------------------------------------------------------
+// Enums
+//-----------------------------------------------------------------------
+namespace orxonox
+{
+  namespace packet
+  {
+    namespace PacketFlag
+    {
+      enum Value
+      {
+        Reliable   = 1,
+        Unsequence = 2,
+        NoAllocate = 4
+      };
+    }
+  }
+}
 …
 namespace orxonox
+{
+  class ChatListener;
   class Client;
   class ClientConnection;
   class ClientConnectionListener;
-  class ClientFrameListener;
   class ClientInformation;
   class Connection;
   class FunctionCallManager;
   class GamestateClient;
+  class GamestateHandler;
   class GamestateManager;
+  class GamestateHandler;
+  class NetworkCallbackBase;
+  template <class T> class NetworkCallback;
+  class NetworkCallbackManager;
+  class Host;
   class NetworkFunctionBase;
+  struct NetworkFunctionPointer;
   class NetworkFunctionStatic;
+  template <class T>
+  class NetworkMemberFunction;
   class NetworkMemberFunctionBase;
-  template <class T> class NetworkMemeberFunction;
-  struct NetworkFunctionPointer;
   class Server;
   class ServerConnection;
-  class ServerFrameListener;
-  class Synchronisable;
-  class SynchronisableVariableBase;
-  template <class T> class SynchronisableVariable;
-  template <class T> class SynchronisableVariableBidirectional;
-  struct ClientList;
-  struct PacketEnvelope;
-  struct QueueItem;
-  struct syncData;
   class TrafficControl;
-  class obj;
-  class objInfo;
+  // packet
   namespace packet
+  {
 …
     class Chat;
     class ClassID;
+    class DeleteObjects;
     class FunctionCalls;
     class FunctionIDs;
     class Gamestate;
-    class NetworkIDs;
     class Packet;
     class Welcome;
+  }
+    namespace PacketFlag
+    {
+      enum Value
+      {
+        Reliable   = 1,
+        Unsequence = 2,
+        NoAllocate = 4
+      };
+    }
+  }
+  // synchronisable
+  template <class T>
+  class NetworkCallback;
+  class NetworkCallbackBase;
+  class NetworkCallbackManager;
+  class Synchronisable;
+  class SynchronisableHeader;
+  template <class T>
+  class SynchronisableVariable;
+  class SynchronisableVariableBase;
+  template <class T>
+  class SynchronisableVariableBidirectional;
+}

code/branches/pickup/src/libraries/network/Server.cc

-                      r5781
+                      r5935
 #include <string>
+#include "util/Clock.h"
 #include "util/Debug.h"
-#include "core/Clock.h"
 #include "core/ObjectList.h"
 #include "core/Executor.h"
 …
     packet::DeleteObjects *del = new packet::DeleteObjects();
     if(!del->fetchIDs())
+    {
+      delete del;
       return true;  //everything ok (no deletes this tick)
+    }
 //     COUT(3) << "sending DeleteObjects" << std::endl;
     while(temp != NULL){
 …
   void Server::addClient(ENetEvent *event){
+  void Server::addPeer(ENetEvent *event){
     static unsigned int newid=1;
 …
     // inform all the listeners
+    ObjectList<ClientConnectionListener>::iterator listener = ObjectList<ClientConnectionListener>::begin();
+    while(listener){
+      listener->clientConnected(newid);
+      listener++;
+    }
+    ClientConnectionListener::broadcastClientConnected(newid);
     ++newid;
 …
     createClient(temp->getID());
+}
+  void Server::removePeer(ENetEvent *event)
+  {
+    COUT(4) << "removing client from list" << std::endl;
+    ClientInformation *client = ClientInformation::findClient(&event->peer->address);
+    if(!client)
+      return;
+    else
+    {
+      //ServerConnection::disconnectClient( client );
+      ClientConnectionListener::broadcastClientDisconnected( client->getID() );
+      delete client;
+    }
+  }
   bool Server::createClient(int clientID){
 …
     ServerConnection::disconnectClient( client );
     GamestateManager::removeClient(client);
+// inform all the listeners
+    ObjectList<ClientConnectionListener>::iterator listener = ObjectList<ClientConnectionListener>::begin();
+    while(listener){
+      listener->clientDisconnected(client->getID());
+      ++listener;
+    }
+    delete client; //remove client from list
+    // inform all the listeners
+    ClientConnectionListener::broadcastClientDisconnected(client->getID());
+  }

code/branches/pickup/src/libraries/network/Server.h

-                      r5781
+                      r5935
 #include "NetworkPrereqs.h"
+#include "util/UtilPrereqs.h"
 #include "core/CorePrereqs.h"
 #include "Host.h"
 …
     unsigned int playerID(){return 0;}
+    void addClient(ENetEvent *event);
+    void addPeer(ENetEvent *event);
+    void removePeer(ENetEvent *event);
     bool createClient(int clientID);
     void disconnectClient( ClientInformation *client);

code/branches/pickup/src/libraries/network/ServerConnection.cc

-                      r5781
+                      r5935
+  {
     Connection::disconnectPeer( client->getPeer() );
-    delete client;
+  }
-  void ServerConnection::disconnectPeer( ENetEvent* event )
+  {
-    COUT(4) << "removing client from list" << std::endl;
-    ClientInformation *client = ClientInformation::findClient(&event->peer->address);
-    if(!client)
-      return;
-    else
-      ServerConnection::disconnectClient( client );
+  }
 …
     ClientInformation *client = ClientInformation::findClient(clientID);
     if(client)
       disconnectClient(client);
+      ServerConnection::disconnectClient(client);
+  }
 …
     ClientInformation *temp = ClientInformation::getBegin();
     while(temp!=0){
       disconnectClient( temp );
+      ServerConnection::disconnectClient( temp );
       temp = temp->next();
+    }
 …
           break;
         case ENET_EVENT_TYPE_DISCONNECT:
+          if(ClientInformation::findClient(&(event.peer->address)))
+            delete ClientInformation::findClient(&(event.peer->address));
+          removePeer( &event );
           temp = ClientInformation::getBegin();
           break;

code/branches/pickup/src/libraries/network/ServerConnection.h

Property svn:eol-style set to native

r5781	r5935
59	59	static bool addPacketAll(ENetPacket *packet);
60	60	virtual void disconnectClient(ClientInformation *client);
61		~~void disconnectPeer( ENetEvent* event );~~
62	61	void disconnectClient(int clientID);
63	62	protected:

code/branches/pickup/src/libraries/network/packet/CMakeLists.txt

-                      r5781
+                      r5935
 ADD_SOURCE_FILES(NETWORK_SRC_FILES
+COMPILATION_BEGIN PacketCompilation.cc
   Acknowledgement.cc
   Chat.cc
 …
   Packet.cc
   Welcome.cc
+COMPILATION_END
+)

code/branches/pickup/src/libraries/network/packet/ClassID.cc

-                      r5781
+                      r5935
   Identifier *id;
   std::string classname;
   unsigned int nrOfClasses=0;
+  unsigned int nrOfClasses=0;
   unsigned int packetSize=2*sizeof(uint32_t); //space for the packetID and for the nrofclasses
   uint32_t network_id;
   flags_ = flags_ | PACKET_FLAGS_CLASSID;
   std::queue<std::pair<uint32_t, std::string> > tempQueue;
   //calculate total needed size (for all strings and integers)
   std::map<std::string, Identifier*>::const_iterator it = Factory::getFactoryMapBegin();
   for(;it != Factory::getFactoryMapEnd();++it){
+  std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapBegin();
+  for(;it != Identifier::getStringIdentifierMapEnd();++it){
     id = (*it).second;
     if(id == NULL)
+    if(id == NULL || !id->hasFactory())
       continue;
     classname = id->getName();
     network_id = id->getNetworkID();
-    if(network_id==0)
-      COUT(3) << "we got a null class id: " << id->getName() << std::endl;
     // now push the network id and the classname to the stack
     tempQueue.push( std::pair<unsigned int, std::string>(network_id, classname) );
 …
     packetSize += (classname.size()+1)+sizeof(uint32_t)+sizeof(uint32_t);
+  }
   this->data_=new uint8_t[ packetSize ];
   //set the appropriate packet id
   assert(this->data_);
   *(Type::Value *)(this->data_ + _PACKETID ) = Type::ClassID;
   uint8_t *temp=data_+sizeof(uint32_t);
   // save the number of all classes
   *(uint32_t*)temp = nrOfClasses;
   temp += sizeof(uint32_t);
   // now save all classids and classnames
   std::pair<uint32_t, std::string> tempPair;
 …
     temp+=2*sizeof(uint32_t)+tempPair.second.size()+1;
+  }
   COUT(5) << "classid packetSize is " << packetSize << endl;
+}
 …
   temp += sizeof(uint32_t);
   totalsize += sizeof(uint32_t); // storage size for nr of all classes
   for(unsigned int i=0; i<nrOfClasses; i++){
     totalsize += 2*sizeof(uint32_t) + *(uint32_t*)(temp + sizeof(uint32_t));
 …
   uint32_t stringsize;
   unsigned char *classname;
   //clean the map of network ids
   Factory::cleanNetworkIDs();
+  //clear the map of network ids
+  Identifier::clearNetworkIDs();
   COUT(4) << "=== processing classids: " << endl;
   std::pair<uint32_t, std::string> tempPair;
 …
   nrOfClasses = *(uint32_t*)temp;
   temp += sizeof(uint32_t);
   for( int i=0; i<nrOfClasses; i++){
     networkID = *(uint32_t*)temp;

code/branches/pickup/src/libraries/network/packet/Gamestate.cc

r5781	r5935
378	378	rawDiff( dest2, dest, basep, header_->getDataSize(), base->header_->getDataSize() );
379	379	assert( memcmp( dest2, gs, dest_length) == 0 );
	380	delete dest2;
380	381	#endif
381	382

code/branches/pickup/src/libraries/network/synchronisable/Synchronisable.cc

-                      r5781
+                      r5935
   /**
   * Constructor:
   * Initializes all Variables and sets the right objectID
+  * Initializes all Variables and sets the right objectID_
   */
   Synchronisable::Synchronisable(BaseObject* creator){
+  Synchronisable::Synchronisable(BaseObject* creator ){
     RegisterRootObject(Synchronisable);
     static uint32_t idCounter=0;
 …
     if ( GameMode::isMaster() || ( Host::running() && Host::isServer() ) )
+    {
+      this->objectID = idCounter++; //this is only needed when running a server
+    //add synchronisable to the objectMap
+      objectMap_[this->objectID] = this;
+      this->setObjectID( idCounter++ );
+    }
     else
+    {
+      objectID=OBJECTID_UNKNOWN;
+      this->setObjectMode(0x0);   //make sure this object doesn't get synchronized
+    }
+    classID = static_cast<uint32_t>(-1);
+      objectID_=OBJECTID_UNKNOWN;
+    }
+    classID_ = static_cast<uint32_t>(-1);
     // set dataSize to 0
 …
     // get creator id
+    this->creatorID = OBJECTID_UNKNOWN;
+    searchcreatorID:
+    if( creator )
+      this->creatorID_ = creator->getSceneID();
+    else
+      this->creatorID_ = OBJECTID_UNKNOWN;
+    /*searchcreatorID:
     if (creator)
+    {
 …
         if (synchronisable_creator && synchronisable_creator->objectMode_)
+        {
             this->creatorID = synchronisable_creator->getObjectID();
+            this->creatorID = synchronisable_creator->getScene()->getObjectID();
+        }
         else if (creator != creator->getCreator())
 …
             goto searchcreatorID;
+        }
+    }
+    }*/
+  }
   /**
    * Destructor:
    * Delete all callback objects and remove objectID from the objectMap_
+   * Delete all callback objects and remove objectID_ from the objectMap_
    */
   Synchronisable::~Synchronisable(){
 …
       // remove object from the static objectMap
       if (this->objectMode_ != 0x0 && (Host::running() && Host::isServer()))
         deletedObjects_.push(objectID);
+        deletedObjects_.push(objectID_);
+    }
     // delete all Synchronisable Variables from syncList ( which are also in stringList )
 …
     stringList.clear();
     std::map<uint32_t, Synchronisable*>::iterator it;
     it = objectMap_.find(objectID);
+    it = objectMap_.find(objectID_);
     if (it != objectMap_.end())
       objectMap_.erase(it);
 …
     Synchronisable *no = orxonox_cast<Synchronisable*>(bo);
     assert(no);
+    no->objectID=header.getObjectID();
+    no->creatorID=header.getCreatorID(); //TODO: remove this
+    no->classID=header.getClassID();
+    COUT(4) << "fabricate objectID: " << no->objectID << " classID: " << no->classID << std::endl;
+    assert( Synchronisable::objectMap_.find(header.getObjectID()) == Synchronisable::objectMap_.end() );
+    no->setObjectID(header.getObjectID());
+    //no->creatorID=header.getCreatorID(); //TODO: remove this
+    no->setClassID(header.getClassID());
+    assert(no->creatorID_ == header.getCreatorID());
+    //assert(no->classID_ == header.getClassID());
+    COUT(4) << "fabricate objectID_: " << no->objectID_ << " classID_: " << no->classID_ << std::endl;
           // update data and create object/entity...
-    assert( Synchronisable::objectMap_.find(header.getObjectID()) == Synchronisable::objectMap_.end() );
-    Synchronisable::objectMap_[header.getObjectID()] = no;
     bool b = no->updateData(mem, mode, true);
     assert(b);
 …
   /**
    * Finds and deletes the Synchronisable with the appropriate objectID
    * @param objectID objectID of the Synchronisable
+   * Finds and deletes the Synchronisable with the appropriate objectID_
+   * @param objectID_ objectID_ of the Synchronisable
    * @return true/false
    */
   bool Synchronisable::deleteObject(uint32_t objectID){
     if(!getSynchronisable(objectID))
+  bool Synchronisable::deleteObject(uint32_t objectID_){
+    if(!getSynchronisable(objectID_))
       return false;
     assert(getSynchronisable(objectID)->objectID==objectID);
     Synchronisable *s = getSynchronisable(objectID);
+    assert(getSynchronisable(objectID_)->objectID_==objectID_);
+    Synchronisable *s = getSynchronisable(objectID_);
     if(s)
       delete s;
+      s->destroy(); // or delete?
     else
       return false;
 …
   /**
    * This function looks up the objectID in the objectMap_ and returns a pointer to the right Synchronisable
    * @param objectID objectID of the Synchronisable
    * @return pointer to the Synchronisable with the objectID
    */
   Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID){
+   * This function looks up the objectID_ in the objectMap_ and returns a pointer to the right Synchronisable
+   * @param objectID_ objectID_ of the Synchronisable
+   * @return pointer to the Synchronisable with the objectID_
+   */
+  Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID_){
     std::map<uint32_t, Synchronisable*>::iterator it1;
     it1 = objectMap_.find(objectID);
+    it1 = objectMap_.find(objectID_);
     if (it1 != objectMap_.end())
       return it1->second;
 …
 //     ObjectList<Synchronisable>::iterator it;
 //     for(it = ObjectList<Synchronisable>::begin(); it; ++it){
 //       if( it->getObjectID()==objectID ){
 //         objectMap_[objectID] = *it;
+//       if( it->getObjectID()==objectID_ ){
+//         objectMap_[objectID_] = *it;
 //         return *it;
 //       }
 …
   /**
    * This function takes all SynchronisableVariables out of the Synchronisable and saves them together with the size, objectID and classID to the given memory
+   * This function takes all SynchronisableVariables out of the Synchronisable and saves them together with the size, objectID_ and classID_ to the given memory
    * takes a pointer to already allocated memory (must have at least getSize bytes length)
    * structure of the bitstream:
    * |totalsize,objectID,classID,var1,var2,string1_length,string1,var3,...|
+   * |totalsize,objectID_,classID_,var1,var2,string1_length,string1,var3,...|
    * length of varx: size saved int syncvarlist
    * @param mem pointer to allocated memory with enough size
 …
     uint32_t tempsize = 0;
 #ifndef NDEBUG
     if (this->classID==0)
+    if (this->classID_==0)
       COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
 #endif
+    if (this->classID == static_cast<uint32_t>(-1))
+        this->classID = this->getIdentifier()->getNetworkID();
+    assert(ClassByID(this->classID));
+    assert(this->classID==this->getIdentifier()->getNetworkID());
+    if (this->classID_ == static_cast<uint32_t>(-1))
+        this->classID_ = this->getIdentifier()->getNetworkID();
+    assert(ClassByID(this->classID_));
+    assert(this->classID_==this->getIdentifier()->getNetworkID());
+    assert(this->objectID_!=OBJECTID_UNKNOWN);
     std::vector<SynchronisableVariableBase*>::iterator i;
 …
     COUT(5) << "Synchronisable getting data from objectID: " << objectID << " classID: " << classID << std::endl;
+    COUT(5) << "Synchronisable getting data from objectID_: " << objectID_ << " classID_: " << classID_ << std::endl;
     // copy to location
     for(i=syncList.begin(); i!=syncList.end(); ++i){
 …
     tempsize += SynchronisableHeader::getSize();
     header.setObjectID( this->objectID );
     header.setCreatorID( this->creatorID );
     header.setClassID( this->classID );
+    header.setObjectID( this->objectID_ );
+    header.setCreatorID( this->creatorID_ );
+    header.setClassID( this->classID_ );
     header.setDataAvailable( true );
     header.setDataSize( tempsize );
 …
     // start extract header
     SynchronisableHeader syncHeader(mem);
     assert(syncHeader.getObjectID()==this->objectID);
     assert(syncHeader.getCreatorID()==this->creatorID);
     assert(syncHeader.getClassID()==this->classID);
+    assert(syncHeader.getObjectID()==this->objectID_);
+    assert(syncHeader.getCreatorID()==this->creatorID_);
+    assert(syncHeader.getClassID()==this->classID_);
     if(syncHeader.isDataAvailable()==false){
       mem += syncHeader.getDataSize();
 …
     // stop extract header
     //COUT(5) << "Synchronisable: objectID " << syncHeader.getObjectID() << ", classID " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << std::endl;
+    //COUT(5) << "Synchronisable: objectID_ " << syncHeader.getObjectID() << ", classID_ " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << std::endl;
     for(i=syncList.begin(); i!=syncList.end(); i++)
+    {
 …
     if(mode==0x0)
       mode=state_;
     return ( (objectMode_&mode)!=0 && (!syncList.empty() ) );
+  }
   /**
    * This function looks at the header located in the bytestream and checks wheter objectID and classID match with the Synchronisables ones
+    return ( (this->objectMode_ & mode)!=0 && (!syncList.empty() ) );
+  }
+  /**
+   * This function looks at the header located in the bytestream and checks wheter objectID_ and classID_ match with the Synchronisables ones
    * @param mem pointer to the bytestream
    */
 …
+  {
     SynchronisableHeader header(mem);
     assert(header.getObjectID()==this->objectID);
+    assert(header.getObjectID()==this->objectID_);
     return header.isDataAvailable();
+  }
 …
    * @param mode same as in registerVar
    */
   void Synchronisable::setObjectMode(uint8_t mode){
+  void Synchronisable::setSyncMode(uint8_t mode){
     assert(mode==0x0 || mode==0x1 || mode==0x2 || mode==0x3);
     objectMode_=mode;
+    this->objectMode_=mode;
+  }

code/branches/pickup/src/libraries/network/synchronisable/Synchronisable.h

-                      r5781
+                      r5935
    * @brief: stores information about a Synchronisable
+   *
    * This class stores the information about a Synchronisable (objectID, classID, creatorID, dataSize)
+   * This class stores the information about a Synchronisable (objectID_, classID_, creatorID_, dataSize)
    * in an emulated bitset.
    * Bit 1 to 31 store the size of the Data the synchronisable consumes in the stream
    * Bit 32 is a bool and defines whether the data is actually stored or is just filled up with 0
    * Byte 5 to 8: objectID
    * Byte 9 to 12: classID
    * Byte 13 to 16: creatorID
+   * Byte 5 to 8: objectID_
+   * Byte 9 to 12: classID_
+   * Byte 13 to 16: creatorID_
    */
   class _NetworkExport SynchronisableHeader{
 …
       inline uint32_t getObjectID() const
         { return *(uint32_t*)(data_+4); }
       inline void setObjectID(uint32_t objectID)
         { *(uint32_t*)(data_+4) = objectID; }
+      inline void setObjectID(uint32_t objectID_)
+        { *(uint32_t*)(data_+4) = objectID_; }
       inline uint32_t getClassID() const
         { return *(uint32_t*)(data_+8); }
       inline void setClassID(uint32_t classID)
         { *(uint32_t*)(data_+8) = classID; }
+      inline void setClassID(uint32_t classID_)
+        { *(uint32_t*)(data_+8) = classID_; }
       inline uint32_t getCreatorID() const
         { return *(uint32_t*)(data_+12); }
       inline void setCreatorID(uint32_t creatorID)
         { *(uint32_t*)(data_+12) = creatorID; }
+      inline void setCreatorID(uint32_t creatorID_)
+        { *(uint32_t*)(data_+12) = creatorID_; }
       inline void operator=(SynchronisableHeader& h)
         { memcpy(data_, h.data_, getSize()); }
 …
     static Synchronisable *fabricate(uint8_t*& mem, uint8_t mode=0x0);
     static bool deleteObject(uint32_t objectID);
     static Synchronisable *getSynchronisable(uint32_t objectID);
+    static bool deleteObject(uint32_t objectID_);
+    static Synchronisable *getSynchronisable(uint32_t objectID_);
     static unsigned int getNumberOfDeletedObject(){ return deletedObjects_.size(); }
     static uint32_t popDeletedObject(){ uint32_t i = deletedObjects_.front(); deletedObjects_.pop(); return i; }
+    inline uint32_t getObjectID() const {return objectID;}
+    inline unsigned int getCreatorID() const {return creatorID;}
+    inline uint32_t getClassID() const {return classID;}
+    inline unsigned int getPriority() const { return objectFrequency_;}
+    inline uint32_t getObjectID() const {return this->objectID_;}
+    inline unsigned int getCreatorID() const {return this->creatorID_;}
+    inline uint32_t getClassID() const {return this->classID_;}
+    inline unsigned int getPriority() const { return this->objectFrequency_;}
+    inline uint8_t getSyncMode() const { return this->objectMode_; }
+    void setSyncMode(uint8_t mode);
   protected:
 …
     template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
     //template <class T> void unregisterVariable(T& var);
-    void setObjectMode(uint8_t mode);
     void setPriority(unsigned int freq){ objectFrequency_ = freq; }
 …
     bool isMyData(uint8_t* mem);
     bool doSync(int32_t id, uint8_t mode=0x0);
+    uint32_t objectID;
+    uint32_t creatorID;
+    uint32_t classID;
+    inline void setObjectID(uint32_t id){ this->objectID_ = id; objectMap_[this->objectID_] = this; }
+    inline void setClassID(uint32_t id){ this->classID_ = id; }
+    uint32_t objectID_;
+    uint32_t creatorID_;
+    uint32_t classID_;
     std::vector<SynchronisableVariableBase*> syncList;

code/branches/pickup/src/libraries/tools/CMakeLists.txt

-                      r5781
+                      r5935
+ADD_SOURCE_FILES(TOOLS_SRC_FILES
+SET_SOURCE_FILES(TOOLS_SRC_FILES
+COMPILATION_BEGIN ResourceCompilation.cc
+  ResourceCollection.cc
+  ResourceLocation.cc
+COMPILATION_END
+  TextureGenerator.cc
+  Timer.cc
+COMPILATION_BEGIN OgreCompilation.cc
   BillboardSet.cc
   DynamicLines.cc
 …
   Mesh.cc
   ParticleInterface.cc
-  ResourceCollection.cc
-  ResourceLocation.cc
   Shader.cc
+  TextureGenerator.cc
+  Timer.cc
+COMPILATION_END
+)
 ADD_SUBDIRECTORY(interfaces)
 …
 ORXONOX_ADD_LIBRARY(tools
   FIND_HEADER_FILES
-  PCH_FILE
-    ToolsPrecompiledHeaders.h
   DEFINE_SYMBOL
     "TOOLS_SHARED_BUILD"

code/branches/pickup/src/libraries/tools/ResourceLocation.cc

-                      r5781
+                      r5935
 #include "util/Exception.h"
-#include "core/Core.h"
 #include "core/CoreIncludes.h"
+#include "core/PathConfig.h"
 #include "core/XMLFile.h"
 #include "core/XMLPort.h"
 …
         // Find the path
+        boost::filesystem::path path;
+        if (boost::filesystem::exists(Core::getDataPath() / this->getPath()))
+            path = Core::getDataPath() / this->getPath();
+        else if (Core::isDevelopmentRun() && boost::filesystem::exists(Core::getExternalDataPath() / this->getPath()))
+            path = Core::getExternalDataPath() / this->getPath();
+        namespace bf = boost::filesystem;
+        bf::path path;
+        if (bf::exists(PathConfig::getDataPath() / this->getPath()))
+            path = PathConfig::getDataPath() / this->getPath();
+        else if (PathConfig::isDevelopmentRun() && bf::exists(PathConfig::getExternalDataPath() / this->getPath()))
+            path = PathConfig::getExternalDataPath() / this->getPath();
         else
+        {

code/branches/pickup/src/libraries/tools/Timer.cc

-                      r5781
+                      r5935
 #include <set>
+#include "util/Clock.h"
 #include "core/CoreIncludes.h"
 #include "core/ConsoleCommand.h"
 #include "core/CommandExecutor.h"
-#include "core/Clock.h"
 #include "core/Functor.h"
 …
     SetConsoleCommandShortcutExtern(killdelays);
     static std::set<StaticTimer*> delaytimerset;
+    static std::set<Timer*> delaytimerset;
     /**
 …
     void delay(float delay, const std::string& command)
+    {
         StaticTimer *delaytimer = new StaticTimer();
+        Timer* delaytimer = new Timer();
         delaytimerset.insert(delaytimer);
 …
         @param command The command to execute
     */
     void executeDelayedCommand(StaticTimer* timer, const std::string& command)
+    void executeDelayedCommand(Timer* timer, const std::string& command)
+    {
         CommandExecutor::execute(command);
         delete timer;
+        timer->destroy();
         delaytimerset.erase(timer);
+    }
 …
     void killdelays()
+    {
         for (std::set<StaticTimer*>::iterator it = delaytimerset.begin(); it != delaytimerset.end(); ++it)
             delete (*it);
+        for (std::set<Timer*>::iterator it = delaytimerset.begin(); it != delaytimerset.end(); ++it)
+            (*it)->destroy();
         delaytimerset.clear();
 …
         @brief Constructor: Sets the default-values.
     */
+    TimerBase::TimerBase()
+    Timer::Timer()
+    {
+        this->init();
+        RegisterObject(Timer);
+    }
+    /**
+        @brief Constructor: Initializes the Timer with given values.
+        @param interval The timer-interval in seconds
+        @param bLoop If true, the function gets called every 'interval' seconds
+        @param exeuctor A executor of the function to call
+    */
+    Timer::Timer(float interval, bool bLoop, Executor* executor, bool bKillAfterCall)
+    {
+        this->init();
+        RegisterObject(Timer);
+        this->setTimer(interval, bLoop, executor, bKillAfterCall);
+    }
+    /**
+        @brief Deletes the executor.
+    */
+    Timer::~Timer()
+    {
+        this->deleteExecutor();
+    }
+    /**
+        @brief Initializes the Timer
+    */
+    void Timer::init()
+    {
         this->executor_ = 0;
 …
         this->time_ = 0;
-        RegisterObject(TimerBase);
+    }
-    /**
-        @brief Deletes the executor.
-    */
-    TimerBase::~TimerBase()
+    {
-        this->deleteExecutor();
+    }
 …
         @brief Executes the executor.
     */
     void TimerBase::run() const
+    void Timer::run()
+    {
         bool temp = this->bKillAfterCall_; // to avoid errors with bKillAfterCall_=false and an exutors which destroy the timer
 …
         if (temp)
             delete this;
+            this->destroy();
+    }
 …
         @brief Deletes the executor.
     */
     void TimerBase::deleteExecutor()
+    void Timer::deleteExecutor()
+    {
       if (this->executor_)
 …
         @brief Updates the timer before the frames are rendered.
     */
     void TimerBase::tick(const Clock& time)
+    void Timer::tick(const Clock& time)
+    {
         if (this->bActive_)

code/branches/pickup/src/libraries/tools/Timer.h

-                      r5781
+                      r5935
                 ClassName();
                 void functionName();
                 Timer<ClassName> myTimer;
+                Timer myTimer;
         };
 …
         ClassName::ClassName()
+        {
             myTimer.setTimer(interval_in_seconds, bLoop, this, createExecutor(createFunctor(&ClassName::functionName)));
+            myTimer.setTimer(interval_in_seconds, bLoop, createExecutor(createFunctor(&ClassName::functionName, this)));
+        }
 …
 namespace orxonox
+{
-    class StaticTimer;
     void delay(float delay, const std::string& command);
     void killdelays();
     void executeDelayedCommand(StaticTimer* timer, const std::string& command);
+    void executeDelayedCommand(Timer* timer, const std::string& command);
     //! TimerBase is the parent of the Timer class.
     class _ToolsExport TimerBase : public TimeFactorListener
+    //! The Timer is a callback-object, calling a given function after a given time-interval.
+    class _ToolsExport Timer : public TimeFactorListener
+    {
         public:
+            ~TimerBase();
+            Timer();
+            ~Timer();
+            void run() const;
+            Timer(float interval, bool bLoop, Executor* executor, bool bKillAfterCall = false);
+            /**
+                @brief Initializes the Timer with given values.
+                @param interval The timer-interval in seconds
+                @param bLoop If true, the function gets called every 'interval' seconds
+                @param object The object owning the timer and the function
+                @param executor A executor of the function to call
+            */
+            void setTimer(float interval, bool bLoop, Executor* executor, bool bKillAfterCall = false)
+            {
+                this->deleteExecutor();
+                this->setInterval(interval);
+                this->bLoop_ = bLoop;
+                this->executor_ = executor;
+                this->bActive_ = true;
+                this->time_ = this->interval_;
+                this->bKillAfterCall_ = bKillAfterCall;
+            }
+            void run();
             void deleteExecutor();
 …
             void tick(const Clock& time);
         protected:
             TimerBase();
+        private:
+            void init();
             Executor* executor_;  //!< The executor of the function that should be called when the time expires
 …
             long long time_;      //!< Internal variable, counting the time till the next function-call
     };
-    //! The Timer is a callback-object, calling a given function after a given time-interval.
-    template <class T = BaseObject>
-    class Timer : public TimerBase
+    {
-        public:
-            Timer() {}
-            /**
-                @brief Constructor: Initializes the Timer with given values.
-                @param interval The timer-interval in seconds
-                @param bLoop If true, the function gets called every 'interval' seconds
-                @param object The object owning the timer and the function
-                @param exeuctor A executor of the function to call
-            */
-            Timer(float interval, bool bLoop, T* object, ExecutorMember<T>* exeuctor, bool bKillAfterCall = false)
+            {
-                this->setTimer(interval, bLoop, object, exeuctor, bKillAfterCall);
+            }
-            /**
-                @brief Initializes the Timer with given values.
-                @param interval The timer-interval in seconds
-                @param bLoop If true, the function gets called every 'interval' seconds
-                @param object The object owning the timer and the function
-                @param exeuctor A executor of the function to call
-            */
-            void setTimer(float interval, bool bLoop, T* object, ExecutorMember<T>* executor, bool bKillAfterCall = false)
+            {
-                this->deleteExecutor();
-                this->setInterval(interval);
-                this->bLoop_ = bLoop;
-                executor->setObject(object);
-                this->executor_ = static_cast<Executor*>(executor);
-                this->bActive_ = true;
-                this->time_ = this->interval_;
-                this->bKillAfterCall_ = bKillAfterCall;
+            }
-    };
-    //! The StaticTimer is a callback-object, calling a static function after a given time-interval.
-    class _ToolsExport StaticTimer : public TimerBase
+    {
-        public:
-            StaticTimer() {}
-            /**
-                @brief Constructor: Initializes the Timer with given values.
-                @param interval The timer-interval in seconds
-                @param bLoop If true, the function gets called every 'interval' seconds
-                @param exeuctor A executor of the function to call
-            */
-            StaticTimer(float interval, bool bLoop, ExecutorStatic* executor, bool bKillAfterCall = false)
+            {
-                this->setTimer(interval, bLoop, executor, bKillAfterCall);
+            }
-            /**
-                @brief Initializes the Timer with given values.
-                @param interval The timer-interval in seconds
-                @param bLoop If true, the function gets called every 'interval' seconds
-                @param object The object owning the timer and the function
-                @param executor A executor of the function to call
-            */
-            void setTimer(float interval, bool bLoop, ExecutorStatic* executor, bool bKillAfterCall = false)
+            {
-                this->deleteExecutor();
-                this->setInterval(interval);
-                this->bLoop_ = bLoop;
-                this->executor_ = executor;
-                this->bActive_ = true;
-                this->time_ = this->interval_;
-                this->bKillAfterCall_ = bKillAfterCall;
+            }
-    };
+}

code/branches/pickup/src/libraries/tools/ToolsPrereqs.h

-                      r5781
+                      r5935
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the tools module
 */
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
 #  ifdef TOOLS_SHARED_BUILD
 …
 //-----------------------------------------------------------------------
 // Forward declarations
+// Enums
 //-----------------------------------------------------------------------
 …
         };
+    }
+}
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+namespace orxonox
+{
     class BillboardSet;
     class Mesh;
     class ParticleInterface;
+    class ResourceCollection;
+    class ResourceLocation;
     class Shader;
+    template <class T>
+    class Tickable;
+    class TimeFactorListener;
     class Timer;
-    class StaticTimer;
+}

code/branches/pickup/src/libraries/util/CMakeLists.txt

-                      r5781
+                      r5935
 SET_SOURCE_FILES(UTIL_SRC_FILES
-  Clipboard.cc
-  CRC32.cc
   Exception.cc
-  ExprParser.cc
   Math.cc
   MultiType.cc
+  Scope.cc
+  StringUtils.cc
+COMPILATION_BEGIN StableCompilation.cc
+  Clipboard.cc
+  Clock.cc
+  CRC32.cc
+  ExprParser.cc
   OutputBuffer.cc
   OutputHandler.cc
-  Scope.cc
   SignalHandler.cc
   Sleep.cc
-  StringUtils.cc
   SubString.cc
+COMPILATION_END
+)

code/branches/pickup/src/libraries/util/Scope.h

-                      r5738
+                      r5935
 #include "UtilPrereqs.h"
 #include <cassert>
+#include <map>
 #include <set>
+#include <map>
 #include "Debug.h"
+#include "ScopeGuard.h"
 namespace orxonox
+{
-    namespace ScopeID
+    {
-        /**
-            @brief A list of available scopes for the Scope template.
-        */
-        enum Value
+        {
-            GSRoot,
-            GSGraphics,
-            GSLevel
-        };
+    }
-    class ScopeListener; // Forward declaration
     /**
         @brief The ScopeManager stores the variables of the scope templates in a statically linked context.
 …
         protected:
             //! Constructor: Registers the instance.
             ScopeListener(ScopeID::Value scope) : scope_(scope)
+            ScopeListener(ScopeID::Value scope) : scope_(scope), bActivated_(false)
                 { ScopeManager::listeners_s[this->scope_].insert(this); }
             //! Destructor: Unregisters the instance.
 …
         private:
             ScopeID::Value scope_; //!< Store the scope to unregister on destruction
+            bool bActivated_;
     };
 …
             Scope()
+            {
+                ScopeManager::instanceCounts_s[scope]++;
+                assert(ScopeManager::instanceCounts_s[scope] > 0);
+                if (ScopeManager::instanceCounts_s[scope] == 1)
+                try
+                {
+                    for (typename std::set<ScopeListener*>::iterator it = ScopeManager::listeners_s[scope].begin(); it != ScopeManager::listeners_s[scope].end(); )
+                        (*(it++))->activated();
+                    ScopeManager::instanceCounts_s[scope]++;
+                    assert(ScopeManager::instanceCounts_s[scope] > 0);
+                    if (ScopeManager::instanceCounts_s[scope] == 1)
+                    {
+                        Loki::ScopeGuard deactivator = Loki::MakeObjGuard(*this, &Scope::deactivateListeners);
+                        for (typename std::set<ScopeListener*>::iterator it = ScopeManager::listeners_s[scope].begin(); it != ScopeManager::listeners_s[scope].end(); )
+                        {
+                            (*it)->activated();
+                            (*(it++))->bActivated_ = true;
+                        }
+                        deactivator.Dismiss();
+                    }
+                }
+                catch (...)
+                {
+                    ScopeManager::instanceCounts_s[scope]--;
+                    throw;
+                }
+            }
 …
                 if (ScopeManager::instanceCounts_s[scope] == 0)
+                    this->deactivateListeners();
+            }
+            void deactivateListeners()
+            {
+                for (typename std::set<ScopeListener*>::iterator it = ScopeManager::listeners_s[scope].begin(); it != ScopeManager::listeners_s[scope].end(); )
+                {
+                    for (typename std::set<ScopeListener*>::iterator it = ScopeManager::listeners_s[scope].begin(); it != ScopeManager::listeners_s[scope].end(); )
+                        (*(it++))->deactivated();
+                    if ((*it)->bActivated_)
+                    {
+                        try
+                            { (*it)->deactivated(); }
+                        catch (...)
+                            { COUT(0) << "ScopeListener::deactivated() failed! This MUST NOT happen, fix it!" << std::endl; }
+                        (*(it++))->bActivated_ = false;
+                    }
+                    else
+                        ++it;
+                }
+            }

code/branches/pickup/src/libraries/util/Singleton.h

-                      r5738
+                      r5935
+        }
+        //! Update method called by ClassSingletonManager (if used)
+        void updateSingleton(const Clock& time) { static_cast<T*>(T::singletonPtr_s)->update(time); }
+        //! Empty update method for the static polymorphism
+        void update(const Clock& time) { }
     protected:
         //! Constructor sets the singleton instance pointer

code/branches/pickup/src/libraries/util/UtilPrereqs.h

-                      r5738
+                      r5935
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the util library
 */
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined( UTIL_STATIC_BUILD )
 #  ifdef UTIL_SHARED_BUILD
 …
 #endif
+//-----------------------------------------------------------------------
+// Enums
+//-----------------------------------------------------------------------
+namespace orxonox
+{
+    namespace ScopeID
+    {
+        //!A list of available scopes for the Scope template.
+        enum Value
+        {
+            Root,
+            Graphics
+        };
+    }
+}
 //-----------------------------------------------------------------------
 …
 namespace orxonox
+{
+    class Clock;
     class Exception;
     class ExprParser;
 …
     class OutputBufferListener;
     class OutputHandler;
+    template <ScopeID::Value>
+    class Scope;
+    template <class, ScopeID::Value>
+    class ScopedSingleton;
+    class ScopeListener;
     class SignalHandler;
+    template <class T>
+    class Singleton;
     class SubString;
+}

Context Navigation

Legend:

Download in other formats: