Index: code/trunk/src/libraries/core/BaseObject.cc
===================================================================
--- code/trunk/src/libraries/core/BaseObject.cc	(revision 6763)
+++ code/trunk/src/libraries/core/BaseObject.cc	(revision 6800)
@@ -103,4 +103,11 @@
         }
     }
+    
+    /** @brief Adds an object which listens to the events of this object. */
+    void BaseObject::registerEventListener(BaseObject* object)
+    {
+        COUT(4) << "New EventListener: " << object->getIdentifier()->getName() << " &(" << object << ")." << std::endl;
+        this->eventListeners_.insert(object);
+    }
 
     /**
@@ -356,4 +363,6 @@
     {
         this->registerEventStates();
+        
+        COUT(4) << this->getIdentifier()->getName() << " (&" << this << ") processing event. originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << "." << std::endl;
 
         std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(event.statename_);
Index: code/trunk/src/libraries/core/BaseObject.h
===================================================================
--- code/trunk/src/libraries/core/BaseObject.h	(revision 6763)
+++ code/trunk/src/libraries/core/BaseObject.h	(revision 6800)
@@ -188,6 +188,5 @@
         private:
             /** @brief Adds an object which listens to the events of this object. */
-            inline void registerEventListener(BaseObject* object)
-                { this->eventListeners_.insert(object); }
+            void registerEventListener(BaseObject* object);
             /** @brief Removes an event listener from this object. */
             inline void unregisterEventListener(BaseObject* object)
Index: code/trunk/src/libraries/core/Event.cc
===================================================================
--- code/trunk/src/libraries/core/Event.cc	(revision 6763)
+++ code/trunk/src/libraries/core/Event.cc	(revision 6800)
@@ -59,16 +59,22 @@
         this->bProcessingEvent_ = true;
 
+        COUT(4) << "Processing event (EventState) : originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << ", object: " << object->getIdentifier()->getName() << " (&" << object << ")" << ", subclass: " << this->subclass_->getName() << ", (?): " << event.originator_->isA(this->subclass_) << "." << std::endl;
+        
         // check if the originator is an instance of the requested class
         if (event.originator_->isA(this->subclass_))
         {
+            // If the EventState doesn't act as an EventSink.
             // actualize the activationcounter
-            if (event.activate_)
-                ++this->activeEvents_;
-            else
+            if(!this->bSink_)
             {
-                --this->activeEvents_;
+                if (event.activate_)
+                    ++this->activeEvents_;
+                else
+                {
+                    --this->activeEvents_;
 
-                if (this->activeEvents_ < 0)
-                    this->activeEvents_ = 0;
+                    if (this->activeEvents_ < 0)
+                        this->activeEvents_ = 0;
+                }
             }
 
@@ -78,5 +84,5 @@
                 (*this->statefunction_)();
             }
-            else if ((this->activeEvents_ == 1 && event.activate_) || (this->activeEvents_ == 0 && !event.activate_))
+            else if (this->bSink_ || (!this->bSink_ && ((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]
@@ -84,5 +90,5 @@
                 {
                     // one argument: just the eventstate
-                    (*this->statefunction_)(this->activeEvents_);
+                    (*this->statefunction_)(event.activate_);
                 }
                 else if (this->statefunction_->getParamCount() >= 2)
@@ -92,5 +98,5 @@
                     {
                         // if the subclass is BaseObject, we don't have to cast the pointer
-                        (*this->statefunction_)(this->activeEvents_, event.originator_);
+                        (*this->statefunction_)(event.activate_, event.originator_);
                     }
                     else
@@ -98,5 +104,5 @@
                         // else cast the pointer to the desired class
                         void* castedOriginator = event.originator_->getDerivedPointer(this->subclass_->getClassID());
-                        (*this->statefunction_)(this->activeEvents_, castedOriginator);
+                        (*this->statefunction_)(event.activate_, castedOriginator);
                     }
                 }
Index: code/trunk/src/libraries/core/Event.h
===================================================================
--- code/trunk/src/libraries/core/Event.h	(revision 6763)
+++ code/trunk/src/libraries/core/Event.h	(revision 6800)
@@ -46,4 +46,5 @@
         BaseObject* originator_; //!< The object which triggered this event
         std::string name_;       //!< The name of this event
+
     };
 
@@ -66,5 +67,5 @@
     {
         public:
-            EventState(Functor* statefunction, Identifier* subclass) : bProcessingEvent_(false), activeEvents_(0), statefunction_(statefunction), subclass_(subclass) {}
+            EventState(Functor* statefunction, Identifier* subclass, bool bSink = false) : bProcessingEvent_(false), activeEvents_(0), statefunction_(statefunction), subclass_(subclass), bSink_(bSink) {}
             virtual ~EventState();
 
@@ -79,4 +80,5 @@
             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)
+            bool        bSink_;             //!< Determines whether the EventState acts as an EventSink forwarding any Event (even if the state didn't change) or in the normal manner, only processing Events that change the state.
     };
 }
Index: code/trunk/src/libraries/core/EventIncludes.h
===================================================================
--- code/trunk/src/libraries/core/EventIncludes.h	(revision 6763)
+++ code/trunk/src/libraries/core/EventIncludes.h	(revision 6800)
@@ -52,7 +52,17 @@
     } \
     XMLPortEventStateIntern(xmlportevent##function, classname, statename, xmlelement, mode)
+    
+#define XMLPortEventSink(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(), true); \
+        this->addEventState(statename, containername##function); \
+    } \
+    XMLPortEventStateIntern(xmlportevent##function, classname, statename, xmlelement, mode)
 
 /**
-    @brief Like XMLPortEventState but with additional template arguments to identify the function of the state (if ambiguous).
+    @brief Like XMLPortEventState but creates an event sink instead of an event state.
+           The most important destinction between an EventState and an EventSink is, that an EventState only processes event which change the state of the EventState, where as an EventSink is an EventState that processes any Event that reaches it.
 */
 #define XMLPortEventStateTemplate(classname, subclassname, statename, function, xmlelement, mode, ...) \
