diff --git a/Core/Code/Interactions/mitkDispatcher.cpp b/Core/Code/Interactions/mitkDispatcher.cpp
index efa5e83b82..e14376a7de 100644
--- a/Core/Code/Interactions/mitkDispatcher.cpp
+++ b/Core/Code/Interactions/mitkDispatcher.cpp
@@ -1,234 +1,230 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
 #include "mitkDispatcher.h"
 #include "mitkInteractionEvent.h"
 #include "mitkInternalEvent.h"
 
 // MicroServices
 #include "mitkGetModuleContext.h"
 #include "mitkModule.h"
 #include "mitkModuleRegistry.h"
 
 #include "mitkInteractionEventObserver.h"
 
 
 mitk::Dispatcher::Dispatcher() :
     m_ProcessingMode(REGULAR), m_EventObserverTracker(GetModuleContext())
 {
-  // get service to inform InteractionEventObserver
-  mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
-  mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::InformerService>();
-
   m_EventObserverTracker.Open();
 }
 
 void mitk::Dispatcher::AddDataInteractor(const DataNode* dataNode)
 {
   RemoveDataInteractor(dataNode);
   RemoveOrphanedInteractors();
   DataInteractor::Pointer dataInteractor = dataNode->GetDataInteractor();
   if (dataInteractor.IsNotNull())
   {
     m_Interactors.push_back(dataInteractor);
   }
 }
 
 /*
  * Note: One DataInteractor can only have one DataNode and vice versa,
  * BUT the m_Interactors list may contain another DataInteractor that is still connected to this DataNode,
  * in this case we have to remove >1 DataInteractor. (Some special case of switching DataNodes between DataInteractors and registering a
  * DataNode to a DataStorage after assigning it to an DataInteractor)
  */
 
 void mitk::Dispatcher::RemoveDataInteractor(const DataNode* dataNode)
 {
   for (ListInteractorType::iterator it = m_Interactors.begin(); it != m_Interactors.end();)
   {
     if ((*it)->GetDataNode() == dataNode)
     {
       it = m_Interactors.erase(it);
     }
     else
     {
       ++it;
     }
   }
 }
 
 size_t mitk::Dispatcher::GetNumberOfInteractors()
 {
   return m_Interactors.size();
 }
 
 mitk::Dispatcher::~Dispatcher()
 {
 }
 
 bool mitk::Dispatcher::ProcessEvent(InteractionEvent* event)
 {
   InteractionEvent::Pointer p = event;
   //MITK_INFO << event->GetEventClass();
   bool eventIsHandled = false;
   /* Filter out and handle Internal Events separately */
   InternalEvent* internalEvent = dynamic_cast<InternalEvent*>(event);
   if (internalEvent != NULL)
   {
     eventIsHandled = HandleInternalEvent(internalEvent);
     // InternalEvents that are handled are not sent to the listeners
     if (eventIsHandled)
     {
       return true;
     }
   }
   switch (m_ProcessingMode)
   {
   case CONNECTEDMOUSEACTION:
     // finished connected mouse action
     if (p->GetEventClass() == "MouseReleaseEvent")
     {
       m_ProcessingMode = REGULAR;
       eventIsHandled = m_SelectedInteractor->HandleEvent(event, m_SelectedInteractor->GetDataNode());
     }
     // give event to selected interactor
     if (eventIsHandled == false)
     {
       eventIsHandled = m_SelectedInteractor->HandleEvent(event, m_SelectedInteractor->GetDataNode());
     }
     break;
 
   case GRABINPUT:
     eventIsHandled = m_SelectedInteractor->HandleEvent(event, m_SelectedInteractor->GetDataNode());
     SetEventProcessingMode(m_SelectedInteractor);
     break;
 
   case PREFERINPUT:
     if (m_SelectedInteractor->HandleEvent(event, m_SelectedInteractor->GetDataNode()) == true)
     {
       SetEventProcessingMode(m_SelectedInteractor);
       eventIsHandled = true;
     }
     break;
 
   case REGULAR:
     break;
   }
   // Standard behavior. Is executed in STANDARD mode  and PREFERINPUT mode, if preferred interactor rejects event.
   if (m_ProcessingMode == REGULAR || (m_ProcessingMode == PREFERINPUT && eventIsHandled == false))
   {
 
     m_Interactors.sort(cmp()); // sorts interactors by layer (descending);
     for (std::list<DataInteractor::Pointer>::iterator it = m_Interactors.begin(); it != m_Interactors.end(); ++it)
     {
       // explicit copy of pointer because HandleEvent function causes the m_Interactors list to be updated,
       // which in turn invalidates the iterator.
       DataInteractor::Pointer dataInteractor = *it;
       if (dataInteractor->HandleEvent(event, dataInteractor->GetDataNode()))
       { // if an event is handled several properties are checked, in order to determine the processing mode of the dispatcher
         SetEventProcessingMode(dataInteractor);
         if (p->GetEventClass() == "MousePressEvent" && m_ProcessingMode == REGULAR)
         {
           m_SelectedInteractor = dataInteractor;
           m_ProcessingMode = CONNECTEDMOUSEACTION;
         }
         eventIsHandled = true;
         break;
       }
     }
   }
 
   /* Notify InteractionEventObserver  */
   std::list<mitk::ServiceReference> listEventObserver;
   m_EventObserverTracker.GetServiceReferences(listEventObserver);
   for (std::list<mitk::ServiceReference>::iterator it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
   {
+
     Any patternName = it->GetProperty("org.mitk.statemachinepattern");
-    // TODO
-    // TOdo any erlauben als string, oder als liste von strings
-    if (!patternName.Empty() || patternName.ToString() == "")
-    {
+
+    //if (!patternName.Empty() || patternName.ToString() == "")
+    //{
       InteractionEventObserver* interactionEventObserver = m_EventObserverTracker.GetService(*it);
       if (interactionEventObserver != NULL)
       {
         interactionEventObserver->Notify(event, eventIsHandled);
       }
-    }
+    //}
   }
 
   // Process event queue
   if (!m_QueuedEvents.empty())
   {
     InteractionEvent::Pointer e = m_QueuedEvents.front();
     m_QueuedEvents.pop_front();
     ProcessEvent(e);
   }
   return eventIsHandled;
 }
 
 /*
  * Checks if DataNodes associated with DataInteractors point back to them.
  * If not remove the DataInteractors. (This can happen when s.o. tries to set DataNodes to multiple DataInteractors)
  */
 void mitk::Dispatcher::RemoveOrphanedInteractors()
 {
   for (ListInteractorType::iterator it = m_Interactors.begin(); it != m_Interactors.end();)
   {
     DataNode::Pointer dn = (*it)->GetDataNode();
     if (dn.IsNull())
     {
       it = m_Interactors.erase(it);
     }
     else
     {
       DataInteractor::Pointer interactor = dn->GetDataInteractor();
       if (interactor != it->GetPointer())
       {
         it = m_Interactors.erase(it);
       }
       else
       {
         ++it;
       }
     }
   }
 }
 
 void mitk::Dispatcher::QueueEvent(InteractionEvent* event)
 {
   m_QueuedEvents.push_back(event);
 }
 
 void mitk::Dispatcher::SetEventProcessingMode(DataInteractor::Pointer dataInteractor)
 {
   m_ProcessingMode = dataInteractor->GetMode();
   if (dataInteractor->GetMode() != REGULAR)
   {
     m_SelectedInteractor = dataInteractor;
   }
 }
 
 bool mitk::Dispatcher::HandleInternalEvent(InternalEvent* internalEvent)
 {
   if (internalEvent->GetSignalName() == IntDeactivateMe && internalEvent->GetTargetInteractor() != NULL)
   {
     internalEvent->GetTargetInteractor()->GetDataNode()->SetDataInteractor(NULL);
     internalEvent->GetTargetInteractor()->SetDataNode(NULL);
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     return true;
   }
   return false;
 }
diff --git a/Core/Code/Interactions/mitkEventConfig.cpp b/Core/Code/Interactions/mitkEventConfig.cpp
index 3a7e64a6f1..a72580040a 100755
--- a/Core/Code/Interactions/mitkEventConfig.cpp
+++ b/Core/Code/Interactions/mitkEventConfig.cpp
@@ -1,196 +1,196 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
 #include "mitkEventConfig.h"
 #include <vtkXMLDataElement.h>
 #include <mitkStandardFileLocations.h>
 #include <vtkObjectFactory.h>
 #include <algorithm>
 #include <sstream>
 #include "mitkEventFactory.h"
 #include "mitkInteractionEvent.h"
 #include "mitkInternalEvent.h"
 #include "mitkInteractionKeyEvent.h"
 #include "mitkInteractionEventConst.h"
 // us
 #include "mitkModule.h"
 #include "mitkModuleResource.h"
 #include "mitkModuleResourceStream.h"
 #include "mitkModuleRegistry.h"
 
 namespace mitk
 {
   vtkStandardNewMacro(EventConfig);
 }
 
 mitk::EventConfig::EventConfig() :
     m_Errors(false)
 {
   if (m_PropertyList.IsNull())
   {
     m_PropertyList = PropertyList::New();
   }
 }
 
 mitk::EventConfig::~EventConfig()
 {
 }
 
 void mitk::EventConfig::InsertMapping(EventMapping mapping)
 {
   for (EventListType::iterator it = m_EventList.begin(); it != m_EventList.end(); ++it)
   {
     if ((*it).interactionEvent->MatchesTemplate(mapping.interactionEvent))
     {
-      MITK_INFO<< "Configuration overwritten:" << (*it).variantName;
+      //MITK_INFO<< "Configuration overwritten:" << (*it).variantName;
       m_EventList.erase(it);
       break;
     }
   }
   m_EventList.push_back(mapping);
 }
 
 /**
  * @brief Loads the xml file filename and generates the necessary instances.
  **/
 bool mitk::EventConfig::LoadConfig(std::string fileName, std::string moduleName)
 {
   mitk::Module* module = mitk::ModuleRegistry::GetModule(moduleName);
   mitk::ModuleResource resource = module->GetResource("Interactions/" + fileName);
   if (!resource.IsValid())
   {
     mitkThrow()<< ("Resource not valid. State machine pattern not found:" + fileName);
   }
   mitk::ModuleResourceStream stream(resource);
   this->SetStream(&stream);
   return this->Parse() && !m_Errors;
 }
 
 void mitk::EventConfig::StartElement(const char* elementName, const char **atts)
 {
   std::string name(elementName);
 
   if (name == xmlTagConfigRoot)
   {
     //
   }
   else if (name == xmlTagParam)
   {
     std::string name = ReadXMLStringAttribut(xmlParameterName, atts);
     std::string value = ReadXMLStringAttribut(xmlParameterValue, atts);
     m_PropertyList->SetStringProperty(name.c_str(), value.c_str());
   }
   else if (name == xmlTagEventVariant)
   {
     std::string eventClass = ReadXMLStringAttribut(xmlParameterEventClass, atts);
     std::string eventVariant = ReadXMLStringAttribut(xmlParameterName, atts);
     // New list in which all parameters are stored that are given within the <input/> tag
     m_EventPropertyList = PropertyList::New();
     m_EventPropertyList->SetStringProperty(xmlParameterEventClass.c_str(), eventClass.c_str());
     m_EventPropertyList->SetStringProperty(xmlParameterEventVariant.c_str(), eventVariant.c_str());
     m_CurrEventMapping.variantName = eventVariant;
   }
   else if (name == xmlTagAttribute)
   {
     // Attributes that describe an Input Event, such as which MouseButton triggered the event,or which modifier keys are pressed
     std::string name = ReadXMLStringAttribut(xmlParameterName, atts);
     std::string value = ReadXMLStringAttribut(xmlParameterValue, atts);
     m_EventPropertyList->SetStringProperty(name.c_str(), value.c_str());
   }
 }
 
 void mitk::EventConfig::EndElement(const char* elementName)
 {
   std::string name(elementName);
   // At end of input section, all necessary infos are collected to created an interaction event.
   if (name == xmlTagEventVariant)
   {
     InteractionEvent::Pointer event = EventFactory::CreateEvent(m_EventPropertyList);
     if (event.IsNotNull())
     {
       m_CurrEventMapping.interactionEvent = event;
       InsertMapping(m_CurrEventMapping);
     }
     else
     {
       MITK_WARN<< "EventConfig: Unknown Event-Type in config. Entry skipped: " << name;
     }
   }
 }
 
 std::string mitk::EventConfig::ReadXMLStringAttribut(std::string name, const char** atts)
 {
   if (atts)
   {
     const char** attsIter = atts;
 
     while (*attsIter)
     {
       if (name == *attsIter)
       {
         attsIter++;
         return *attsIter;
       }
       attsIter += 2;
     }
   }
   return std::string();
 }
 
 const mitk::PropertyList::Pointer mitk::EventConfig::GetAttributes()
 {
   return m_PropertyList;
 }
 
 std::string mitk::EventConfig::GetMappedEvent(InteractionEvent::Pointer interactionEvent)
 {
   // internal events are excluded from mapping
   if (interactionEvent->GetEventClass() == "InternalEvent")
   {
     InternalEvent* internalEvent = dynamic_cast<InternalEvent*>(interactionEvent.GetPointer());
     return internalEvent->GetSignalName();
   }
 
   for (EventListType::iterator it = m_EventList.begin(); it != m_EventList.end(); ++it)
   {
     if ((*it).interactionEvent->MatchesTemplate(interactionEvent))
     {
       return (*it).variantName;
     }
   }
   // if this part is reached, no mapping has been found,
   // so here we handle key events and map a key event to the string "Std" + letter/code
   // so "A" will be returned as "StdA"
   if (interactionEvent->GetEventClass() == "KeyEvent")
   {
     InteractionKeyEvent* keyEvent = dynamic_cast<InteractionKeyEvent*>(interactionEvent.GetPointer());
     return ("Std" + keyEvent->GetKey());
   }
   return "";
 }
 
 void mitk::EventConfig::ClearConfig()
 {
   m_EventList.clear();
 }
 
 bool mitk::EventConfig::ReadXMLBooleanAttribut(std::string name, const char** atts)
 {
   std::string s = ReadXMLStringAttribut(name, atts);
   std::transform(s.begin(), s.end(), s.begin(), ::toupper);
 
   return s == "TRUE";
 }