diff --git a/Modules/Segmentation/Controllers/mitkToolManager.cpp b/Modules/Segmentation/Controllers/mitkToolManager.cpp
index 0ff8909942..6e2fbd852c 100644
--- a/Modules/Segmentation/Controllers/mitkToolManager.cpp
+++ b/Modules/Segmentation/Controllers/mitkToolManager.cpp
@@ -1,577 +1,589 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkToolManager.h"
 #include "mitkToolManagerProvider.h"
 #include "mitkCoreObjectFactory.h"
 
 #include <itkCommand.h>
 #include <itkObjectFactoryBase.h>
 
 #include <list>
 
 #include "mitkInteractionEventObserver.h"
 #include "mitkSegTool2D.h"
 #include "mitkRenderingManager.h"
+#include "mitkSliceNavigationController.h"
 
 #include "usGetModuleContext.h"
 #include "usModuleContext.h"
 
 mitk::ToolManager::ToolManager(DataStorage *storage)
   : m_ActiveTool(nullptr), 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
   this->InitializeTools();
 }
 
 void mitk::ToolManager::EnsureTimeObservation()
 {
   if (nullptr != mitk::RenderingManager::GetInstance() && nullptr != mitk::RenderingManager::GetInstance()->GetTimeNavigationController())
   {
-    auto timestepper = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetTime();
+    auto timeController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
 
     m_LastTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
-    if (timestepper != m_CurrentTimeStepper)
+    auto currentTimeController = m_CurrentTimeNavigationController.Lock();
+
+    if (timeController != currentTimeController)
     {
+      if (currentTimeController.IsNotNull())
+      {
+        currentTimeController->RemoveObserver(m_TimePointObserverTag);
+      }
+
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction(this, &ToolManager::OnTimeChanged);
-      m_TimePointObserverTag = timestepper->AddObserver(itk::ModifiedEvent(), command);
-      m_CurrentTimeStepper = timestepper;
+      command->SetCallbackFunction(this, &ToolManager::OnTimeChangedConst);
+      m_CurrentTimeNavigationController = timeController;
+      m_TimePointObserverTag = timeController->AddObserver(SliceNavigationController::GeometryTimeEvent(nullptr,0), command);
     }
   }
 }
 
 void mitk::ToolManager::StopTimeObservation()
 {
-  if (nullptr!= m_CurrentTimeStepper && nullptr != mitk::RenderingManager::GetInstance() && nullptr != mitk::RenderingManager::GetInstance()->GetTimeNavigationController())
-  {
-    auto timestepper = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetTime();
+  auto currentTimeController = m_CurrentTimeNavigationController.Lock();
 
-    if (timestepper == m_CurrentTimeStepper)
-    {
-      timestepper->RemoveObserver(m_TimePointObserverTag);
-      m_CurrentTimeStepper = nullptr;
-      m_TimePointObserverTag = 0;
-    }
+  if (currentTimeController.IsNotNull())
+  {
+    currentTimeController->RemoveObserver(m_TimePointObserverTag);
+    m_CurrentTimeNavigationController = nullptr;
+    m_TimePointObserverTag = 0;
   }
 }
 
 mitk::ToolManager::~ToolManager()
 {
   for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
     (*dataIter)->RemoveObserver(m_WorkingDataObserverTags[(*dataIter)]);
 
   if (this->GetDataStorage() != nullptr)
     this->GetDataStorage()->RemoveNodeEvent.RemoveListener(
       mitk::MessageDelegate1<ToolManager, const mitk::DataNode *>(this, &ToolManager::OnNodeRemoved));
 
   if (m_ActiveTool)
   {
     m_ActiveTool->Deactivated();
     m_ActiveToolRegistration.Unregister();
 
     m_ActiveTool = nullptr;
     m_ActiveToolID = -1; // no tool active
 
     ActiveToolChanged.Send();
   }
   for (auto observerTagMapIter = m_ReferenceDataObserverTags.begin();
        observerTagMapIter != m_ReferenceDataObserverTags.end();
        ++observerTagMapIter)
   {
     observerTagMapIter->first->RemoveObserver(observerTagMapIter->second);
   }
   this->StopTimeObservation();
 }
 
 void mitk::ToolManager::InitializeTools()
 {
   // clear all previous tool pointers (tools may be still activated from another recently used plugin)
   if (m_ActiveTool)
   {
     m_ActiveTool->Deactivated();
     m_ActiveToolRegistration.Unregister();
 
     m_ActiveTool = nullptr;
     m_ActiveToolID = -1; // no tool active
 
     ActiveToolChanged.Send();
   }
   m_Tools.clear();
   // get a list of all known mitk::Tools
   std::list<itk::LightObject::Pointer> thingsThatClaimToBeATool = itk::ObjectFactoryBase::CreateAllInstance("mitkTool");
 
   // remember these tools
   for (auto iter = thingsThatClaimToBeATool.begin();
        iter != thingsThatClaimToBeATool.end();
        ++iter)
   {
     if (auto *tool = dynamic_cast<Tool *>(iter->GetPointer()))
     {
       tool->InitializeStateMachine();
       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);
     }
   }
 }
 
 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 (auto 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 (const std::exception &)
   {
     return nullptr;
   }
 }
 
 bool mitk::ToolManager::ActivateTool(int id)
 {
   if (id != -1 && !this->GetToolById(id)->CanHandle(this->GetReferenceData(0)->GetData()))
     return false;
 
   if (this->GetDataStorage())
   {
     this->GetDataStorage()->RemoveNodeEvent.AddListener(
       mitk::MessageDelegate1<ToolManager, const mitk::DataNode *>(this, &ToolManager::OnNodeRemoved));
   }
 
   if (GetToolById(id) == m_ActiveTool)
     return true; // no change needed
 
   static int nextTool = -1;
   nextTool = id;
 
   static bool inActivateTool = false;
   if (inActivateTool)
   {
     return true;
   }
   inActivateTool = true;
 
   while (nextTool != m_ActiveToolID)
   {
     // Deactivate all other active tools to ensure a globally single active tool
     for (const auto& toolManager : ToolManagerProvider::GetInstance()->GetToolManagers())
     {
       if (nullptr != toolManager.second->m_ActiveTool)
       {
         toolManager.second->m_ActiveTool->Deactivated();
         toolManager.second->m_ActiveToolRegistration.Unregister();
 
         // The active tool of *this* ToolManager is handled below this loop
         if (this != toolManager.second)
         {
           toolManager.second->m_ActiveTool = nullptr;
           toolManager.second->m_ActiveToolID = -1;
           toolManager.second->ActiveToolChanged.Send();
         }
       }
     }
 
     m_ActiveTool = GetToolById(nextTool);
     m_ActiveToolID = m_ActiveTool ? nextTool : -1; // current ID if tool is valid, otherwise -1
 
     ActiveToolChanged.Send();
 
     if (m_ActiveTool)
     {
       this->EnsureTimeObservation();
       if (m_RegisteredClients > 0)
       {
         m_ActiveTool->Activated();
         m_ActiveToolRegistration =
           us::GetModuleContext()->RegisterService<InteractionEventObserver>(m_ActiveTool, us::ServiceProperties());
       }
     }
   }
 
   inActivateTool = false;
   return (m_ActiveTool != nullptr);
 }
 
 void mitk::ToolManager::SetReferenceData(DataVectorType data)
 {
   if (data != m_ReferenceData)
   {
     // remove observers from old nodes
     for (auto dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter)
     {
       auto searchIter = m_ReferenceDataObserverTags.find(*dataIter);
       if (searchIter != m_ReferenceDataObserverTags.end())
       {
         (*dataIter)->RemoveObserver(searchIter->second);
       }
     }
 
     m_ReferenceData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_ReferenceDataObserverTags.clear();
     for (auto dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter)
     {
       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))
 {
   DataVectorType v;
 
   for (auto dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter)
   {
     if ((void *)(*dataIter) != (void *)caller)
     {
       v.push_back(*dataIter);
     }
     else
     {
       m_ReferenceDataObserverTags.erase(*dataIter); // no tag to remove anymore
     }
   }
   this->SetReferenceData(v);
 }
 
 void mitk::ToolManager::SetReferenceData(DataNode *data)
 {
   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 (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
     {
       auto searchIter = m_WorkingDataObserverTags.find(*dataIter);
       if (searchIter != m_WorkingDataObserverTags.end())
       {
         (*dataIter)->RemoveObserver(searchIter->second);
       }
     }
 
     m_WorkingData = data;
     // TODO tell active tool?
 
     // Quick workaround for bug #16598
     if (m_WorkingData.empty())
       this->ActivateTool(-1);
     // workaround end
 
     // attach new observers
     m_WorkingDataObserverTags.clear();
     for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
     {
       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))
 {
   DataVectorType v;
 
   for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
   {
     if ((void *)(*dataIter) != (void *)caller)
     {
       v.push_back(*dataIter);
     }
     else
     {
       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 nullptr nodes
   {
     v.push_back(data);
   }
 
   SetWorkingData(v);
 }
 
 void mitk::ToolManager::SetRoiData(DataVectorType data)
 {
   if (data != m_RoiData)
   {
     // remove observers from old nodes
     for (auto dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter)
     {
       auto searchIter = m_RoiDataObserverTags.find(*dataIter);
       if (searchIter != m_RoiDataObserverTags.end())
       {
         (*dataIter)->RemoveObserver(searchIter->second);
       }
     }
 
     m_RoiData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_RoiDataObserverTags.clear();
     for (auto dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter)
     {
       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))
 {
   DataVectorType v;
 
   for (auto dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter)
   {
     if ((void *)(*dataIter) != (void *)caller)
     {
       v.push_back(*dataIter);
     }
     else
     {
       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 (const std::exception &)
   {
     return nullptr;
   }
 }
 
 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 (const std::exception &)
   {
     return nullptr;
   }
 }
 
 mitk::DataStorage *mitk::ToolManager::GetDataStorage()
 {
   if (!m_DataStorage.IsExpired())
   {
     return m_DataStorage.Lock();
   }
   else
   {
     return nullptr;
   }
 }
 
 void mitk::ToolManager::SetDataStorage(DataStorage &storage)
 {
   m_DataStorage = &storage;
 }
 
 mitk::DataNode *mitk::ToolManager::GetWorkingData(unsigned int idx)
 {
   if (m_WorkingData.empty())
     return nullptr;
 
   if (m_WorkingData.size() > idx)
     return m_WorkingData[idx];
 
   return nullptr;
 }
 
 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();
       m_ActiveToolRegistration =
         us::GetModuleContext()->RegisterService<InteractionEventObserver>(m_ActiveTool, us::ServiceProperties());
     }
   }
   ++m_RegisteredClients;
 }
 
 void mitk::ToolManager::UnregisterClient()
 {
   if (m_RegisteredClients < 1)
     return;
 
   --m_RegisteredClients;
   if (m_RegisteredClients < 1)
   {
     if (m_ActiveTool)
     {
       m_ActiveTool->Deactivated();
       m_ActiveToolRegistration.Unregister();
     }
   }
 }
 
 int mitk::ToolManager::GetToolID(const Tool *tool)
 {
   int id(0);
   for (auto 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 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());
 }
 
-void mitk::ToolManager::OnTimeChanged(const itk::Object* caller, const itk::EventObject& /*e*/)
+void mitk::ToolManager::OnTimeChanged(itk::Object* caller, const itk::EventObject& e)
+{
+  this->OnTimeChangedConst(caller, e);
+}
+
+void mitk::ToolManager::OnTimeChangedConst(const itk::Object* caller, const itk::EventObject& /*e*/)
 {
-  if (caller == m_CurrentTimeStepper)
+  auto currentController = m_CurrentTimeNavigationController.Lock();
+  if (caller == currentController)
   {
-    const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
+    const auto currentTimePoint = currentController->GetSelectedTimePoint();
     if (currentTimePoint != m_LastTimePoint)
     {
       m_LastTimePoint = currentTimePoint;
       SelectedTimePointChanged.Send();
     }
   }
 }
 
 mitk::TimePointType mitk::ToolManager::GetCurrentTimePoint() const
 {
   return m_LastTimePoint;
 }
diff --git a/Modules/Segmentation/Controllers/mitkToolManager.h b/Modules/Segmentation/Controllers/mitkToolManager.h
index 2a87d44a0a..4cdfbf263a 100644
--- a/Modules/Segmentation/Controllers/mitkToolManager.h
+++ b/Modules/Segmentation/Controllers/mitkToolManager.h
@@ -1,301 +1,302 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkToolManager_h_Included
 #define mitkToolManager_h_Included
 
 #include "mitkDataNode.h"
 #include "mitkDataStorage.h"
 #include "mitkTool.h"
 #include "mitkWeakPointer.h"
 #include <MitkSegmentationExports.h>
 
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 
 #include <vector>
 
 namespace mitk
 {
   class Image;
   class PlaneGeometry;
 
   /**
     \brief Manages and coordinates instances of mitk::Tool.
 
     \sa QmitkToolSelectionBox
     \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 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 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 nullptr 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 MITKSEGMENTATION_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;
     Message<> SelectedTimePointChanged;
 
     Message1<std::string> ToolErrorMessage;
     Message1<std::string> GeneralToolMessage;
 
     mitkClassMacroItkParent(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 (auto 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 nullptr 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(unsigned 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);
 
     /** Get the current selected time point of the RenderManager
     */
     TimePointType GetCurrentTimePoint() const;
 
-    /*
+    /**
       \brief Tell that someone is using tools.
       GUI elements should call this when they become active. This method increases an internal "client count".
      */
     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".
      */
     void UnregisterClient();
 
     /** \brief Initialize all classes derived from mitk::Tool by itkObjectFactoy */
     void InitializeTools();
 
     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
     ~ToolManager() override;
 
     ToolVectorType m_Tools;
 
     Tool *m_ActiveTool;
     int m_ActiveToolID;
     us::ServiceRegistration<InteractionEventObserver> m_ActiveToolRegistration;
 
     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);
 
     /** Callback for time changed events*/
-    void OnTimeChanged(const itk::Object* caller, const itk::EventObject& e);
+    void OnTimeChangedConst(const itk::Object* caller, const itk::EventObject& e);
+    void OnTimeChanged(itk::Object* caller, const itk::EventObject& e);
 
     void EnsureTimeObservation();
     void StopTimeObservation();
 
-private:
-  //Time point of last detected change
-  TimePointType m_LastTimePoint = 0;
-  //Tag of the observer that listens to time changes
-  unsigned long m_TimePointObserverTag = 0;
-  //Pointer to the observed time stepper
-  const Stepper* m_CurrentTimeStepper = nullptr;
+  private:
+    /** Time point of last detected change*/
+    TimePointType m_LastTimePoint = 0;
+    /** Tag of the observer that listens to time changes*/
+    unsigned long m_TimePointObserverTag = 0;
+    /** Pointer to the observed time stepper*/
+    WeakPointer<SliceNavigationController> m_CurrentTimeNavigationController;
   };
 
 } // namespace
 
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
index a48c148cb5..0539cb7df1 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
@@ -1,97 +1,97 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkAutoSegmentationTool.h"
 #include "mitkImage.h"
 #include "mitkToolManager.h"
 #include <mitkImageTimeSelector.h>
 
 mitk::AutoSegmentationTool::AutoSegmentationTool() : Tool("dummy"), m_OverwriteExistingSegmentation(false)
 {
 }
 
 mitk::AutoSegmentationTool::~AutoSegmentationTool()
 {
 }
 
 const char *mitk::AutoSegmentationTool::GetGroup() const
 {
   return "autoSegmentation";
 }
 
 mitk::Image::ConstPointer mitk::AutoSegmentationTool::Get3DImage(const mitk::Image* image, unsigned int timestep) const
 {
   if (nullptr == image)
     return image;
 
   if (image->GetDimension() != 4)
     return image;
 
   mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
 
   imageTimeSelector->SetInput(image);
   imageTimeSelector->SetTimeNr(static_cast<int>(timestep));
 
   imageTimeSelector->UpdateLargestPossibleRegion();
 
   return imageTimeSelector->GetOutput();
 }
 
 mitk::Image::ConstPointer mitk::AutoSegmentationTool::Get3DImageByTimePoint(const mitk::Image* image, TimePointType timePoint) const
 {
   if (nullptr == image)
     return image;
 
   if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
     return nullptr;
 
   return this->Get3DImage(image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint));
 }
 
 void mitk::AutoSegmentationTool::SetOverwriteExistingSegmentation(bool overwrite)
 {
   m_OverwriteExistingSegmentation = overwrite;
 }
 
 std::string mitk::AutoSegmentationTool::GetCurrentSegmentationName()
 {
   if (m_ToolManager->GetWorkingData(0))
     return m_ToolManager->GetWorkingData(0)->GetName();
   else
     return "";
 }
 
 mitk::DataNode *mitk::AutoSegmentationTool::GetTargetSegmentationNode()
 {
   mitk::DataNode::Pointer segmentationNode = m_ToolManager->GetWorkingData(0);
   if (!m_OverwriteExistingSegmentation)
   {
     mitk::DataNode::Pointer refNode = m_ToolManager->GetReferenceData(0);
     if (refNode.IsNull())
     {
       // TODO create and use segmentation exceptions instead!!
       MITK_ERROR << "No valid reference data!";
       return nullptr;
     }
 
-    std::string nodename = m_ToolManager->GetReferenceData(0)->GetName() + "_" + this->GetName();
+    std::string nodename = refNode->GetName() + "_" + this->GetName();
     mitk::Color color;
     color.SetRed(1);
     color.SetBlue(0);
     color.SetGreen(0);
     //create a new segmentation node based on the current segmentation as template
     segmentationNode = CreateEmptySegmentationNode(dynamic_cast<mitk::Image *>(segmentationNode->GetData()), nodename, color);
 
     m_ToolManager->GetDataStorage()->Add(segmentationNode, refNode);
   }
   return segmentationNode;
 }