diff --git a/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp b/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
index 6201016e0c..5d1b7aacc4 100644
--- a/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
+++ b/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
@@ -1,562 +1,560 @@
 /*============================================================================
 
 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 "mitkSliceNavigationController.h"
 
 #include <mitkSliceNavigationHelper.h>
 #include "mitkBaseRenderer.h"
-#include "mitkCrosshairPositionEvent.h"
 #include "mitkOperation.h"
 #include "mitkOperationActor.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProportionalTimeGeometry.h"
 #include "mitkArbitraryTimeGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkVtkPropRenderer.h"
 
 #include "mitkImage.h"
 #include "mitkImagePixelReadAccessor.h"
 #include "mitkInteractionConst.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkOperationEvent.h"
 #include "mitkPixelTypeMultiplex.h"
 #include "mitkPlaneOperation.h"
 #include "mitkPointOperation.h"
-#include "mitkStatusBar.h"
 
 #include "mitkApplyTransformMatrixOperation.h"
 
 namespace mitk
 {
 
   PlaneGeometry::PlaneOrientation ViewDirectionToPlaneOrientation(SliceNavigationController::ViewDirection viewDiretion)
   {
     switch (viewDiretion)
     {
     case SliceNavigationController::Axial:
       return PlaneGeometry::Axial;
     case SliceNavigationController::Sagittal:
       return PlaneGeometry::Sagittal;
     case SliceNavigationController::Coronal:
       return PlaneGeometry::Coronal;
     case SliceNavigationController::Original:
     default:
       return PlaneGeometry::None;
     }
   }
 
   SliceNavigationController::SliceNavigationController()
     : BaseController()
     , m_InputWorldTimeGeometry(TimeGeometry::ConstPointer())
     , m_CreatedWorldGeometry(TimeGeometry::Pointer())
     , m_ViewDirection(Axial)
     , m_DefaultViewDirection(Axial)
     , m_RenderingManager(RenderingManager::Pointer())
     , m_Renderer(nullptr)
     , m_BlockUpdate(false)
     , m_SliceLocked(false)
     , m_SliceRotationLocked(false)
   {
     typedef itk::SimpleMemberCommand<SliceNavigationController> SNCCommandType;
     SNCCommandType::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
 
     sliceStepperChangedCommand = SNCCommandType::New();
     timeStepperChangedCommand = SNCCommandType::New();
 
     sliceStepperChangedCommand->SetCallbackFunction(this, &SliceNavigationController::SendSlice);
 
     timeStepperChangedCommand->SetCallbackFunction(this, &SliceNavigationController::SendTime);
 
     m_Slice->AddObserver(itk::ModifiedEvent(), sliceStepperChangedCommand);
     m_Time->AddObserver(itk::ModifiedEvent(), timeStepperChangedCommand);
 
     m_Slice->SetUnitName("mm");
     m_Time->SetUnitName("ms");
   }
 
   SliceNavigationController::~SliceNavigationController()
   {
     // nothing here
   }
 
   void SliceNavigationController::SetInputWorldTimeGeometry(const TimeGeometry* geometry)
   {
     if (nullptr != geometry)
     {
       if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() < eps)
       {
         itkWarningMacro("setting an empty bounding-box");
         geometry = nullptr;
       }
     }
 
     if (m_InputWorldTimeGeometry != geometry)
     {
       m_InputWorldTimeGeometry = geometry;
       this->Modified();
     }
   }
 
   void SliceNavigationController::SetViewDirectionToDefault()
   {
     m_ViewDirection = m_DefaultViewDirection;
   }
 
   const char* SliceNavigationController::GetViewDirectionAsString() const
   {
     const char* viewDirectionString;
     switch (m_ViewDirection)
     {
       case SliceNavigationController::Axial:
         viewDirectionString = "Axial";
         break;
 
       case SliceNavigationController::Sagittal:
         viewDirectionString = "Sagittal";
         break;
 
       case SliceNavigationController::Coronal:
         viewDirectionString = "Coronal";
         break;
 
       case SliceNavigationController::Original:
         viewDirectionString = "Original";
         break;
 
       default:
         viewDirectionString = "No View Direction Available";
         break;
     }
     return viewDirectionString;
   }
 
   void SliceNavigationController::Update()
   {
     if (!m_BlockUpdate)
     {
       if (m_ViewDirection == Sagittal)
       {
         this->Update(Sagittal, true, true, false);
       }
       else if (m_ViewDirection == Coronal)
       {
         this->Update(Coronal, false, true, false);
       }
       else if (m_ViewDirection == Axial)
       {
         this->Update(Axial, false, false, true);
       }
       else
       {
         this->Update(m_ViewDirection);
       }
     }
   }
 
   void SliceNavigationController::Update(SliceNavigationController::ViewDirection viewDirection,
                                          bool top,
                                          bool frontside,
                                          bool rotated)
   {
     if (m_BlockUpdate)
     {
       return;
     }
 
     if (m_InputWorldTimeGeometry.IsNull())
     {
       return;
     }
 
     if (0 == m_InputWorldTimeGeometry->CountTimeSteps())
     {
       return;
     }
 
     m_BlockUpdate = true;
 
     if (m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime())
     {
       Modified();
     }
 
     this->SetViewDirection(viewDirection);
 
     if (m_LastUpdateTime < GetMTime())
     {
       m_LastUpdateTime = GetMTime();
 
       this->CreateWorldGeometry(top, frontside, rotated);
     }
 
     // unblock update; we may do this now, because if m_BlockUpdate was already
     // true before this method was entered, then we will never come here.
     m_BlockUpdate = false;
 
     // Send the geometry. Do this even if nothing was changed, because maybe
     // Update() was only called to re-send the old geometry and time/slice data.
     this->SendCreatedWorldGeometry();
     this->SendSlice();
     this->SendTime();
 
     // Adjust the stepper range of slice stepper according to geometry
     this->AdjustSliceStepperRange();
   }
 
   void SliceNavigationController::SendCreatedWorldGeometry()
   {
     if (!m_BlockUpdate)
     {
       this->InvokeEvent(GeometrySendEvent(m_CreatedWorldGeometry, 0));
     }
   }
 
   void SliceNavigationController::SendCreatedWorldGeometryUpdate()
   {
     if (!m_BlockUpdate)
     {
       this->InvokeEvent(GeometryUpdateEvent(m_CreatedWorldGeometry, m_Slice->GetPos()));
     }
   }
 
   void SliceNavigationController::SendSlice()
   {
     if (!m_BlockUpdate)
     {
       if (m_CreatedWorldGeometry.IsNotNull())
       {
         this->InvokeEvent(GeometrySliceEvent(m_CreatedWorldGeometry, m_Slice->GetPos()));
         RenderingManager::GetInstance()->RequestUpdateAll();
       }
     }
   }
 
   void SliceNavigationController::SendTime()
   {
     if (!m_BlockUpdate)
     {
       if (m_CreatedWorldGeometry.IsNotNull())
       {
         this->InvokeEvent(GeometryTimeEvent(m_CreatedWorldGeometry, m_Time->GetPos()));
         RenderingManager::GetInstance()->RequestUpdateAll();
       }
     }
   }
 
   void SliceNavigationController::SetGeometry(const itk::EventObject&)
   {
     // not implemented
   }
 
   void SliceNavigationController::SetGeometryTime(const itk::EventObject& geometryTimeEvent)
   {
     if (m_CreatedWorldGeometry.IsNull())
     {
       return;
     }
 
     const auto* timeEvent = dynamic_cast<const SliceNavigationController::GeometryTimeEvent*>(&geometryTimeEvent);
     assert(timeEvent != nullptr);
 
     TimeGeometry* timeGeometry = timeEvent->GetTimeGeometry();
     assert(timeGeometry != nullptr);
 
     auto timeStep = (int)timeEvent->GetPos();
     ScalarType timeInMS;
     timeInMS = timeGeometry->TimeStepToTimePoint(timeStep);
     timeStep = m_CreatedWorldGeometry->TimePointToTimeStep(timeInMS);
     this->GetTime()->SetPos(timeStep);
   }
 
   void SliceNavigationController::SetGeometrySlice(const itk::EventObject& geometrySliceEvent)
   {
     const auto* sliceEvent = dynamic_cast<const SliceNavigationController::GeometrySliceEvent*>(&geometrySliceEvent);
     assert(sliceEvent != nullptr);
 
     this->GetSlice()->SetPos(sliceEvent->GetPos());
   }
 
   void SliceNavigationController::SelectSliceByPoint(const Point3D& point)
   {
     if (m_CreatedWorldGeometry.IsNull())
     {
       return;
     }
 
     int selectedSlice = -1;
     try
     {
       selectedSlice = SliceNavigationHelper::SelectSliceByPoint(m_CreatedWorldGeometry, point);
     }
     catch (const mitk::Exception& e)
     {
       MITK_ERROR << "Unable to select a slice by the given point " << point << "\n"
                  << "Reason: " << e.GetDescription();
     }
 
     if (-1 == selectedSlice)
     {
       return;
     }
 
     this->GetSlice()->SetPos(selectedSlice);
 
     this->SendCreatedWorldGeometryUpdate();
     // send crosshair event
     SetCrosshairEvent.Send(point);
   }
 
   void SliceNavigationController::ReorientSlices(const Point3D& point, const Vector3D& normal)
   {
     if (m_CreatedWorldGeometry.IsNull())
     {
       return;
     }
 
     PlaneOperation op(OpORIENT, point, normal);
     m_CreatedWorldGeometry->ExecuteOperation(&op);
 
     this->SendCreatedWorldGeometryUpdate();
   }
 
   void SliceNavigationController::ReorientSlices(const Point3D& point,
                                                  const Vector3D& axisVec0,
                                                  const Vector3D& axisVec1)
   {
     if (m_CreatedWorldGeometry.IsNull())
     {
       return;
     }
 
     PlaneOperation op(OpORIENT, point, axisVec0, axisVec1);
     m_CreatedWorldGeometry->ExecuteOperation(&op);
 
     this->SendCreatedWorldGeometryUpdate();
   }
 
   const BaseGeometry* SliceNavigationController::GetCurrentGeometry3D()
   {
     if (m_CreatedWorldGeometry.IsNull())
     {
       return nullptr;
     }
 
     return m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos());
   }
 
   const PlaneGeometry* SliceNavigationController::GetCurrentPlaneGeometry()
   {
     const auto* slicedGeometry = dynamic_cast<const SlicedGeometry3D*>(this->GetCurrentGeometry3D());
 
     if (nullptr == slicedGeometry)
     {
       return nullptr;
     }
 
     return slicedGeometry->GetPlaneGeometry(this->GetSlice()->GetPos());
   }
 
   void SliceNavigationController::AdjustSliceStepperRange()
   {
     const auto* slicedGeometry = dynamic_cast<const SlicedGeometry3D*>(this->GetCurrentGeometry3D());
 
     const Vector3D& direction = slicedGeometry->GetDirectionVector();
 
     int c = 0;
     int i, k = 0;
     for (i = 0; i < 3; ++i)
     {
       if (fabs(direction[i]) < 0.000000001)
       {
         ++c;
       }
       else
       {
         k = i;
       }
     }
 
     if (c == 2)
     {
       ScalarType min = slicedGeometry->GetOrigin()[k];
       ScalarType max = min + slicedGeometry->GetExtentInMM(k);
 
       m_Slice->SetRange(min, max);
     }
     else
     {
       m_Slice->InvalidateRange();
     }
   }
 
   void SliceNavigationController::ExecuteOperation(Operation* operation)
   {
     // switch on type
     // - select best slice for a given point
     // - rotate created world geometry according to Operation->SomeInfo()
     if (!operation || m_CreatedWorldGeometry.IsNull())
     {
       return;
     }
 
     switch (operation->GetOperationType())
     {
       case OpMOVE: // should be a point operation
       {
         if (!m_SliceLocked) // do not move the cross position
         {
           // select a slice
           auto* po = dynamic_cast<PointOperation*>(operation);
           if (po && po->GetIndex() == -1)
           {
             this->SelectSliceByPoint(po->GetPoint());
           }
           else if (po &&
                    po->GetIndex() != -1) // undo case because index != -1, index holds the old position of this slice
           {
             this->GetSlice()->SetPos(po->GetIndex());
           }
         }
         break;
       }
       case OpRESTOREPLANEPOSITION:
       {
         m_CreatedWorldGeometry->ExecuteOperation(operation);
 
         this->SendCreatedWorldGeometryUpdate();
 
         break;
       }
       case OpAPPLYTRANSFORMMATRIX:
       {
         m_CreatedWorldGeometry->ExecuteOperation(operation);
 
         this->SendCreatedWorldGeometryUpdate();
 
         break;
       }
       default:
       {
         // do nothing
         break;
       }
     }
   }
 
   TimeStepType SliceNavigationController::GetSelectedTimeStep() const
   {
     return this->GetTime()->GetPos();
   }
 
   TimePointType SliceNavigationController::GetSelectedTimePoint() const
   {
     auto timeStep = this->GetSelectedTimeStep();
 
     if (m_CreatedWorldGeometry.IsNull())
     {
       return 0.0;
     }
 
     if (!m_CreatedWorldGeometry->IsValidTimeStep(timeStep))
     {
       mitkThrow() << "SliceNavigationController is in an invalid state. It has a time step"
                   << "selected that is not covered by its time geometry. Selected time step: " << timeStep
                   << "; TimeGeometry steps count: " << m_CreatedWorldGeometry->CountTimeSteps();
     }
 
     return m_CreatedWorldGeometry->TimeStepToTimePoint(timeStep);
   }
 
   void SliceNavigationController::CreateWorldGeometry(bool top, bool frontside, bool rotated)
   {
     // initialize the viewplane
     SlicedGeometry3D::Pointer slicedWorldGeometry;
     BaseGeometry::ConstPointer currentGeometry;
 
     // get the BaseGeometry (ArbitraryTimeGeometry or ProportionalTimeGeometry) of the current time step
     auto currentTimeStep = this->GetTime()->GetPos();
     if (m_InputWorldTimeGeometry->IsValidTimeStep(currentTimeStep))
     {
       currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(currentTimeStep);
     }
     else
     {
       currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(0);
     }
 
     if (Original == m_ViewDirection)
     {
       slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(
         m_InputWorldTimeGeometry->GetGeometryForTimeStep(currentTimeStep).GetPointer());
       if (slicedWorldGeometry.IsNull())
       {
         slicedWorldGeometry = SlicedGeometry3D::New();
         slicedWorldGeometry->InitializePlanes(
           currentGeometry, PlaneGeometry::None, top, frontside, rotated);
         slicedWorldGeometry->SetSliceNavigationController(this);
       }
     }
     else
     {
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes(
         currentGeometry, ViewDirectionToPlaneOrientation(m_ViewDirection), top, frontside, rotated);
       slicedWorldGeometry->SetSliceNavigationController(this);
     }
 
     // reset the stepper
     m_Slice->SetSteps(slicedWorldGeometry->GetSlices());
     m_Slice->SetPos(0);
 
     TimeStepType inputTimeSteps = m_InputWorldTimeGeometry->CountTimeSteps();
     const TimeBounds& timeBounds = m_InputWorldTimeGeometry->GetTimeBounds();
     m_Time->SetSteps(inputTimeSteps);
     m_Time->SetPos(0);
     m_Time->SetRange(timeBounds[0], timeBounds[1]);
 
     currentTimeStep = this->GetTime()->GetPos();
     assert(m_InputWorldTimeGeometry->GetGeometryForTimeStep(currentTimeStep).IsNotNull());
 
     // create new time geometry and initialize it according to the type of the 'm_InputWorldTimeGeometry'
     // the created world geometry will either have equidistant timesteps (ProportionalTimeGeometry)
     // or individual time bounds for each timestep (ArbitraryTimeGeometry)
     m_CreatedWorldGeometry = mitk::TimeGeometry::Pointer();
     if (nullptr != dynamic_cast<const mitk::ProportionalTimeGeometry*>(m_InputWorldTimeGeometry.GetPointer()))
     {
       const TimePointType minimumTimePoint = m_InputWorldTimeGeometry->TimeStepToTimePoint(currentTimeStep);
       const TimePointType stepDuration =
         m_InputWorldTimeGeometry->TimeStepToTimePoint(currentTimeStep + 1) - minimumTimePoint;
 
       auto createdTimeGeometry = ProportionalTimeGeometry::New();
       createdTimeGeometry->Initialize(slicedWorldGeometry, inputTimeSteps);
       createdTimeGeometry->SetFirstTimePoint(minimumTimePoint);
       createdTimeGeometry->SetStepDuration(stepDuration);
 
       m_CreatedWorldGeometry = createdTimeGeometry;
     }
     else
     {
       auto createdTimeGeometry = mitk::ArbitraryTimeGeometry::New();
       createdTimeGeometry->ReserveSpaceForGeometries(inputTimeSteps);
       const BaseGeometry::Pointer clonedGeometry = slicedWorldGeometry->Clone();
 
       for (TimeStepType i = 0; i < inputTimeSteps; ++i)
       {
         const auto bounds = m_InputWorldTimeGeometry->GetTimeBounds(i);
         createdTimeGeometry->AppendNewTimeStep(clonedGeometry, bounds[0], bounds[1]);
       }
 
       createdTimeGeometry->Update();
       m_CreatedWorldGeometry = createdTimeGeometry;
     }
   }
 } // namespace mitk
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.cpp
index 9c8bf772ba..53919dd2f1 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.cpp
@@ -1,205 +1,203 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 // Qmitk
 #include "QmitkRenderWindow.h"
 #include "QmitkSliceNavigationListener.h"
 
 #include "mitkIRenderWindowPart.h"
 
 // Qt
 #include <QTimer>
 #include <QMessageBox>
 
 
 ///**********************************************
 QmitkSliceNavigationListener::QmitkSliceNavigationListener() : m_renderWindowPart(nullptr),
 m_PendingSliceChangedEvent(false),
 m_CurrentSelectedPosition(std::numeric_limits<mitk::Point3D::ValueType>::lowest()),
 m_CurrentSelectedTimePoint(std::numeric_limits<mitk::TimePointType>::lowest())
 {
 }
 
 QmitkSliceNavigationListener::~QmitkSliceNavigationListener()
 {
   this->RemoveAllObservers();
-};
+}
 
 mitk::TimePointType QmitkSliceNavigationListener::GetCurrentSelectedTimePoint() const
 {
   return m_CurrentSelectedTimePoint;
 }
 
 mitk::Point3D QmitkSliceNavigationListener::GetCurrentSelectedPosition() const
 {
   return m_CurrentSelectedPosition;
 }
 
 void QmitkSliceNavigationListener::OnSliceChangedDelayed()
 {
   m_PendingSliceChangedEvent = false;
 
   emit SliceChanged();
 
   if (nullptr != m_renderWindowPart)
   {
     const auto newSelectedPosition = m_renderWindowPart->GetSelectedPosition();
     const auto newSelectedTimePoint = m_renderWindowPart->GetSelectedTimePoint();
 
     if (newSelectedPosition != m_CurrentSelectedPosition)
     {
       m_CurrentSelectedPosition = newSelectedPosition;
       emit SelectedPositionChanged(newSelectedPosition);
     }
 
     if (newSelectedTimePoint != m_CurrentSelectedTimePoint)
     {
       m_CurrentSelectedTimePoint = newSelectedTimePoint;
       emit SelectedTimePointChanged(newSelectedTimePoint);
     }
   }
-};
+}
 
-void
-QmitkSliceNavigationListener::OnSliceChangedInternal(const itk::EventObject&)
+void QmitkSliceNavigationListener::OnSliceChangedInternal(const itk::EventObject&)
 {
-  // Taken from QmitkStdMultiWidget::HandleCrosshairPositionEvent().
   // Since there are always 3 events arriving (one for each render window) every time the slice
   // or time changes, the slot OnSliceChangedDelayed is triggered - and only if it hasn't been
   // triggered yet - so it is only executed once for every slice/time change.
   if (!m_PendingSliceChangedEvent)
   {
     m_PendingSliceChangedEvent = true;
 
     QTimer::singleShot(0, this, SLOT(OnSliceChangedDelayed()));
   }
-};
+}
 
 void QmitkSliceNavigationListener::OnSliceNavigationControllerDeleted(const itk::Object* sender, const itk::EventObject& /*e*/)
 {
   const mitk::SliceNavigationController* sendingSlicer =
     dynamic_cast<const mitk::SliceNavigationController*>(sender);
 
   this->RemoveObservers(sendingSlicer);
-};
+}
 
 void QmitkSliceNavigationListener::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_renderWindowPart != renderWindowPart)
   {
     m_renderWindowPart = renderWindowPart;
 
     if (!InitObservers())
     {
       QMessageBox::information(nullptr, "Error", "Unable to set up the event observers. The " \
         "plot will not be triggered on changing the crosshair, " \
         "position or time step.");
     }
 
     m_CurrentSelectedPosition = m_renderWindowPart->GetSelectedPosition();
     m_CurrentSelectedTimePoint = m_renderWindowPart->GetSelectedTimePoint();
   }
-};
+}
 
 void QmitkSliceNavigationListener::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   m_renderWindowPart = nullptr;
   this->RemoveAllObservers(renderWindowPart);
-};
+}
 
 bool QmitkSliceNavigationListener::InitObservers()
 {
   bool result = true;
 
   typedef QHash<QString, QmitkRenderWindow*> WindowMapType;
   WindowMapType windowMap = m_renderWindowPart->GetQmitkRenderWindows();
 
   auto i = windowMap.begin();
 
   while (i != windowMap.end())
   {
     mitk::SliceNavigationController* sliceNavController =
       i.value()->GetSliceNavigationController();
 
     if (sliceNavController)
     {
       itk::ReceptorMemberCommand<QmitkSliceNavigationListener>::Pointer cmdSliceEvent =
         itk::ReceptorMemberCommand<QmitkSliceNavigationListener>::New();
       cmdSliceEvent->SetCallbackFunction(this, &QmitkSliceNavigationListener::OnSliceChangedInternal);
       int tag = sliceNavController->AddObserver(
         mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0),
         cmdSliceEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_renderWindowPart)));
 
       itk::ReceptorMemberCommand<QmitkSliceNavigationListener>::Pointer cmdTimeEvent =
         itk::ReceptorMemberCommand<QmitkSliceNavigationListener>::New();
       cmdTimeEvent->SetCallbackFunction(this, &QmitkSliceNavigationListener::OnSliceChangedInternal);
       tag = sliceNavController->AddObserver(
         mitk::SliceNavigationController::GeometryTimeEvent(nullptr, 0),
         cmdTimeEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_renderWindowPart)));
 
       itk::MemberCommand<QmitkSliceNavigationListener>::Pointer cmdDelEvent =
         itk::MemberCommand<QmitkSliceNavigationListener>::New();
       cmdDelEvent->SetCallbackFunction(this,
         &QmitkSliceNavigationListener::OnSliceNavigationControllerDeleted);
       tag = sliceNavController->AddObserver(
         itk::DeleteEvent(), cmdDelEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_renderWindowPart)));
     }
 
     ++i;
 
     result = result && sliceNavController;
   }
 
   return result;
-};
+}
 
 void QmitkSliceNavigationListener::RemoveObservers(const mitk::SliceNavigationController* deletedSlicer)
 {
   std::pair < ObserverMapType::const_iterator, ObserverMapType::const_iterator> obsRange =
     m_ObserverMap.equal_range(deletedSlicer);
 
   for (ObserverMapType::const_iterator pos = obsRange.first; pos != obsRange.second; ++pos)
   {
     pos->second.controller->RemoveObserver(pos->second.observerTag);
   }
 
   m_ObserverMap.erase(deletedSlicer);
-};
+}
 
 void QmitkSliceNavigationListener::RemoveAllObservers(mitk::IRenderWindowPart* deletedPart)
 {
   for (ObserverMapType::const_iterator pos = m_ObserverMap.begin(); pos != m_ObserverMap.end();)
   {
     ObserverMapType::const_iterator delPos = pos++;
 
     if (deletedPart == nullptr || deletedPart == delPos->second.renderWindowPart)
     {
       delPos->second.controller->RemoveObserver(delPos->second.observerTag);
       m_ObserverMap.erase(delPos);
     }
   }
-};
+}
 
 QmitkSliceNavigationListener::ObserverInfo::ObserverInfo(mitk::SliceNavigationController* controller, int observerTag,
   const std::string& renderWindowName, mitk::IRenderWindowPart* part) : controller(controller), observerTag(observerTag),
   renderWindowName(renderWindowName), renderWindowPart(part)
 {
-};
+}
diff --git a/Plugins/org.mitk.gui.qt.dicominspector/src/internal/QmitkDicomInspectorView.cpp b/Plugins/org.mitk.gui.qt.dicominspector/src/internal/QmitkDicomInspectorView.cpp
index 9004dac7f8..d3b1171e2c 100644
--- a/Plugins/org.mitk.gui.qt.dicominspector/src/internal/QmitkDicomInspectorView.cpp
+++ b/Plugins/org.mitk.gui.qt.dicominspector/src/internal/QmitkDicomInspectorView.cpp
@@ -1,378 +1,377 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 
 // mitk
 #include <QmitkRenderWindow.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkPixelTypeMultiplex.h>
 
 // Qt
 #include <QMessageBox>
 #include <QMessageBox>
 #include <QFileDialog>
 #include <qwt_plot_marker.h>
 
 #include "QmitkDicomInspectorView.h"
 
 const std::string QmitkDicomInspectorView::VIEW_ID = "org.mitk.views.dicominspector";
 
 QmitkDicomInspectorView::ObserverInfo::ObserverInfo(mitk::SliceNavigationController* controller,
   int observerTag, const std::string& renderWindowName, mitk::IRenderWindowPart* part) : controller(controller), observerTag(observerTag),
   renderWindowName(renderWindowName), renderWindowPart(part)
 {
 }
 
 QmitkDicomInspectorView::QmitkDicomInspectorView()
   : m_RenderWindowPart(nullptr)
   , m_PendingSliceChangedEvent(false)
   , m_SelectedNode(nullptr)
   , m_SelectedTimePoint(0.)
   , m_CurrentSelectedZSlice(0)
 {
   m_SelectedPosition.Fill(0.0);
 }
 
 QmitkDicomInspectorView::~QmitkDicomInspectorView()
 {
   this->RemoveAllObservers();
 }
 
 void QmitkDicomInspectorView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart != renderWindowPart)
   {
     m_RenderWindowPart = renderWindowPart;
 
     if (!InitObservers())
     {
       QMessageBox::information(nullptr, "Error", "Unable to set up the event observers. The " \
         "plot will not be triggered on changing the crosshair, " \
         "position or time step.");
     }
   }
 }
 
 void QmitkDicomInspectorView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   m_RenderWindowPart = nullptr;
   this->RemoveAllObservers(renderWindowPart);
 }
 
 void QmitkDicomInspectorView::CreateQtPartControl(QWidget* parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
 
   m_Controls.singleSlot->SetDataStorage(GetDataStorage());
   m_Controls.singleSlot->SetSelectionIsOptional(true);
   m_Controls.singleSlot->SetAutoSelectNewNodes(true);
   m_Controls.singleSlot->SetEmptyInfo(QString("Please select a data node"));
   m_Controls.singleSlot->SetPopUpTitel(QString("Select data node"));
 
   m_SelectionServiceConnector = std::make_unique<QmitkSelectionServiceConnector>();
   SetAsSelectionListener(true);
 
   m_Controls.timePointValueLabel->setText(QString(""));
   m_Controls.sliceNumberValueLabel->setText(QString(""));
 
   connect(m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkDicomInspectorView::OnCurrentSelectionChanged);
 
   mitk::IRenderWindowPart* renderWindowPart = GetRenderWindowPart();
   RenderWindowPartActivated(renderWindowPart);
 }
 
 bool QmitkDicomInspectorView::InitObservers()
 {
   bool result = true;
 
   typedef QHash<QString, QmitkRenderWindow*> WindowMapType;
   WindowMapType windowMap = m_RenderWindowPart->GetQmitkRenderWindows();
 
   auto i = windowMap.begin();
 
   while (i != windowMap.end())
   {
     mitk::SliceNavigationController* sliceNavController =
       i.value()->GetSliceNavigationController();
 
     if (sliceNavController)
     {
       auto cmdSliceEvent = itk::SimpleMemberCommand<QmitkDicomInspectorView>::New();
       cmdSliceEvent->SetCallbackFunction(this, &QmitkDicomInspectorView::OnSliceChanged);
       int tag = sliceNavController->AddObserver(
         mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), cmdSliceEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_RenderWindowPart)));
 
       auto cmdTimeEvent = itk::SimpleMemberCommand<QmitkDicomInspectorView>::New();
       cmdTimeEvent->SetCallbackFunction(this, &QmitkDicomInspectorView::OnSliceChanged);
       tag = sliceNavController->AddObserver(
         mitk::SliceNavigationController::GeometryTimeEvent(nullptr, 0), cmdTimeEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_RenderWindowPart)));
 
       auto cmdDelEvent = itk::MemberCommand<QmitkDicomInspectorView>::New();
       cmdDelEvent->SetCallbackFunction(this, &QmitkDicomInspectorView::OnSliceNavigationControllerDeleted);
       tag = sliceNavController->AddObserver(itk::DeleteEvent(), cmdDelEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_RenderWindowPart)));
     }
 
     ++i;
 
     result = result && sliceNavController;
   }
 
   return result;
 }
 
 void QmitkDicomInspectorView::RemoveObservers(const mitk::SliceNavigationController* deletedSlicer)
 {
   std::pair<ObserverMapType::const_iterator, ObserverMapType::const_iterator> obsRange =
     m_ObserverMap.equal_range(deletedSlicer);
 
   for (ObserverMapType::const_iterator pos = obsRange.first; pos != obsRange.second; ++pos)
   {
     pos->second.controller->RemoveObserver(pos->second.observerTag);
   }
 
   m_ObserverMap.erase(deletedSlicer);
 }
 
 void QmitkDicomInspectorView::RemoveAllObservers(mitk::IRenderWindowPart* deletedPart)
 {
   for (ObserverMapType::const_iterator pos = m_ObserverMap.begin(); pos != m_ObserverMap.end();)
   {
     ObserverMapType::const_iterator delPos = pos++;
 
     if (nullptr == deletedPart || deletedPart == delPos->second.renderWindowPart)
     {
       delPos->second.controller->RemoveObserver(delPos->second.observerTag);
       m_ObserverMap.erase(delPos);
     }
   }
 }
 
 void QmitkDicomInspectorView::OnCurrentSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   if (nodes.empty() || nodes.front().IsNull())
   {
     m_SelectedNode = nullptr;
     m_SelectedData = nullptr;
     UpdateData();
     return;
   }
 
   if (nodes.front() != this->m_SelectedNode)
   {
     // node is selected, create DICOM tag table
     m_SelectedNode = nodes.front();
     m_SelectedData = this->m_SelectedNode->GetData();
 
     m_SelectedNodeTime.Modified();
     UpdateData();
     OnSliceChangedDelayed();
   }
 }
 
 void QmitkDicomInspectorView::OnSliceChanged()
 {
-  // Taken from QmitkStdMultiWidget::HandleCrosshairPositionEvent().
   // Since there are always 3 events arriving (one for each render window) every time the slice
   // or time changes, the slot OnSliceChangedDelayed is triggered - and only if it hasn't been
   // triggered yet - so it is only executed once for every slice/time change.
   if (!m_PendingSliceChangedEvent)
   {
     m_PendingSliceChangedEvent = true;
 
     QTimer::singleShot(0, this, SLOT(OnSliceChangedDelayed()));
   }
 }
 
 void QmitkDicomInspectorView::OnSliceNavigationControllerDeleted(const itk::Object* sender, const itk::EventObject& /*e*/)
 {
   auto sendingSlicer = dynamic_cast<const mitk::SliceNavigationController*>(sender);
 
   this->RemoveObservers(sendingSlicer);
 }
 
 void QmitkDicomInspectorView::ValidateAndSetCurrentPosition()
 {
   auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
   auto currentSelectedPosition = renderWindowPart->GetSelectedPosition(nullptr);
   const auto currentSelectedTimePoint = renderWindowPart->GetSelectedTimePoint();
 
   if (m_SelectedPosition != currentSelectedPosition
     || m_SelectedTimePoint != currentSelectedTimePoint
     || m_SelectedNodeTime > m_CurrentPositionTime)
   {
     // the current position has been changed, the selected node has been changed since
     // the last position validation or the current time position has been changed -> check position
     m_SelectedPosition = currentSelectedPosition;
     m_SelectedTimePoint = currentSelectedTimePoint;
     m_CurrentPositionTime.Modified();
     m_ValidSelectedPosition = false;
 
     if (m_SelectedData.IsNull())
     {
       return;
     }
 
     mitk::BaseGeometry::Pointer geometry = m_SelectedData->GetTimeGeometry()->GetGeometryForTimePoint(m_SelectedTimePoint);
 
     // check for invalid time step
     if (geometry.IsNull())
     {
       geometry = m_SelectedData->GetTimeGeometry()->GetGeometryForTimeStep(0);
     }
 
     if (geometry.IsNull())
     {
       return;
     }
 
     m_ValidSelectedPosition = geometry->IsInside(m_SelectedPosition);
     itk::Index<3> index;
     geometry->WorldToIndex(m_SelectedPosition, index);
 
     m_CurrentSelectedZSlice = index[2];
   }
 }
 
 void QmitkDicomInspectorView::OnSliceChangedDelayed()
 {
   m_PendingSliceChangedEvent = false;
 
   ValidateAndSetCurrentPosition();
 
   m_Controls.tableTags->setEnabled(m_ValidSelectedPosition);
 
   if (m_SelectedNode.IsNotNull())
   {
     RenderTable();
   }
 }
 
 void QmitkDicomInspectorView::RenderTable()
 {
   assert(nullptr != m_RenderWindowPart);
 
   const auto timeStep = (m_SelectedData.IsNull()) ? 0 : m_SelectedData->GetTimeGeometry()->TimePointToTimeStep(m_SelectedTimePoint);
 
   unsigned int rowIndex = 0;
   for (const auto& element : m_Tags)
   {
     QTableWidgetItem* newItem = new QTableWidgetItem(QString::fromStdString(
       element.second.prop->GetValue(timeStep, m_CurrentSelectedZSlice, true, true)));
     m_Controls.tableTags->setItem(rowIndex, 3, newItem);
     ++rowIndex;
   }
 
   UpdateLabels();
 }
 
 void QmitkDicomInspectorView::UpdateData()
 {
   QStringList headers;
 
   m_Controls.tableTags->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
 
   m_Tags.clear();
 
   if (m_SelectedData.IsNotNull())
   {
     for (const auto& element : *(m_SelectedData->GetPropertyList()->GetMap()))
     {
       if (element.first.find("DICOM") == 0)
       {
         std::istringstream stream(element.first);
         std::string token;
         std::getline(stream, token, '.'); //drop the DICOM suffix
         std::getline(stream, token, '.'); //group id
         unsigned long dcmgroup = std::stoul(token, nullptr, 16);
         std::getline(stream, token, '.'); //element id
         unsigned long dcmelement = std::stoul(token, nullptr, 16);
 
         TagInfo info(mitk::DICOMTag(dcmgroup, dcmelement), dynamic_cast<const mitk::DICOMProperty*>(element.second.GetPointer()));
 
         m_Tags.insert(std::make_pair(element.first, info));
       }
     }
   }
 
   m_Controls.tableTags->setRowCount(m_Tags.size());
 
   unsigned int rowIndex = 0;
   for (const auto& element : m_Tags)
   {
     QTableWidgetItem* newItem = new QTableWidgetItem(QString::number(element.second.tag.GetGroup(), 16));
     m_Controls.tableTags->setItem(rowIndex, 0, newItem);
     newItem = new QTableWidgetItem(QString::number(element.second.tag.GetElement(), 16));
     m_Controls.tableTags->setItem(rowIndex, 1, newItem);
     newItem = new QTableWidgetItem(QString::fromStdString(element.second.tag.GetName()));
     m_Controls.tableTags->setItem(rowIndex, 2, newItem);
     newItem = new QTableWidgetItem(QString::fromStdString(element.second.prop->GetValue()));
     m_Controls.tableTags->setItem(rowIndex, 3, newItem);
     ++rowIndex;
   }
 
   UpdateLabels();
 }
 
 void QmitkDicomInspectorView::UpdateLabels()
 {
   if (m_SelectedData.IsNull())
   {
     m_Controls.timePointValueLabel->setText(QString(""));
     m_Controls.sliceNumberValueLabel->setText(QString(""));
   }
   else
   {
     const auto timeStep = m_SelectedData->GetTimeGeometry()->TimePointToTimeStep(m_SelectedTimePoint);
 
     if (m_ValidSelectedPosition)
     {
       m_Controls.timePointValueLabel->setText(QString::number(timeStep) + QStringLiteral("(")+ QString::number(m_SelectedTimePoint/1000.) + QStringLiteral(" [s])"));
       m_Controls.sliceNumberValueLabel->setText(QString::number(m_CurrentSelectedZSlice));
     }
     else
     {
       m_Controls.timePointValueLabel->setText(QString("outside data geometry"));
       m_Controls.sliceNumberValueLabel->setText(QString("outside data geometry"));
     }
   }
 }
 
 void QmitkDicomInspectorView::SetAsSelectionListener(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
     connect(m_SelectionServiceConnector.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged,
       m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
   }
   else
   {
     m_SelectionServiceConnector->RemovePostSelectionListener();
     disconnect(m_SelectionServiceConnector.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged,
       m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
   }
 }