diff --git a/Modules/MitkExt/Controllers/mitkToolManager.cpp b/Modules/MitkExt/Controllers/mitkToolManager.cpp
index 351c284264..bde2964de6 100644
--- a/Modules/MitkExt/Controllers/mitkToolManager.cpp
+++ b/Modules/MitkExt/Controllers/mitkToolManager.cpp
@@ -1,573 +1,573 @@
 /*===================================================================
 
 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 "mitkToolManager.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkCoreObjectFactory.h"
 
 #include <itkObjectFactoryBase.h>
 #include <itkCommand.h>
 
 #include <list>
 
 #include "mitkInteractionEventObserver.h"
 #include "mitkDisplayInteractor.h"
 // MicroServices
 #include "mitkGetModuleContext.h"
 #include "mitkModule.h"
 #include "mitkModuleRegistry.h"
 
 
 mitk::ToolManager::ToolManager(DataStorage* storage)
 :m_ActiveTool(NULL),
  m_ActiveToolID(-1),
  m_RegisteredClients(0),
  m_DataStorage(storage)
 {
   CoreObjectFactory::GetInstance(); // to make sure a CoreObjectFactory was instantiated (and in turn, possible tools are registered) - bug 1029
 
   // get a list of all known mitk::Tools
   std::list<itk::LightObject::Pointer> thingsThatClaimToBeATool = itk::ObjectFactoryBase::CreateAllInstance("mitkTool");
 
   // remember these tools
   for ( std::list<itk::LightObject::Pointer>::iterator iter = thingsThatClaimToBeATool.begin();
     iter != thingsThatClaimToBeATool.end();
     ++iter )
   {
     if ( Tool* tool = dynamic_cast<Tool*>( iter->GetPointer() ) )
     {
       tool->SetToolManager(this); // important to call right after instantiation
       tool->ErrorMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnToolErrorMessage );
       tool->GeneralMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnGeneralToolMessage );
       m_Tools.push_back( tool );
     }
   }
 
   //ActivateTool(0); // first one is default
 }
 
 mitk::ToolManager::~ToolManager()
 {
   for (DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
     (*dataIter)->RemoveObserver(m_WorkingDataObserverTags[(*dataIter)]);
 
   if(this->GetDataStorage() != NULL)
     this->GetDataStorage()->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<ToolManager, const mitk::DataNode*>
         ( this, &ToolManager::OnNodeRemoved ));
 
   if (m_ActiveTool)
   {
     m_ActiveTool->Deactivated();
     GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
 
     m_ActiveTool = NULL;
     m_ActiveToolID = -1; // no tool active
 
     ActiveToolChanged.Send();
 
   }
   for ( NodeTagMapType::iterator observerTagMapIter = m_ReferenceDataObserverTags.begin(); observerTagMapIter != m_ReferenceDataObserverTags.end(); ++observerTagMapIter )
   {
     observerTagMapIter->first->RemoveObserver( observerTagMapIter->second );
   }
 }
 
 void mitk::ToolManager::OnToolErrorMessage(std::string s)
 {
   this->ToolErrorMessage(s);
 }
 
 void mitk::ToolManager::OnGeneralToolMessage(std::string s)
 {
   this->GeneralToolMessage(s);
 }
 
 
 const mitk::ToolManager::ToolVectorTypeConst mitk::ToolManager::GetTools()
 {
   ToolVectorTypeConst resultList;
 
   for ( ToolVectorType::iterator iter = m_Tools.begin();
     iter != m_Tools.end();
     ++iter )
   {
     resultList.push_back( iter->GetPointer() );
   }
 
   return resultList;
 }
 
 mitk::Tool* mitk::ToolManager::GetToolById(int id)
 {
   try
   {
     return m_Tools.at(id);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 bool mitk::ToolManager::ActivateTool(int id)
 {
 
   if(this->GetDataStorage())
     {
       this->GetDataStorage()->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<ToolManager, const mitk::DataNode*>
         ( this, &ToolManager::OnNodeRemoved ) );
     }
 
   //MITK_INFO << "ToolManager::ActivateTool("<<id<<")"<<std::endl;
   //if( GetToolById(id) == NULL ) return false; // NO, invalid IDs are actually used here. Parameter -1 or anything that does not exists will deactivate all tools!
 
   //If a tool is deactivated set the event notification policy of the global interaction to multiple again
   if (id == -1)
   {
     GlobalInteraction::GetInstance()->SetEventNotificationPolicy(GlobalInteraction::INFORM_MULTIPLE);
 
-    // Re-enabling InteractionEventObservers that have been previously disabled for legacy handling of Tools
-    // in new interaction framework
-    for (std::map<ServiceReference, EventConfig>::iterator it = m_DisplayInteractorConfigs.begin();
-         it != m_DisplayInteractorConfigs.end(); ++it)
-    {
-      if (it->first)
-      {
-        DisplayInteractor* displayInteractor = static_cast<DisplayInteractor*>(
-                                                 GetModuleContext()->GetService<InteractionEventObserver>(it->first));
-        if (displayInteractor != NULL)
-        {
-          // here the regular configuration is loaded again
-          displayInteractor->SetEventConfig(it->second);
-        }
-      }
-    }
-    m_DisplayInteractorConfigs.clear();
+//    // Re-enabling InteractionEventObservers that have been previously disabled for legacy handling of Tools
+//    // in new interaction framework
+//    for (std::map<ServiceReference, EventConfig>::iterator it = m_DisplayInteractorConfigs.begin();
+//         it != m_DisplayInteractorConfigs.end(); ++it)
+//    {
+//      if (it->first)
+//      {
+//        DisplayInteractor* displayInteractor = static_cast<DisplayInteractor*>(
+//                                                 GetModuleContext()->GetService<InteractionEventObserver>(it->first));
+//        if (displayInteractor != NULL)
+//        {
+//          // here the regular configuration is loaded again
+//          displayInteractor->SetEventConfig(it->second);
+//        }
+//      }
+//    }
+//    m_DisplayInteractorConfigs.clear();
   }
 
   if ( GetToolById( id ) == m_ActiveTool ) return true; // no change needed
 
   static int nextTool = -1;
   nextTool = id;
   //MITK_INFO << "ToolManager::ActivateTool("<<id<<"): nextTool = "<<nextTool<<std::endl;
 
   static bool inActivateTool = false;
   if (inActivateTool)
   {
     //MITK_INFO << "ToolManager::ActivateTool("<<id<<"): already inside ActivateTool somehow, returning now "<<std::endl;
     return true;
   }
   inActivateTool = true;
 
   while ( nextTool != m_ActiveToolID )
   {
     //MITK_INFO <<"ToolManager::ActivateTool: nextTool = " << nextTool << " (active tool = " << m_ActiveToolID<<")"<<std::endl;
     if (m_ActiveTool)
     {
       m_ActiveTool->Deactivated();
       GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
     }
 
     m_ActiveTool = GetToolById( nextTool );
     m_ActiveToolID = m_ActiveTool ? nextTool : -1; // current ID if tool is valid, otherwise -1
 
     ActiveToolChanged.Send();
 
     if (m_ActiveTool)
     {
       if (m_RegisteredClients > 0)
       {
         m_ActiveTool->Activated();
         GlobalInteraction::GetInstance()->AddListener( m_ActiveTool );
         //If a tool is activated set event notification policy to one
         GlobalInteraction::GetInstance()->SetEventNotificationPolicy(GlobalInteraction::INFORM_ONE);
 
-        // As a legacy solution the display interaction of the new interaction framework is disabled here  to avoid conflicts with tools
-        // Note: this only affects InteractionEventObservers (formerly known as Listeners) all DataNode specific interaction will still be enabled
-        m_DisplayInteractorConfigs.clear();
-        std::list<mitk::ServiceReference> listEventObserver = GetModuleContext()->GetServiceReferences<InteractionEventObserver>();
-        for (std::list<mitk::ServiceReference>::iterator it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
-        {
-          DisplayInteractor* displayInteractor = dynamic_cast<DisplayInteractor*>(
-                                                          GetModuleContext()->GetService<InteractionEventObserver>(*it));
-          if (displayInteractor != NULL)
-          {
-            // remember the original configuration
-            m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayInteractor->GetEventConfig()));
-            // here the alternative configuration is loaded
-            displayInteractor->SetEventConfig("Legacy/DisplayConfigMITKTools.xml");
-          }
-        }
+//        // As a legacy solution the display interaction of the new interaction framework is disabled here  to avoid conflicts with tools
+//        // Note: this only affects InteractionEventObservers (formerly known as Listeners) all DataNode specific interaction will still be enabled
+//        m_DisplayInteractorConfigs.clear();
+//        std::list<mitk::ServiceReference> listEventObserver = GetModuleContext()->GetServiceReferences<InteractionEventObserver>();
+//        for (std::list<mitk::ServiceReference>::iterator it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
+//        {
+//          DisplayInteractor* displayInteractor = dynamic_cast<DisplayInteractor*>(
+//                                                          GetModuleContext()->GetService<InteractionEventObserver>(*it));
+//          if (displayInteractor != NULL)
+//          {
+//            // remember the original configuration
+//            m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayInteractor->GetEventConfig()));
+//            // here the alternative configuration is loaded
+//            displayInteractor->SetEventConfig("Legacy/DisplayConfigMITKTools.xml");
+//          }
+//        }
       }
     }
   }
 
   inActivateTool = false;
   return (m_ActiveTool != NULL);
 }
 
 void mitk::ToolManager::SetReferenceData(DataVectorType data)
 {
   if (data != m_ReferenceData)
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_ReferenceDataObserverTags.find( *dataIter );
       if ( searchIter != m_ReferenceDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_ReferenceData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_ReferenceDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
     {
 
 
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheReferenceDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheReferenceDataDeletedConst );
       m_ReferenceDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
 
     ReferenceDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::OnOneOfTheReferenceDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheReferenceDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheReferenceDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from reference data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_ReferenceDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetReferenceData( v );
 }
 
 void mitk::ToolManager::SetReferenceData(DataNode* data)
 {
   //MITK_INFO << "ToolManager::SetReferenceData(" << (void*)data << ")" << std::endl;
   DataVectorType v;
   if (data)
   {
     v.push_back(data);
   }
   SetReferenceData(v);
 }
 
 void mitk::ToolManager::SetWorkingData(DataVectorType data)
 {
   if ( data != m_WorkingData )
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( *dataIter );
       if ( searchIter != m_WorkingDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_WorkingData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_WorkingDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
     {
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheWorkingDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheWorkingDataDeletedConst );
       m_WorkingDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
 
     WorkingDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::OnOneOfTheWorkingDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheWorkingDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheWorkingDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from reference data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_WorkingDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetWorkingData( v );
 }
 
 
 void mitk::ToolManager::SetWorkingData(DataNode* data)
 {
   DataVectorType v;
 
   if (data) // don't allow for NULL nodes
   {
     v.push_back(data);
   }
 
   SetWorkingData(v);
 }
 
 void mitk::ToolManager::SetRoiData(DataVectorType data)
 {
   if (data != m_RoiData)
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_RoiDataObserverTags.find( *dataIter );
       if ( searchIter != m_RoiDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_RoiData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_RoiDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
     {
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheRoiDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheRoiDataDeletedConst );
       m_RoiDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
     RoiDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::SetRoiData(DataNode* data)
 {
   DataVectorType v;
 
   if(data)
   {
     v.push_back(data);
   }
   this->SetRoiData(v);
 }
 
 void mitk::ToolManager::OnOneOfTheRoiDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheRoiDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheRoiDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from roi data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_RoiDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetRoiData( v );
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetReferenceData()
 {
   return m_ReferenceData;
 }
 
 mitk::DataNode* mitk::ToolManager::GetReferenceData(int idx)
 {
   try
   {
     return m_ReferenceData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetWorkingData()
 {
   return m_WorkingData;
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetRoiData()
 {
   return m_RoiData;
 }
 
 mitk::DataNode* mitk::ToolManager::GetRoiData(int idx)
 {
   try
   {
     return m_RoiData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 mitk::DataStorage* mitk::ToolManager::GetDataStorage()
 {
   if ( m_DataStorage.IsNotNull() )
   {
     return m_DataStorage;
   }
   else
   {
     return NULL;
   }
 }
 
 void mitk::ToolManager::SetDataStorage(DataStorage& storage)
 {
   m_DataStorage = &storage;
 }
 
 
 
 mitk::DataNode* mitk::ToolManager::GetWorkingData(int idx)
 {
   try
   {
     return m_WorkingData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 int mitk::ToolManager::GetActiveToolID()
 {
   return m_ActiveToolID;
 }
 
 mitk::Tool* mitk::ToolManager::GetActiveTool()
 {
   return m_ActiveTool;
 }
 
 void mitk::ToolManager::RegisterClient()
 {
   if ( m_RegisteredClients < 1 )
   {
     if ( m_ActiveTool )
     {
       m_ActiveTool->Activated();
       GlobalInteraction::GetInstance()->AddListener( m_ActiveTool );
     }
   }
   ++m_RegisteredClients;
 }
 
 void mitk::ToolManager::UnregisterClient()
 {
   if ( m_RegisteredClients < 1) return;
 
   --m_RegisteredClients;
   if ( m_RegisteredClients < 1 )
   {
     if ( m_ActiveTool )
     {
       m_ActiveTool->Deactivated();
       GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
     }
   }
 }
 
 int mitk::ToolManager::GetToolID( const Tool* tool )
 {
   int id(0);
   for ( ToolVectorType::iterator iter = m_Tools.begin();
     iter != m_Tools.end();
     ++iter, ++id )
   {
     if ( tool == iter->GetPointer() )
     {
       return id;
     }
   }
   return -1;
 }
 
 
 void mitk::ToolManager::OnNodeRemoved(const mitk::DataNode* node)
 {
   //check if the data of the node is typeof Image
   /*if(dynamic_cast<mitk::Image*>(node->GetData()))
   {*/
     //check all storage vectors
     OnOneOfTheReferenceDataDeleted(const_cast<mitk::DataNode*>(node), itk::DeleteEvent());
     OnOneOfTheRoiDataDeleted(const_cast<mitk::DataNode*>(node),itk::DeleteEvent());
     OnOneOfTheWorkingDataDeleted(const_cast<mitk::DataNode*>(node),itk::DeleteEvent());
   //}
 }
 
diff --git a/Modules/MitkExt/Controllers/mitkToolManager.h b/Modules/MitkExt/Controllers/mitkToolManager.h
index a8ee554b74..e92fbd51d0 100644
--- a/Modules/MitkExt/Controllers/mitkToolManager.h
+++ b/Modules/MitkExt/Controllers/mitkToolManager.h
@@ -1,295 +1,295 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef mitkToolManager_h_Included
 #define mitkToolManager_h_Included
 
 #include "mitkTool.h"
 #include "MitkExtExports.h"
 #include "mitkDataNode.h"
 #include "mitkDataStorage.h"
 #include "mitkWeakPointer.h"
 #include "mitkServiceReference.h"
 
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 
 #include <vector>
 #include <map>
 
 namespace mitk
 {
 
 class Image;
 class PlaneGeometry;
 
 /**
   \brief Manages and coordinates instances of mitk::Tool.
 
   \sa QmitkToolSelectionBox
   \sa QmitkToolReferenceDataSelectionBox
   \sa QmitkToolWorkingDataSelectionBox
   \sa Tool
   \sa QmitkSegmentationView
 
   \ingroup Interaction
   \ingroup ToolManagerEtAl
 
   There is a separate page describing the general design of QmitkSegmentationView: \ref QmitkSegmentationTechnicalPage
 
   This class creates and manages several instances of mitk::Tool.
 
   \li ToolManager creates instances of mitk::Tool by asking the itk::ObjectFactory to list all known implementations of mitk::Tool.
       As a result, one has to implement both a subclass of mitk::Tool and a matching subclass of itk::ObjectFactoryBase that is registered
       to the top-level itk::ObjectFactory. For an example, see mitkContourToolFactory.h. (this limitiation of one-class-one-factory is due
       to the implementation of itk::ObjectFactory).
       In MITK, the right place to register the factories to itk::ObjectFactory is the mitk::QMCoreObjectFactory or mitk::SBCoreObjectFactory.
 
    \li One (and only one - or none at all) of the registered tools can be activated using ActivateTool. This tool is registered to mitk::GlobalInteraction
       as a listener and will receive all mouse clicks and keyboard strokes that get into the MITK event mechanism. Tools are automatically
       unregistered from GlobalInteraction when no clients are registered to ToolManager (see RegisterClient()).
 
    \li ToolManager knows a set of "reference" DataNodes and a set of "working" DataNodes. The first application are segmentation tools, where the
       reference is the original image and the working data the (kind of) binary segmentation. However, ToolManager is implemented more generally, so that
       there could be other tools that work, e.g., with surfaces.
 
   \li Any "user/client" of ToolManager, i.e. every functionality that wants to use a tool, should call RegisterClient when the tools should be active.
       ToolManager keeps track of how many clients want it to be used, and when this count reaches zero, it unregistes the active Tool from GlobalInteraction.
       In "normal" settings, the functionality does not need to care about that if it uses a QmitkToolSelectionBox, which does exactly that when it is
       enabled/disabled.
 
   \li There is a set of events that are sent by ToolManager. At the moment these are TODO update documentation:
       - mitk::ToolReferenceDataChangedEvent whenever somebody calls SetReferenceData. Most of the time this actually means that the data has changed, but
         there might be cases where the same data is passed to SetReferenceData a second time, so don't rely on the assumption that something actually changed.
       - mitk::ToolSelectedEvent is sent when a (truly) different tool was activated. In reaction to this event you can ask for the active Tool using
         GetActiveTool or GetActiveToolID (where NULL or -1 indicate that NO tool is active at the moment).
 
   Design descisions:
 
   \li Not a singleton, because there could be two functionalities using tools, each one with different reference/working data.
 
   $Author$
 */
 class MitkExt_EXPORT ToolManager : public itk::Object
 {
   public:
 
     typedef std::vector<Tool::Pointer>         ToolVectorType;
     typedef std::vector<Tool::ConstPointer>    ToolVectorTypeConst;
     typedef std::vector<DataNode*> DataVectorType; // has to be observed for delete events!
     typedef std::map<DataNode*, unsigned long> NodeTagMapType;
 
     Message<> NodePropertiesChanged;
     Message<> NewNodesGenerated;
     Message1<DataVectorType*> NewNodeObjectsGenerated;
 
     Message<> ActiveToolChanged;
     Message<> ReferenceDataChanged;
     Message<> WorkingDataChanged;
     Message<> RoiDataChanged;
 
     Message1<std::string> ToolErrorMessage;
     Message1<std::string> GeneralToolMessage;
 
     mitkClassMacro(ToolManager, itk::Object);
     mitkNewMacro1Param(ToolManager, DataStorage*);
 
     /**
       \brief Gives you a list of all tools.
       This is const on purpose.
      */
     const ToolVectorTypeConst GetTools();
 
     int GetToolID( const Tool* tool );
 
     /*
       \param id The tool of interest.
       Counting starts with 0.
     */
     Tool* GetToolById(int id);
 
     /**
       \param id The tool to activate. Provide -1 for disabling any tools.
       Counting starts with 0.
       Registeres a listner for NodeRemoved event at DataStorage (see mitk::ToolManager::OnNodeRemoved).
     */
     bool ActivateTool(int id);
 
     template <class T>
     int GetToolIdByToolType()
     {
       int id = 0;
       for ( ToolVectorType::iterator iter = m_Tools.begin();
             iter != m_Tools.end();
             ++iter, ++id )
       {
         if ( dynamic_cast<T*>(iter->GetPointer()) )
         {
           return id;
         }
       }
       return -1;
     }
 
     /**
       \return -1 for "No tool is active"
     */
     int GetActiveToolID();
 
     /**
       \return NULL for "No tool is active"
     */
     Tool* GetActiveTool();
 
     /*
       \brief Set a list of data/images as reference objects.
     */
     void SetReferenceData(DataVectorType);
 
     /*
       \brief Set single data item/image as reference object.
     */
     void SetReferenceData(DataNode*);
 
     /*
       \brief Set a list of data/images as working objects.
     */
     void SetWorkingData(DataVectorType);
 
     /*
       \brief Set single data item/image as working object.
     */
     void SetWorkingData(DataNode*);
 
     /*
       \brief Set a list of data/images as roi objects.
     */
     void SetRoiData(DataVectorType);
 
     /*
       \brief Set a single data item/image as roi object.
     */
     void SetRoiData(DataNode*);
 
     /*
       \brief Get the list of reference data.
     */
     DataVectorType GetReferenceData();
 
     /*
       \brief Get the current reference data.
       \warning If there is a list of items, this method will only return the first list item.
     */
     DataNode* GetReferenceData(int);
 
     /*
       \brief Get the list of working data.
     */
     DataVectorType GetWorkingData();
 
     /*
       \brief Get the current working data.
       \warning If there is a list of items, this method will only return the first list item.
     */
     DataNode* GetWorkingData(int);
 
     /*
      \brief Get the current roi data
      */
     DataVectorType GetRoiData();
 
     /*
      \brief Get the roi data at position idx
      */
     DataNode* GetRoiData(int idx);
 
     DataStorage* GetDataStorage();
     void SetDataStorage(DataStorage& storage);
 
     /*
       \brief Tell that someone is using tools.
       GUI elements should call this when they become active. This method increases an internal "client count". Tools
       are only registered to GlobalInteraction when this count is greater than 0. This is useful to automatically deactivate
       tools when you hide their GUI elements.
      */
     void RegisterClient();
 
     /*
       \brief Tell that someone is NOT using tools.
       GUI elements should call this when they become active. This method increases an internal "client count". Tools
       are only registered to GlobalInteraction when this count is greater than 0. This is useful to automatically deactivate
       tools when you hide their GUI elements.
      */
     void UnregisterClient();
 
     void OnOneOfTheReferenceDataDeletedConst(const itk::Object* caller, const itk::EventObject& e);
     void OnOneOfTheReferenceDataDeleted           (itk::Object* caller, const itk::EventObject& e);
 
     void OnOneOfTheWorkingDataDeletedConst(const itk::Object* caller, const itk::EventObject& e);
     void OnOneOfTheWorkingDataDeleted           (itk::Object* caller, const itk::EventObject& e);
 
     void OnOneOfTheRoiDataDeletedConst(const itk::Object* caller, const itk::EventObject& e);
     void OnOneOfTheRoiDataDeleted           (itk::Object* caller, const itk::EventObject& e);
 
     /*
      \brief Connected to tool's messages
 
      This method just resends error messages coming from any of the tools. This way clients (GUIs) only have to observe one message.
      */
     void OnToolErrorMessage(std::string s);
     void OnGeneralToolMessage(std::string s);
 
   protected:
 
     /**
       You may specify a list of tool "groups" that should be available for this ToolManager. Every Tool can report its group
       as a string. This constructor will try to find the tool's group inside the supplied string. If there is a match,
       the tool is accepted. Effectively, you can provide a human readable list like "default, lymphnodevolumetry, oldERISstuff".
     */
     ToolManager(DataStorage* storage); // purposely hidden
     virtual ~ToolManager();
 
     ToolVectorType m_Tools;
 
     Tool* m_ActiveTool;
     int m_ActiveToolID;
 
     DataVectorType m_ReferenceData;
     NodeTagMapType  m_ReferenceDataObserverTags;
 
     DataVectorType m_WorkingData;
     NodeTagMapType  m_WorkingDataObserverTags;
 
     DataVectorType m_RoiData;
     NodeTagMapType m_RoiDataObserverTags;
 
     int m_RegisteredClients;
 
     WeakPointer<DataStorage> m_DataStorage;
 
     /// \brief Callback for NodeRemove events
     void OnNodeRemoved(const mitk::DataNode* node);
 
   private:
 
-    std::map<ServiceReference, EventConfig> m_DisplayInteractorConfigs;
+    //std::map<ServiceReference, EventConfig> m_DisplayInteractorConfigs;
 };
 
 } // namespace
 
 #endif