diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake
index 49db018347..9ea0347b08 100644
--- a/Modules/Core/files.cmake
+++ b/Modules/Core/files.cmake
@@ -1,323 +1,322 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   mitkCoreActivator.cpp
   mitkCoreObjectFactoryBase.cpp
   mitkCoreObjectFactory.cpp
   mitkCoreServices.cpp
   mitkException.cpp
 
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkCompareImageDataFilter.cpp
   Algorithms/mitkCompositePixelValueToString.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkExtractSliceFilter2.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp
   Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkTemporalJoinImagesFilter.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkCrosshairManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSliceNavigationHelper.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkLayerController.cpp
 
   DataManagement/mitkAnatomicalStructureColorPresets.cpp
   DataManagement/mitkArbitraryTimeGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseGeometry.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataStorage.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGeometryTransformHolder.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkGenericIDRelationRule.cpp
   DataManagement/mitkIdentifiable.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageReadAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageVtkReadAccessor.cpp
   DataManagement/mitkImageVtkWriteAccessor.cpp
   DataManagement/mitkImageWriteAccessor.cpp
   DataManagement/mitkIntPropertyExtension.cpp
   DataManagement/mitkIPersistenceService.cpp
   DataManagement/mitkIPropertyAliases.cpp
   DataManagement/mitkIPropertyDescriptions.cpp
   DataManagement/mitkIPropertyExtensions.cpp
   DataManagement/mitkIPropertyFilters.cpp
   DataManagement/mitkIPropertyOwner.cpp
   DataManagement/mitkIPropertyPersistence.cpp
   DataManagement/mitkIPropertyProvider.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLine.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTableProperty.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMaterial.cpp
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModifiedLock.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDataUID.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateFunction.cpp
   DataManagement/mitkNodePredicateGeometry.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateDataProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkNodePredicateSubGeometry.cpp
   DataManagement/mitkNumericConstants.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneGeometryData.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkPointSetShapeProperty.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyAliases.cpp
   DataManagement/mitkPropertyDescriptions.cpp
   DataManagement/mitkPropertyExtension.cpp
   DataManagement/mitkPropertyExtensions.cpp
   DataManagement/mitkPropertyFilter.cpp
   DataManagement/mitkPropertyFilters.cpp
   DataManagement/mitkPropertyKeyPath.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkPropertyNameHelper.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkPropertyPersistence.cpp
   DataManagement/mitkPropertyPersistenceInfo.cpp
   DataManagement/mitkPropertyRelationRuleBase.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkScaleOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkSourceImageRelationRule.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTemporoSpatialStringProperty.cpp
   DataManagement/mitkUIDManipulator.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVectorProperty.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkIPropertyRelations.cpp
   DataManagement/mitkPropertyRelations.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
-  Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayActionEventBroadcast.cpp
   Interactions/mitkDisplayActionEventFunctions.cpp
   Interactions/mitkDisplayActionEventHandler.cpp
   Interactions/mitkDisplayActionEventHandlerDesynchronized.cpp
   Interactions/mitkDisplayActionEventHandlerStd.cpp
   Interactions/mitkDisplayActionEventHandlerSynchronized.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkEventRecorder.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkInteractionEventObserver.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionSchemeSwitcher.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkSinglePointDataInteractor.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineCondition.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkXML2EventParser.cpp
 
   IO/mitkAbstractFileIO.cpp
   IO/mitkAbstractFileReader.cpp
   IO/mitkAbstractFileWriter.cpp
   IO/mitkCustomMimeType.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileReaderRegistry.cpp
   IO/mitkFileReaderSelector.cpp
   IO/mitkFileReaderWriterBase.cpp
   IO/mitkFileWriter.cpp
   IO/mitkFileWriterRegistry.cpp
   IO/mitkFileWriterSelector.cpp
   IO/mitkGeometry3DToXML.cpp
   IO/mitkIFileIO.cpp
   IO/mitkIFileReader.cpp
   IO/mitkIFileWriter.cpp
   IO/mitkGeometryDataReaderService.cpp
   IO/mitkGeometryDataWriterService.cpp
   IO/mitkImageGenerator.cpp
   IO/mitkImageVtkLegacyIO.cpp
   IO/mitkImageVtkXmlIO.cpp
   IO/mitkIMimeTypeProvider.cpp
   IO/mitkIOConstants.cpp
   IO/mitkIOMimeTypes.cpp
   IO/mitkIOUtil.cpp
   IO/mitkItkImageIO.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkLegacyFileReaderService.cpp
   IO/mitkLegacyFileWriterService.cpp
   IO/mitkLocaleSwitch.cpp
   IO/mitkLog.cpp
   IO/mitkMimeType.cpp
   IO/mitkMimeTypeProvider.cpp
   IO/mitkOperation.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetReaderService.cpp
   IO/mitkPointSetWriterService.cpp
   IO/mitkProportionalTimeGeometryToXML.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSurfaceStlIO.cpp
   IO/mitkSurfaceVtkIO.cpp
   IO/mitkSurfaceVtkLegacyIO.cpp
   IO/mitkSurfaceVtkXmlIO.cpp
   IO/mitkUtf8Util.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkPreferenceListReaderOptionsFunctor.cpp
   IO/mitkIOMetaInformationPropertyConstants.cpp
 
   Rendering/mitkAbstractAnnotationRenderer.cpp
   Rendering/mitkAnnotationUtils.cpp
   Rendering/mitkBaseRenderer.cpp
   #Rendering/mitkGLMapper.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkAnnotation.cpp
   Rendering/mitkPlaneGeometryDataMapper2D.cpp
   Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowFrame.cpp
   #Rendering/mitkSurfaceGLMapper2D.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkSurfaceVtkMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
 )
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfigMITKBase.xml
 Interactions/DisplayConfigPACSBase.xml
 Interactions/DisplayConfigCrosshair.xml
 Interactions/DisplayConfigRotation.xml
 Interactions/DisplayConfigActivateCoupling.xml
 Interactions/DisplayConfigSwivel.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigBlockLMB.xml
 Interactions/PointSet.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 mitkAnatomicalStructureColorPresets.xml
 )
diff --git a/Modules/Core/include/mitkCrosshairPositionEvent.h b/Modules/Core/include/mitkCrosshairPositionEvent.h
deleted file mode 100644
index 0d22b2969f..0000000000
--- a/Modules/Core/include/mitkCrosshairPositionEvent.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*============================================================================
-
-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 mitkCrosshairPositionEvent_h
-#define mitkCrosshairPositionEvent_h
-
-#include <MitkCoreExports.h>
-#include <mitkInteractionEvent.h>
-
-namespace mitk
-{
-  /** A special mitk::Event thrown by the SliceNavigationController on mouse scroll
-    */
-  class MITKCORE_EXPORT CrosshairPositionEvent : public mitk::InteractionEvent
-  {
-  public:
-    CrosshairPositionEvent(BaseRenderer *sender);
-  };
-}
-
-#endif
diff --git a/Modules/Core/include/mitkDisplayActionEventBroadcast.h b/Modules/Core/include/mitkDisplayActionEventBroadcast.h
index d2470f5854..30066977f8 100644
--- a/Modules/Core/include/mitkDisplayActionEventBroadcast.h
+++ b/Modules/Core/include/mitkDisplayActionEventBroadcast.h
@@ -1,224 +1,218 @@
 /*============================================================================
 
 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 MITKDISPLAYACTIONEVENTBROADCAST_H
 #define MITKDISPLAYACTIONEVENTBROADCAST_H
 
 #include "mitkInteractionEventObserver.h"
 #include <MitkCoreExports.h>
 
 namespace mitk
 {
   /**
   * @brief This class serves as an event state machine while simultaneously observing interaction events.
   *   It connects the actions from the event state machine .xml-file with concrete functions of this class.
   *
   *   The observed interaction events are mouse events that trigger certain actions, according to an event configuration (e.g. PACS mode).
   *   These actions are defined and connected inside this broadcast class.
   *   They typically contain some preprocessing steps and use the results of the preprocessing to broadcast a specific display event.
   *
   *   Any instance that wants to react on the invoked events can call 'AddObserver' on a specific broadcast instance,
   *   given an itkEventObject and an itkCommand.
   */
   class MITKCORE_EXPORT DisplayActionEventBroadcast : public EventStateMachine, public InteractionEventObserver
   {
   public:
     mitkClassMacro(DisplayActionEventBroadcast, EventStateMachine);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     /**
     * By this function this observer is notified about about every 'InteractionEvent'.
     * The interaction event is passed to the state machine in order to use its infrastructure.
     * For more information see @see InteractionEventObserver.
     *
     * @par  interactionEvent    The event that was observed and triggered this notification.
     * @par  isHandled           Flag that indicates if a 'DataInteractor' has already handled the event.
     */
     void Notify(InteractionEvent* interactionEvent, bool isHandled) override;
 
   protected:
 
     DisplayActionEventBroadcast();
     ~DisplayActionEventBroadcast() override;
 
     /**
     * @brief Connects the action names used in the state machine pattern with functions implemented within this InteractionEventObserver.
     */
     void ConnectActionsAndFunctions() override;
     /**
     * @brief This function is executed when a config object is set / changed (via 'SetEventConfig' or 'AddEventConfig' in 'InteractionEventObserver').
     *     It is used to read out the parameters set in the configuration file and to set the member variables accordingly.
     */
     void ConfigurationChanged() override;
     /**
     * @brief Filters the event resp. the sender of the event.
     *
     * @par      interactionEvent    The event whose sender has to be checked
     * @par      data node           The data node is ignored in this specific implementation.
     *
     * @return   True, if the sender of the event is a valid sender and the sending renderer is a 2D-renderer. False, if not.
     */
     bool FilterEvents(InteractionEvent* interactionEvent, DataNode* dataNode) override;
 
     //////////////////////////////////////////////////////////////////////////
     // Functions to react to interaction events (actions)
     //////////////////////////////////////////////////////////////////////////
     /**
     * @brief Check if the given interaction event is actually an 'InteractionPositionEvent'.
     *
     * @par interactionEvent   The interaction event that is checked.
     *
     * @return True, if the given event can be dynamically cast to an 'InteractionPositionEvent'. False, if not.
     */
     bool CheckPositionEvent(const InteractionEvent* interactionEvent);
 
     bool CheckRotationPossible(const InteractionEvent* interactionEvent);
 
     bool CheckSwivelPossible(const InteractionEvent* interactionEvent);
 
     void Init(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void Move(StateMachineAction* stateMachineAction , InteractionEvent* interactionEvent);
 
     void SetCrosshair(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void Zoom(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void Scroll(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void ScrollOneUp(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void ScrollOneDown(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void AdjustLevelWindow(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void StartRotation(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void EndRotation(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void Rotate(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void Swivel(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void IncreaseTimeStep(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
     void DecreaseTimeStep(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
 
   private:
 
-    void UpdateStatusbar(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
-
     bool GetBoolProperty(PropertyList::Pointer propertyList, const char* propertyName, bool defaultValue);
 
     /**
     * @brief Reference to the service registration of the observer.
     *   This is needed to unregister the observer on unload.
     */
     us::ServiceRegistration<InteractionEventObserver> m_ServiceRegistration;
 
     /**
     * @brief Determines if this broadcast class reacts to events that already have been processed by a DataInteractor.
     *     The default value is false.
     */
     bool m_AlwaysReact;
 
     /**
     * @brief Coordinate of the mouse pointer at beginning of an interaction (translated to mm unit).
     */
     Point2D m_StartCoordinateInMM;
     /**
     * @brief Coordinate of the mouse pointer in the last step within an interaction.
     */
     Point2D m_LastDisplayCoordinate;
     /**
-    * @brief Coordinate of the mouse pointer in the last step within an interaction (translated to mm unit).
-    */
-    Point2D m_LastCoordinateInMM;
-    /**
     * \brief Current coordinates of the pointer.
     */
     Point2D m_CurrentDisplayCoordinate;
 
     /**
     * @brief Defines the behavior at the end of a data set.
     *     If set to true, it will restart at end of data set from the beginning.
     */
     bool m_AutoRepeat;
     /**
     * @brief Defines how many slices are scrolled per pixel that the mouse pointer was moved.
     *     By default the modifier is 4. This means that when the user moves the cursor by 4 pixels in Y-direction,
     *     the scene is scrolled by one slice. If the user has moved the the cursor by 20 pixels, the scene is
     *     scrolled by 5 slices.
     *
     *     If the cursor has moved less than m_IndexToSliceModifier pixels, the scene is scrolled by one slice.
     */
     int m_IndexToSliceModifier;
     /**
     * @brief Defines the scroll behavior.
     *     Default is up/down movement of pointer performs scrolling
     */
     std::string m_ScrollDirection;
     /**
     * @brief Defines how the axis of interaction influences scroll behavior.
     */
     bool m_InvertScrollDirection;
     /**
     * @brief Defines the zoom behavior.
     *     Default is up/down movement of pointer performs zooming
     */
     std::string m_ZoomDirection;
     /**
     * @brief Defines how the axis of interaction influences zoom behavior.
     */
     bool m_InvertZoomDirection;
     /**
     * @brief Factor to adjust zooming speed.
     */
     float m_ZoomFactor;
     /**
     * @brief Defines how the axis of interaction influences move behavior.
     */
     bool m_InvertMoveDirection;
     /**
     * @brief Defines the level-window behavior.
     *     Default is left/right movement of pointer modifies the level.
     */
     std::string m_LevelDirection;
     /**
     * @brief Defines how the axis of interaction influences level-window behavior.
     */
     bool m_InvertLevelWindowDirection;
     /**
     * @brief Determines if the angle between crosshair remains fixed when rotating.
     */
     bool m_LinkPlanes;
 
     typedef std::vector<SliceNavigationController*> SNCVector;
     SNCVector m_RotatableSNCs;
     SNCVector m_SNCsToBeRotated;
 
     Point3D m_LastCursorPosition;
     Point3D m_CenterOfRotation;
 
     Point2D m_ReferenceCursor;
 
     Vector3D m_RotationPlaneNormal;
     Vector3D m_RotationPlaneXVector;
     Vector3D m_RotationPlaneYVector;
 
     Vector3D m_PreviousRotationAxis;
     ScalarType m_PreviousRotationAngle;
   };
 } // end namespace
 
 #endif // MITKDISPLAYACTIONEVENTBROADCAST_H
diff --git a/Modules/Core/include/mitkStatusBar.h b/Modules/Core/include/mitkStatusBar.h
index 7e45957ffe..16a5edab5c 100755
--- a/Modules/Core/include/mitkStatusBar.h
+++ b/Modules/Core/include/mitkStatusBar.h
@@ -1,91 +1,92 @@
 /*============================================================================
 
 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 MITKSTATUSBAR_H
 #define MITKSTATUSBAR_H
 #include "mitkStatusBarImplementation.h"
 #include <MitkCoreExports.h>
 #include <itkObject.h>
 #include <mitkPoint.h>
+#include <mitkTimeGeometry.h>
 #include <itkIndex.h>
 
 namespace mitk
 {
   //##Documentation
   //## @brief Sending a message to the applications StatusBar
   //##
   //## Holds a GUI dependent StatusBarImplementation and sends the text further.
   //## nearly equal to itk::OutputWindow,
   //## no Window, but one line of text and a delay for clear.
   //## all mitk-classes use this class to display text on GUI-StatusBar.
   //## The mainapplication has to set the internal held StatusBarImplementation with SetInstance(..).
   //## @ingroup Interaction
   class MITKCORE_EXPORT StatusBar : public itk::Object
   {
   public:
     itkTypeMacro(StatusBar, itk::Object);
 
     //##Documentation
     //## @brief static method to get the GUI dependent StatusBar-instance
     //## so the methods DisplayText, etc. can be called
     //## No reference counting, cause of decentral static use!
     static StatusBar *GetInstance();
 
     //##Documentation
     //## @brief Supply a GUI- dependent StatusBar. Has to be set by the application
     //## to connect the application dependent subclass of mitkStatusBar
     //## if you create an instance, then call ->Delete() on the supplied
     //## instance after setting it.
     static void SetImplementation(StatusBarImplementation *instance);
 
     //##Documentation
     //## @brief Send a string to the applications StatusBar
     void DisplayText(const char *t);
     //##Documentation
     //## @brief Send a string with a time delay to the applications StatusBar
     void DisplayText(const char *t, int ms);
     void DisplayErrorText(const char *t);
     void DisplayWarningText(const char *t);
     void DisplayWarningText(const char *t, int ms);
     void DisplayGenericOutputText(const char *t);
     void DisplayDebugText(const char *t);
     void DisplayGreyValueText(const char *t);
 
     //##Documentation
+    void DisplayRendererInfo(Point3D point, TimePointType time);
     //## @brief Display position, index, time and pixel value
-    void DisplayImageInfo(mitk::Point3D point, itk::Index<3> index, mitk::ScalarType time, mitk::ScalarType pixelValue);
+    void DisplayImageInfo(Point3D point, itk::Index<3> index, TimePointType time, ScalarType pixelValue);
     //## @brief Display rotation, index, time and custom pixel value
-    void DisplayImageInfo(mitk::Point3D point, itk::Index<3> index, mitk::ScalarType time, const char *pixelValue);
-    //##Documentation
+    void DisplayImageInfo(Point3D point, itk::Index<3> index, TimePointType time, const char* pixelValue);
     //## @brief Display placeholder text for invalid information
     void DisplayImageInfoInvalid();
 
     //##Documentation
     //## @brief removes any temporary message being shown.
     void Clear();
 
     //##Documentation
     //## @brief Set the SizeGrip of the window
     //## (the triangle in the lower right Windowcorner for changing the size)
     //## to enabled or disabled
     void SetSizeGripEnabled(bool enable);
 
   protected:
     StatusBar();
     ~StatusBar() override;
 
     static StatusBarImplementation *m_Implementation;
     static StatusBar *m_Instance;
   };
 
 } // end namespace mitk
 #endif /* define MITKSTATUSBAR_H */
diff --git a/Modules/Core/resource/Interactions/DisplayInteraction.xml b/Modules/Core/resource/Interactions/DisplayInteraction.xml
index 81e8d9e23f..82a24b1299 100644
--- a/Modules/Core/resource/Interactions/DisplayInteraction.xml
+++ b/Modules/Core/resource/Interactions/DisplayInteraction.xml
@@ -1,175 +1,165 @@
 <!--
 State machine pattern for display interactions:
 -Zooming
 -Panning
 -Scrolling through planes
 -Adjusting the LevelWindow
 
 For some interactions several transitions exists, which one is used can be determined by the configuration file.
 If an event_variant is not declared in the configuration file it is disabled.
 
 For example scrolling can be triggered by Key-, Wheel- or MouseMove events, where the latter needs an extra state for scrolling.
 So they are triggered by different event_variants, to choose which one is used, describe the desired event_variant in a config file
 and omit the others. See DisplayConfig___ for examples and also for parameters for the interaction behaviour.
 
 
 TODO Std move to abort interaction of scroll/pan/zoom
 -->
 <statemachine>
     <state name="start" startstate="true" >
         <transition event_class="InteractionPositionEvent" event_variant="StartMove" target="move">
           <condition name="check_position_event"/>
           <action name="init"/>
         </transition>
         <transition event_class="InteractionPositionEvent" event_variant="StartZoom" target="zoom">
           <condition name="check_position_event"/>
           <action name="init"/>
         </transition>
         <!-- mitkDisplayInteractor.cpp implements this for all events -->
         <transition event_class="InteractionEvent" event_variant="PlaneUP" target="start">
             <action name="ScrollOneUp"/>
-            <action name="updateStatusbar"/>
         </transition>
         <transition event_class="InteractionEvent" event_variant="PlaneDown" target="start">
             <action name="ScrollOneDown"/>
-            <action name="updateStatusbar"/>
         </transition>
         <transition event_class="MousePressEvent"  event_variant="StartScroll" target="scroll">
             <action name="init"/>
         </transition>
         <transition event_class="MousePressEvent"  event_variant="StartAdjustLevelWindow" target="adjustlevelwindow">
             <action name="init"/>
         </transition>
         <transition event_class="InteractionPositionEvent"  event_variant="SetCrosshair" target="crosshair">
             <action name="setCrosshair"/>
-            <action name="updateStatusbar"/>
         </transition>
         <transition event_class="InteractionPositionEvent"  event_variant="Move" target="rotationPossible">
             <condition name="check_can_rotate"/>
             <action name="startRotation"/>
         </transition>
         <!-- Case when we do crosshair instead of rotation) -->
         <transition event_class="InteractionPositionEvent"  event_variant="StartRotate" target="crosshair">
             <condition name="check_can_rotate" inverted="true" />
             <action name="setCrosshair"/>
-            <action name="updateStatusbar"/>
         </transition>
 
         <transition event_class="InteractionPositionEvent"  event_variant="StartSwivel" target="swivel">
             <condition name="check_can_swivel"/>
         </transition>
         <!-- Case when we do crosshair instead of swivel) -->
         <transition event_class="InteractionPositionEvent"  event_variant="StartSwivel" target="crosshair">
             <condition name="check_can_swivel" inverted="true"/>
             <action name="setCrosshair"/>
-            <action name="updateStatusbar"/>
         </transition>
          <!-- Change TimeSteps by clicking left or right Arrow-->
         <transition event_class="InteractionEvent" event_variant="IncreaseTimeStep" target="start">
           <action name="IncreaseTimeStep"/>
         </transition>
         <transition event_class="InteractionEvent" event_variant="DecreaseTimeStep" target="start">
           <action name="DecreaseTimeStep"/>
         </transition>
     </state>
     <state name="crosshair">
       <transition event_class="InteractionPositionEvent"  event_variant="MoveCrosshair" target="crosshair">
         <action name="setCrosshair"/>
-        <action name="updateStatusbar"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="EndMoveCrosshair" target="start"/>
 
       <!-- Case when we jumped in from rotation (wanted to rotate, but not possible, so alternative action is to set crosshair) -->
       <transition event_class="InteractionPositionEvent"  event_variant="Rotate" target="crosshair">
         <action name="setCrosshair"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="EndRotate" target="start"/>
       <!-- Case when we do crosshair instead of swivel) -->
       <transition event_class="InteractionPositionEvent"  event_variant="Swivel" target="crosshair">
         <action name="setCrosshair"/>
-        <action name="updateStatusbar"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="EndSwivel" target="start"/>
       <transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
     </state>
     <state name="move">
       <transition event_class="InteractionPositionEvent" event_variant="Moving" target="move">
         <condition name="check_position_event"/>
         <action name="move"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="EndMoving" target="start"/>
       <transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
     </state>
     <state name="zoom">
       <transition event_class="InteractionPositionEvent" event_variant="Zooming" target="zoom">
         <condition name="check_position_event"/>
         <action name="zoom"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="EndZooming" target="start"/>
       <transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
     </state>
     <state name="scroll">
       <transition event_class="InteractionPositionEvent" event_variant="Scrolling" target="scroll">
         <condition name="check_position_event"/>
         <action name="scroll"/>
-        <action name="updateStatusbar"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="EndScrolling" target="start"/>
       <transition event_class="InteractionPositionEvent" event_variant="EndScrollingVar" target="start"/>
       <transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
     </state>
     <state name="adjustlevelwindow">
       <transition event_class="InteractionPositionEvent" event_variant="adjustlevelwindow" target="adjustlevelwindow">
         <condition name="check_position_event"/>
         <action name="levelWindow"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="EndLevelWindow" target="start"/>
       <transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
     </state>
     <state name="rotationPossible">
       <transition event_class="InteractionPositionEvent" event_variant="StartRotate" target="rotation">
         <action name="rotate"/>
       </transition>
       <transition event_class="InternalEvent" event_variant="LeaveRenderWindow" target="start">
        <action name="endRotation"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="Move" target="start">
         <condition name="check_can_rotate" inverted="true" />
         <action name="endRotation"/>
       </transition>
       <transition event_class="InteractionEvent" event_variant="PlaneUP" target="rotationPossible">
         <action name="ScrollOneUp"/>
-        <action name="updateStatusbar"/>
       </transition>
       <transition event_class="InteractionEvent" event_variant="PlaneDown" target="rotationPossible">
         <action name="ScrollOneDown"/>
-        <action name="updateStatusbar"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="StartMove" target="move">
         <condition name="check_position_event"/>
         <action name="init"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="StartZoom" target="zoom">
         <condition name="check_position_event"/>
         <action name="init"/>
       </transition>
       <transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
     </state>
     <state name="rotation">
       <transition event_class="InteractionPositionEvent" event_variant="Rotate" target="rotation">
         <action name="rotate"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="EndRotate" target="start">
         <action name="endRotation"/>
       </transition>
       <transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
     </state>
     <state name="swivel">
       <transition event_class="InteractionPositionEvent" event_variant="Swivel" target="swivel">
         <action name="swivel"/>
       </transition>
       <transition event_class="InteractionPositionEvent" event_variant="EndSwivel" target="start"/>
       <transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
     </state>
 
 </statemachine>
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/Modules/Core/src/Controllers/mitkStatusBar.cpp b/Modules/Core/src/Controllers/mitkStatusBar.cpp
index adba4af8cd..66bae1893c 100755
--- a/Modules/Core/src/Controllers/mitkStatusBar.cpp
+++ b/Modules/Core/src/Controllers/mitkStatusBar.cpp
@@ -1,164 +1,189 @@
 /*============================================================================
 
 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 "mitkStatusBar.h"
 #include <itkObjectFactory.h>
 #include <itkOutputWindow.h>
 
 namespace mitk
 {
   StatusBarImplementation *StatusBar::m_Implementation = nullptr;
   StatusBar *StatusBar::m_Instance = nullptr;
 
   /**
    * Display the text in the statusbar of the application
    */
   void StatusBar::DisplayText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayText(t);
   }
 
   /**
    * Display the text in the statusbar of the application for ms seconds
    */
   void StatusBar::DisplayText(const char *t, int ms)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayText(t, ms);
   }
 
   void StatusBar::DisplayErrorText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayErrorText(t);
   }
   void StatusBar::DisplayWarningText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayWarningText(t);
   }
   void StatusBar::DisplayWarningText(const char *t, int ms)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayWarningText(t, ms);
   }
   void StatusBar::DisplayGenericOutputText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayGenericOutputText(t);
   }
   void StatusBar::DisplayDebugText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayDebugText(t);
   }
   void StatusBar::DisplayGreyValueText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayGreyValueText(t);
   }
 
-  static void WriteCommonImageInfo(
-    std::ostringstream &stream, Point3D point, itk::Index<3> index, ScalarType time)
+  static void WriteCommonRendererInfo(std::ostringstream& stream, Point3D point, TimePointType time)
+  {
+    stream << "Position: <" << std::fixed << point[0] << ", "
+      << std::fixed << point[1] << ", "
+      << std::fixed << point[2] << "> mm; ";
+
+    stream << "Time: " << time << " ms";
+  }
+
+  static void WriteCommonImageInfo(std::ostringstream& stream, Point3D point, itk::Index<3> index, TimePointType time)
   {
     stream << "Position: <" << std::fixed << point[0] << ", "
                             << std::fixed << point[1] << ", "
                             << std::fixed << point[2] << "> mm; ";
 
     stream << "Index: <" << index[0] << ", "
                          << index[1] << ", "
                          << index[2] << "> ; ";
 
     stream << "Time: " << time << " ms";
   }
 
-  void StatusBar::DisplayImageInfo(Point3D point, itk::Index<3> index, ScalarType time, ScalarType pixelValue)
+  void StatusBar::DisplayRendererInfo(Point3D point, TimePointType time)
+  {
+    if (m_Implementation == nullptr)
+      return;
+
+    std::ostringstream stream;
+    stream.imbue(std::locale::classic());
+    stream.precision(2);
+
+    WriteCommonRendererInfo(stream, point, time);
+
+    m_Implementation->DisplayGreyValueText(stream.str().c_str());
+  }
+
+  void StatusBar::DisplayImageInfo(Point3D point, itk::Index<3> index, TimePointType time, ScalarType pixelValue)
   {
     if (m_Implementation == nullptr)
       return;
 
     std::ostringstream stream;
     stream.imbue(std::locale::classic());
     stream.precision(2);
 
     WriteCommonImageInfo(stream, point, index, time);
     stream << "; Pixel value: ";
 
     if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
       stream << std::scientific;
 
     stream << pixelValue;
 
     m_Implementation->DisplayGreyValueText(stream.str().c_str());
   }
 
-  void StatusBar::DisplayImageInfo(Point3D point, itk::Index<3> index, ScalarType time, const char *pixelValue)
+  void StatusBar::DisplayImageInfo(Point3D point, itk::Index<3> index, TimePointType time, const char* pixelValue)
   {
     if (m_Implementation == nullptr)
       return;
 
     std::ostringstream stream;
     stream.imbue(std::locale::classic());
     stream.precision(2);
 
     WriteCommonImageInfo(stream, point, index, time);
     stream << "; " << pixelValue;
 
     m_Implementation->DisplayGreyValueText(stream.str().c_str());
   }
 
   void StatusBar::DisplayImageInfoInvalid()
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayGreyValueText("No image information at this position!");
   }
+
   void StatusBar::Clear()
   {
     if (m_Implementation != nullptr)
       m_Implementation->Clear();
   }
+
   void StatusBar::SetSizeGripEnabled(bool enable)
   {
     if (m_Implementation != nullptr)
     {
       m_Implementation->SetSizeGripEnabled(enable);
     }
   }
+
   /**
    * Get the instance of this StatusBar
    */
   StatusBar *StatusBar::GetInstance()
   {
     if (m_Instance == nullptr) // if not set, then send a errormessage on OutputWindow
     {
       m_Instance = new StatusBar();
     }
 
     return m_Instance;
   }
 
   /**
    * Set an instance of this; application must do this!See Header!
    */
   void StatusBar::SetImplementation(StatusBarImplementation *implementation)
   {
     if (m_Implementation == implementation)
     {
       return;
     }
     m_Implementation = implementation;
   }
 
   StatusBar::StatusBar() {}
   StatusBar::~StatusBar() {}
 } // end namespace mitk
diff --git a/Modules/Core/src/Interactions/mitkCrosshairPositionEvent.cpp b/Modules/Core/src/Interactions/mitkCrosshairPositionEvent.cpp
deleted file mode 100644
index c85c6d970c..0000000000
--- a/Modules/Core/src/Interactions/mitkCrosshairPositionEvent.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-/*============================================================================
-
-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 "mitkCrosshairPositionEvent.h"
-
-mitk::CrosshairPositionEvent::CrosshairPositionEvent(BaseRenderer *sender) : InteractionEvent(sender)
-{
-}
diff --git a/Modules/Core/src/Interactions/mitkDisplayActionEventBroadcast.cpp b/Modules/Core/src/Interactions/mitkDisplayActionEventBroadcast.cpp
index 673085af97..c42172fe75 100644
--- a/Modules/Core/src/Interactions/mitkDisplayActionEventBroadcast.cpp
+++ b/Modules/Core/src/Interactions/mitkDisplayActionEventBroadcast.cpp
@@ -1,917 +1,807 @@
 /*============================================================================
 
 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 "mitkDisplayActionEventBroadcast.h"
 
  // us
 #include "usGetModuleContext.h"
 #include "usModuleContext.h"
 
 // mitk core module
-#include <mitkCompositePixelValueToString.h>
 #include <mitkDisplayActionEvents.h>
 #include <mitkImage.h>
-#include <mitkImagePixelReadAccessor.h>
 #include <mitkInteractionConst.h>
 #include <mitkInteractionPositionEvent.h>
 #include <mitkLine.h>
-#include <mitkNodePredicateDataType.h>
-#include <mitkPixelTypeMultiplex.h>
 #include <mitkRotationOperation.h>
-#include <mitkStatusBar.h>
 
 #include <rotate_cursor.xpm>
 
 mitk::DisplayActionEventBroadcast::DisplayActionEventBroadcast()
   : m_AlwaysReact(false)
   , m_AutoRepeat(false)
   , m_IndexToSliceModifier(4)
   , m_InvertScrollDirection(false)
   , m_InvertZoomDirection(false)
   , m_ZoomFactor(2)
   , m_InvertMoveDirection(false)
   , m_InvertLevelWindowDirection(false)
   , m_LinkPlanes(true)
 {
   m_StartCoordinateInMM.Fill(0);
   m_LastDisplayCoordinate.Fill(0);
-  m_LastCoordinateInMM.Fill(0);
   m_CurrentDisplayCoordinate.Fill(0);
 
   // register the broadcast class (itself) as an interaction event observer via micro services
   us::ServiceProperties props;
   props["name"] = std::string("DisplayActionEventBroadcast");
   m_ServiceRegistration = us::GetModuleContext()->RegisterService<InteractionEventObserver>(this, props);
 }
 
 mitk::DisplayActionEventBroadcast::~DisplayActionEventBroadcast()
 {
   m_ServiceRegistration.Unregister();
 }
 
 void mitk::DisplayActionEventBroadcast::Notify(InteractionEvent* interactionEvent, bool isHandled)
 {
   // the event is passed to the state machine interface to be handled
   if (!isHandled || m_AlwaysReact)
   {
     HandleEvent(interactionEvent, nullptr);
   }
 }
 
 void mitk::DisplayActionEventBroadcast::ConnectActionsAndFunctions()
 {
   CONNECT_CONDITION("check_position_event", CheckPositionEvent);
   CONNECT_CONDITION("check_can_rotate", CheckRotationPossible);
   CONNECT_CONDITION("check_can_swivel", CheckSwivelPossible);
 
   CONNECT_FUNCTION("init", Init);
   CONNECT_FUNCTION("move", Move);
   CONNECT_FUNCTION("zoom", Zoom);
   CONNECT_FUNCTION("scroll", Scroll);
   CONNECT_FUNCTION("ScrollOneUp", ScrollOneUp);
   CONNECT_FUNCTION("ScrollOneDown", ScrollOneDown);
   CONNECT_FUNCTION("levelWindow", AdjustLevelWindow);
   CONNECT_FUNCTION("setCrosshair", SetCrosshair);
 
-  CONNECT_FUNCTION("updateStatusbar", UpdateStatusbar)
-
   CONNECT_FUNCTION("startRotation", StartRotation);
   CONNECT_FUNCTION("endRotation", EndRotation);
   CONNECT_FUNCTION("rotate", Rotate);
 
   CONNECT_FUNCTION("swivel", Swivel);
 
   CONNECT_FUNCTION("IncreaseTimeStep", IncreaseTimeStep);
   CONNECT_FUNCTION("DecreaseTimeStep", DecreaseTimeStep);
 }
 
 void mitk::DisplayActionEventBroadcast::ConfigurationChanged()
 {
   PropertyList::Pointer properties = GetAttributes();
 
   // alwaysReact
   std::string strAlwaysReact = "";
   m_AlwaysReact = false;
   if (properties->GetStringProperty("alwaysReact", strAlwaysReact))
   {
     if (strAlwaysReact == "true")
     {
       m_AlwaysReact = true;
     }
   }
 
   // auto repeat
   std::string strAutoRepeat = "";
   m_AutoRepeat = false;
   if (properties->GetStringProperty("autoRepeat", strAutoRepeat))
   {
     if (strAutoRepeat == "true")
     {
       m_AutoRepeat = true;
     }
   }
 
   // pixel movement for scrolling one slice
   std::string strPixelPerSlice = "";
   m_IndexToSliceModifier = 4;
   if (properties->GetStringProperty("pixelPerSlice", strPixelPerSlice))
   {
     m_IndexToSliceModifier = atoi(strPixelPerSlice.c_str());
   }
 
   // scroll direction
   if (!properties->GetStringProperty("scrollDirection", m_ScrollDirection))
   {
     m_ScrollDirection = "updown";
   }
 
   m_InvertScrollDirection = GetBoolProperty(properties, "invertScrollDirection", false);
 
   // zoom direction
   if (!properties->GetStringProperty("zoomDirection", m_ZoomDirection))
   {
     m_ZoomDirection = "updown";
   }
 
   m_InvertZoomDirection = GetBoolProperty(properties, "invertZoomDirection", false);
   m_InvertMoveDirection = GetBoolProperty(properties, "invertMoveDirection", false);
 
   if (!properties->GetStringProperty("levelWindowDirection", m_LevelDirection))
   {
     m_LevelDirection = "leftright";
   }
 
   m_InvertLevelWindowDirection = GetBoolProperty(properties, "invertLevelWindowDirection", false);
 
   // coupled rotation
   std::string strCoupled = "";
   m_LinkPlanes = false;
   if (properties->GetStringProperty("coupled", strCoupled))
   {
     if (strCoupled == "true")
     {
       m_LinkPlanes = true;
     }
   }
 
   // zoom factor
   std::string strZoomFactor = "";
   properties->GetStringProperty("zoomFactor", strZoomFactor);
   m_ZoomFactor = .05;
   if (atoi(strZoomFactor.c_str()) > 0)
   {
     m_ZoomFactor = 1.0 + (atoi(strZoomFactor.c_str()) / 100.0);
   }
 }
 
 bool mitk::DisplayActionEventBroadcast::FilterEvents(InteractionEvent* interactionEvent, DataNode * /*dataNode*/)
 {
   BaseRenderer* sendingRenderer = interactionEvent->GetSender();
   if (nullptr == sendingRenderer)
   {
     return false;
   }
 
   if (BaseRenderer::Standard3D == sendingRenderer->GetMapperID())
   {
     return false;
   }
 
   return true;
 }
 
 bool mitk::DisplayActionEventBroadcast::CheckPositionEvent(const InteractionEvent *interactionEvent)
 {
   const auto* positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return false;
   }
 
   return true;
 }
 
 bool mitk::DisplayActionEventBroadcast::CheckRotationPossible(const InteractionEvent *interactionEvent)
 {
   // Decide between moving and rotation slices.
   /*
   Detailed logic:
 
   1. Find the SliceNavigationController that has sent the event: this one defines our rendering plane and will NOT be
   rotated. Needs not even be counted or checked.
   2. Inspect every other SliceNavigationController
   - calculate the line intersection of this SliceNavigationController's plane with our rendering plane
   - if there is NO intersection, ignore and continue
   - IF there is an intersection
   - check the mouse cursor's distance from that line.
   0. if the line is NOT near the cursor, remember the plane as "one of the other planes" (which can be rotated in
   "locked" mode)
   1. on first line near the cursor,  just remember this intersection line as THE other plane that we want to rotate
   2. on every consecutive line near the cursor, check if the line is geometrically identical to the line that we want to
   rotate
   - if yes, we just push this line to the "other" lines and rotate it along
   - if no, then we have a situation where the mouse is near two other lines (e.g. crossing point) and don't want to
   rotate
   */
   const auto* positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return false;
   }
 
   BaseRenderer* renderer = positionEvent->GetSender();
   if (nullptr == renderer)
   {
     return false;
   }
 
   const PlaneGeometry* rendererWorldPlaneGeometry = renderer->GetCurrentWorldPlaneGeometry();
   if (nullptr == rendererWorldPlaneGeometry)
   {
     return false;
   }
 
   Point3D position = positionEvent->GetPositionInWorld();
   const auto spacing = rendererWorldPlaneGeometry->GetSpacing();
   const PlaneGeometry *geometryToBeRotated = nullptr; // this one is under the mouse cursor
   const PlaneGeometry *anyOtherGeometry = nullptr;    // this is also visible (for calculation of intersection ONLY)
   Line3D intersectionLineWithGeometryToBeRotated;
 
   bool hitMultipleLines(false);
   m_SNCsToBeRotated.clear();
 
   const ScalarType threshholdDistancePixels = 12.0;
 
   auto allRenderWindows = RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
   for (auto renderWindow : allRenderWindows)
   {
     SliceNavigationController* snc = BaseRenderer::GetInstance(renderWindow)->GetSliceNavigationController();
 
     // If the mouse cursor is in 3D Renderwindow, do not check for intersecting planes.
     if (BaseRenderer::Standard3D == BaseRenderer::GetInstance(renderWindow)->GetMapperID())
     {
       continue;
     }
 
     const PlaneGeometry* rendererPlaneGeometry = snc->GetCurrentPlaneGeometry();
     if (nullptr == rendererPlaneGeometry)
     {
       continue; // ignore, we don't see a plane
     }
 
     // check if there is an intersection between rendered / clicked geometry and the one being analyzed
     Line3D intersectionLine;
     if (!rendererWorldPlaneGeometry->IntersectionLine(rendererPlaneGeometry, intersectionLine))
     {
       continue; // we ignore this plane, it's parallel to our plane
     }
 
     // check distance from intersection line
     const double distanceFromIntersectionLine = intersectionLine.Distance(position) / spacing[snc->GetDefaultViewDirection()];
 
     // far away line, only remember for linked rotation if necessary
     if (distanceFromIntersectionLine > threshholdDistancePixels)
     {
       // we just take the last one, so overwrite each iteration (we just need some crossing point)
       // TODO what about multiple crossings? NOW we have undefined behavior / random crossing point is used
       anyOtherGeometry = rendererPlaneGeometry;
       if (m_LinkPlanes)
       {
         // if planes are linked, apply rotation to all planes
         m_SNCsToBeRotated.push_back(snc);
       }
     }
     else // close to cursor
     {
       if (nullptr == geometryToBeRotated) // first one close to the cursor
       {
         geometryToBeRotated = rendererPlaneGeometry;
         intersectionLineWithGeometryToBeRotated = intersectionLine;
         m_SNCsToBeRotated.push_back(snc);
       }
       else
       {
         // compare to the line defined by geometryToBeRotated: if identical, just rotate this otherRenderersRenderPlane
         // together with the primary one
         //                                                     if different, DON'T rotate
         if (intersectionLine.IsParallel(intersectionLineWithGeometryToBeRotated)
          && intersectionLine.Distance(intersectionLineWithGeometryToBeRotated.GetPoint1()) < eps)
         {
           m_SNCsToBeRotated.push_back(snc);
         }
         else
         {
           hitMultipleLines = true;
         }
       }
     }
   }
 
   bool moveSlices(true);
 
   if (geometryToBeRotated && anyOtherGeometry && rendererWorldPlaneGeometry && !hitMultipleLines)
   {
     // assure all three are valid, so calculation of center of rotation can be done
     moveSlices = false;
   }
   // question in state machine is: "rotate?"
   if (moveSlices) // i.e. NOT rotate
   {
     return false;
   }
   else
   {
     // we have enough information for rotation
     // remember where the last cursor position ON THE LINE has been observed
     m_LastCursorPosition = intersectionLineWithGeometryToBeRotated.Project(position);
 
     // find center of rotation by intersection with any of the OTHER lines
     if (anyOtherGeometry->IntersectionPoint(intersectionLineWithGeometryToBeRotated, m_CenterOfRotation))
     {
       return true;
     }
     else
     {
       return false;
     }
   }
   return false;
 }
 
 bool mitk::DisplayActionEventBroadcast::CheckSwivelPossible(const InteractionEvent *interactionEvent)
 {
   // Decide between moving and rotation: if we're close to the crossing
   // point of the planes, moving mode is entered, otherwise
   // rotation/swivel mode
   const auto* positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return false;
   }
 
   BaseRenderer* renderer = positionEvent->GetSender();
   if (nullptr == renderer)
   {
     return false;
   }
 
   const Point3D& position = positionEvent->GetPositionInWorld();
 
   m_SNCsToBeRotated.clear();
 
   const PlaneGeometry* clickedGeometry(nullptr);
   const PlaneGeometry* otherGeometry1(nullptr);
   const PlaneGeometry* otherGeometry2(nullptr);
 
   const ScalarType threshholdDistancePixels = 6.0;
 
   auto allRenderWindows = RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
   for (auto renderWindow : allRenderWindows)
   {
     SliceNavigationController* snc = BaseRenderer::GetInstance(renderWindow)->GetSliceNavigationController();
 
     // If the mouse cursor is in 3D Renderwindow, do not check for intersecting planes.
     if (BaseRenderer::Standard3D == BaseRenderer::GetInstance(renderWindow)->GetMapperID())
     {
       continue;
     }
 
     const PlaneGeometry* rendererPlaneGeometry = snc->GetCurrentPlaneGeometry();
     if (nullptr == rendererPlaneGeometry)
     {
       continue; // ignore, we don't see a plane
     }
 
     if (snc == renderer->GetSliceNavigationController())
     {
       clickedGeometry = rendererPlaneGeometry;
       m_SNCsToBeRotated.push_back(snc);
     }
     else
     {
       if (nullptr == otherGeometry1)
       {
         otherGeometry1 = rendererPlaneGeometry;
       }
       else
       {
         otherGeometry2 = rendererPlaneGeometry;
       }
       if (m_LinkPlanes)
       {
         // if planes are linked, apply rotation to all planes
         m_SNCsToBeRotated.push_back(snc);
       }
     }
   }
 
   Line3D line;
   Point3D point;
   if ((nullptr != clickedGeometry) && (nullptr != otherGeometry1) && (nullptr != otherGeometry2)
    && clickedGeometry->IntersectionLine(otherGeometry1, line) && otherGeometry2->IntersectionPoint(line, point))
   {
     m_CenterOfRotation = point;
     if (m_CenterOfRotation.EuclideanDistanceTo(position) < threshholdDistancePixels)
     {
       return false;
     }
     else
     {
       m_ReferenceCursor = positionEvent->GetPointerPositionOnScreen();
 
       // Get main axes of rotation plane and store it for rotation step
       m_RotationPlaneNormal = clickedGeometry->GetNormal();
 
       ScalarType xVector[] = { 1.0, 0.0, 0.0 };
       ScalarType yVector[] = { 0.0, 1.0, 0.0 };
       clickedGeometry->BaseGeometry::IndexToWorld(Vector3D(xVector), m_RotationPlaneXVector);
       clickedGeometry->BaseGeometry::IndexToWorld(Vector3D(yVector), m_RotationPlaneYVector);
 
       m_RotationPlaneNormal.Normalize();
       m_RotationPlaneXVector.Normalize();
       m_RotationPlaneYVector.Normalize();
 
       m_PreviousRotationAxis.Fill(0.0);
       m_PreviousRotationAxis[2] = 1.0;
       m_PreviousRotationAngle = 0.0;
 
       return true;
     }
   }
   else
   {
     return false;
   }
   return false;
 }
 
 void mitk::DisplayActionEventBroadcast::Init(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
 {
   const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return;
   }
 
   m_LastDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
   m_CurrentDisplayCoordinate = m_LastDisplayCoordinate;
   positionEvent->GetSender()->DisplayToPlane(m_LastDisplayCoordinate, m_StartCoordinateInMM);
-  m_LastCoordinateInMM = m_StartCoordinateInMM;
 }
 
 void mitk::DisplayActionEventBroadcast::Move(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
 {
   const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return;
   }
 
   BaseRenderer* sender = interactionEvent->GetSender();
   Vector2D moveVector = m_LastDisplayCoordinate - positionEvent->GetPointerPositionOnScreen();
 
   if (m_InvertMoveDirection)
   {
     moveVector *= -1.0;
   }
 
   moveVector *= sender->GetScaleFactorMMPerDisplayUnit(); // #TODO: put here?
 
   // store new display coordinate
   m_LastDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
 
   // propagate move event with computed geometry values
   InvokeEvent(DisplayMoveEvent(interactionEvent, moveVector));
 }
 
 void mitk::DisplayActionEventBroadcast::SetCrosshair(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
 {
   const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return;
   }
 
   Point3D position = positionEvent->GetPositionInWorld();
 
   // propagate set crosshair event with computed geometry values
   InvokeEvent(DisplaySetCrosshairEvent(interactionEvent, position));
 }
 
 void mitk::DisplayActionEventBroadcast::Zoom(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
 {
   const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return;
   }
 
   float factor = 1.0;
   float distance = 0;
 
   if (m_ZoomDirection == "updown")
   {
     distance = m_CurrentDisplayCoordinate[1] - m_LastDisplayCoordinate[1];
   }
   else
   {
     distance = m_CurrentDisplayCoordinate[0] - m_LastDisplayCoordinate[0];
   }
 
   if (m_InvertZoomDirection)
   {
     distance *= -1.0;
   }
 
   // set zooming speed
   if (distance < 0.0)
   {
     factor = 1.0 / m_ZoomFactor;
   }
   else if (distance > 0.0)
   {
     factor = 1.0 * m_ZoomFactor;
   }
 
   // store new display coordinates
   m_LastDisplayCoordinate = m_CurrentDisplayCoordinate;
   m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
 
   // propagate zoom event with computed geometry values
   InvokeEvent(DisplayZoomEvent(interactionEvent, factor, m_StartCoordinateInMM));
 }
 
 void mitk::DisplayActionEventBroadcast::Scroll(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
 {
   const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return;
   }
 
   int sliceDelta = 0;
 
   // scroll direction
   if (m_ScrollDirection == "updown")
   {
     sliceDelta = static_cast<int>(m_CurrentDisplayCoordinate[1] - m_LastDisplayCoordinate[1]);
   }
   else
   {
     sliceDelta = static_cast<int>(m_CurrentDisplayCoordinate[0] - m_LastDisplayCoordinate[0]);
   }
 
   if (m_InvertScrollDirection)
   {
     sliceDelta *= -1;
   }
 
   // set how many pixels the mouse has to be moved to scroll one slice
   // if the mouse has been moved less than 'm_IndexToSliceModifier', pixels slice ONE slice only
   if (sliceDelta > 0 && sliceDelta < m_IndexToSliceModifier)
   {
     sliceDelta = m_IndexToSliceModifier;
   }
   else if (sliceDelta < 0 && sliceDelta > -m_IndexToSliceModifier)
   {
     sliceDelta = -m_IndexToSliceModifier;
   }
   sliceDelta /= m_IndexToSliceModifier;
 
   // store new display coordinates
   m_LastDisplayCoordinate = m_CurrentDisplayCoordinate;
   m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
 
   // propagate scroll event with computed geometry values
   InvokeEvent(DisplayScrollEvent(interactionEvent, sliceDelta, m_AutoRepeat));
 }
 
 void mitk::DisplayActionEventBroadcast::ScrollOneUp(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
 {
   int sliceDelta = 1;
   if (m_InvertScrollDirection)
   {
     sliceDelta = -1;
   }
 
   // propagate scroll event with a single slice delta (increase)
   InvokeEvent(DisplayScrollEvent(interactionEvent, sliceDelta, m_AutoRepeat));
 }
 
 void mitk::DisplayActionEventBroadcast::ScrollOneDown(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
 {
   int sliceDelta = -1;
   if (m_InvertScrollDirection)
   {
     sliceDelta = 1;
   }
 
   // propagate scroll event with a single slice delta (decrease)
   InvokeEvent(DisplayScrollEvent(interactionEvent, sliceDelta, m_AutoRepeat));
 }
 
 void mitk::DisplayActionEventBroadcast::AdjustLevelWindow(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
 {
   const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return;
   }
 
   ScalarType level;
   ScalarType window;
 
   if (m_LevelDirection == "leftright")
   {
     level = m_CurrentDisplayCoordinate[0] - m_LastDisplayCoordinate[0];
     window = m_CurrentDisplayCoordinate[1] - m_LastDisplayCoordinate[1];
   }
   else
   {
     level = m_CurrentDisplayCoordinate[1] - m_LastDisplayCoordinate[1];
     window = m_CurrentDisplayCoordinate[0] - m_LastDisplayCoordinate[0];
   }
 
   if (m_InvertLevelWindowDirection)
   {
     level *= -1;
     window *= -1;
   }
 
   level *= static_cast<ScalarType>(2);
   window *= static_cast<ScalarType>(2);
 
   // store new display coordinates
   m_LastDisplayCoordinate = m_CurrentDisplayCoordinate;
   m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
 
   // propagate set level window event with the level and window delta
   InvokeEvent(DisplaySetLevelWindowEvent(interactionEvent, level, window));
 }
 
 void mitk::DisplayActionEventBroadcast::StartRotation(StateMachineAction* /*stateMachineAction*/, InteractionEvent* /*interactionEvent*/)
 {
   SetMouseCursor(rotate_cursor_xpm, 0, 0);
 }
 
 void mitk::DisplayActionEventBroadcast::EndRotation(StateMachineAction* /*stateMachineAction*/, InteractionEvent* /*interactionEvent*/)
 {
   ResetMouseCursor();
 }
 
 void mitk::DisplayActionEventBroadcast::Rotate(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
 {
   const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return;
   }
 
   Point3D position = positionEvent->GetPositionInWorld();
 
   Vector3D toProjected = m_LastCursorPosition - m_CenterOfRotation;
   Vector3D toCursor = position - m_CenterOfRotation;
 
   // cross product: | A x B | = |A| * |B| * sin(angle)
   Vector3D axisOfRotation;
   vnl_vector_fixed<ScalarType, 3> vnlDirection = vnl_cross_3d(toCursor.GetVnlVector(), toProjected.GetVnlVector());
   axisOfRotation.SetVnlVector(vnlDirection.as_ref());
 
   // scalar product: A * B = |A| * |B| * cos(angle)
   // tan = sin / cos
   ScalarType angle = -atan2((double)(axisOfRotation.GetNorm()), (double)(toCursor * toProjected));
   angle *= 180.0 / vnl_math::pi;
   m_LastCursorPosition = position;
 
   // create RotationOperation and apply to all SNCs that should be rotated
   RotationOperation rotationOperation(OpROTATE, m_CenterOfRotation, axisOfRotation, angle);
 
   // iterate the OTHER slice navigation controllers
   for (auto iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
   {
     TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
     if (nullptr == timeGeometry)
     {
       continue;
     }
 
     timeGeometry->ExecuteOperation(&rotationOperation);
 
     (*iter)->SendCreatedWorldGeometryUpdate();
   }
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::DisplayActionEventBroadcast::Swivel(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
 {
   const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
   if (nullptr == positionEvent)
   {
     return;
   }
 
   // Determine relative mouse movement projected onto world space
   Point2D position = positionEvent->GetPointerPositionOnScreen();
 
   Vector2D relativeCursor = position - m_ReferenceCursor;
   Vector3D relativeCursorAxis = m_RotationPlaneXVector * relativeCursor[0] + m_RotationPlaneYVector * relativeCursor[1];
 
   // Determine rotation axis (perpendicular to rotation plane and cursor movement)
   Vector3D rotationAxis = itk::CrossProduct(m_RotationPlaneNormal, relativeCursorAxis);
 
   ScalarType rotationAngle = relativeCursor.GetNorm() / 2.0;
 
   // Restore the initial plane pose by undoing the previous rotation operation
   RotationOperation op(OpROTATE, m_CenterOfRotation, m_PreviousRotationAxis, -m_PreviousRotationAngle);
 
   SNCVector::iterator iter;
   for (iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
   {
     if (!(*iter)->GetSliceRotationLocked())
     {
       TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
       if (nullptr == timeGeometry)
       {
         continue;
       }
 
       timeGeometry->ExecuteOperation(&op);
       (*iter)->SendCreatedWorldGeometryUpdate();
     }
   }
 
   // Apply new rotation operation to all relevant SNCs
   RotationOperation op2(OpROTATE, m_CenterOfRotation, rotationAxis, rotationAngle);
 
   for (iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
   {
     if (!(*iter)->GetSliceRotationLocked())
     {
       // Retrieve the TimeGeometry of this SliceNavigationController
       TimeGeometry *timeGeometry = (*iter)->GetCreatedWorldGeometry();
       if (nullptr == timeGeometry)
       {
         continue;
       }
 
       // Execute the new rotation
       timeGeometry->ExecuteOperation(&op2);
 
       // Notify listeners
       (*iter)->SendCreatedWorldGeometryUpdate();
     }
   }
 
   m_PreviousRotationAxis = rotationAxis;
   m_PreviousRotationAngle = rotationAngle;
 
   RenderingManager::GetInstance()->RequestUpdateAll();
   return;
 }
 
 void mitk::DisplayActionEventBroadcast::IncreaseTimeStep(StateMachineAction*, InteractionEvent*)
 {
   auto sliceNaviController = RenderingManager::GetInstance()->GetTimeNavigationController();
   auto stepper = sliceNaviController->GetTime();
   stepper->SetAutoRepeat(true);
   stepper->Next();
 }
 
 void mitk::DisplayActionEventBroadcast::DecreaseTimeStep(StateMachineAction*, InteractionEvent*)
 {
   auto sliceNaviController = RenderingManager::GetInstance()->GetTimeNavigationController();
   auto stepper = sliceNaviController->GetTime();
   stepper->SetAutoRepeat(true);
   stepper->Previous();
 }
 
-void mitk::DisplayActionEventBroadcast::UpdateStatusbar(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
-{
-  const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
-  if (nullptr == positionEvent)
-  {
-    return;
-  }
-
-  BaseRenderer::Pointer renderer = positionEvent->GetSender();
-
-  TNodePredicateDataType<Image>::Pointer isImageData = TNodePredicateDataType<Image>::New();
-  DataStorage::SetOfObjects::ConstPointer nodes = renderer->GetDataStorage()->GetSubset(isImageData).GetPointer();
-  if (nodes.IsNull())
-  {
-    return;
-  }
-
-  // A rendering update is required before getting the pointer position.
-  // This is required when scrolling through slices of an image using the mouse wheel.
-  renderer->ForceImmediateUpdate();
-  Point3D worldposition;
-  renderer->DisplayToWorld(positionEvent->GetPointerPositionOnScreen(), worldposition);
-  auto globalCurrentTimePoint = renderer->GetTime();
-
-  Image::Pointer image3D;
-  DataNode::Pointer node;
-  DataNode::Pointer topSourceNode;
-
-  int component = 0;
-
-  node = FindTopmostVisibleNode(nodes, worldposition, globalCurrentTimePoint, renderer);
-  if (node.IsNull())
-  {
-    return;
-  }
-
-  bool isBinary(false);
-  node->GetBoolProperty("binary", isBinary);
-  if (isBinary)
-  {
-    DataStorage::SetOfObjects::ConstPointer sourcenodes = renderer->GetDataStorage()->GetSources(node, nullptr, true);
-    if (!sourcenodes->empty())
-    {
-      topSourceNode = FindTopmostVisibleNode(nodes, worldposition, globalCurrentTimePoint, renderer);
-    }
-    if (topSourceNode.IsNotNull())
-    {
-      image3D = dynamic_cast<Image*>(topSourceNode->GetData());
-      topSourceNode->GetIntProperty("Image.Displayed Component", component);
-    }
-    else
-    {
-      image3D = dynamic_cast<Image*>(node->GetData());
-      node->GetIntProperty("Image.Displayed Component", component);
-    }
-  }
-  else
-  {
-    image3D = dynamic_cast<Image *>(node->GetData());
-    node->GetIntProperty("Image.Displayed Component", component);
-  }
-
-  // get the position and pixel value from the image and build up status bar text
-  auto statusBar = StatusBar::GetInstance();
-  if (image3D.IsNotNull() && statusBar != nullptr)
-  {
-    itk::Index<3> p;
-    image3D->GetGeometry()->WorldToIndex(worldposition, p);
-
-    auto pixelType = image3D->GetChannelDescriptor().GetPixelType().GetPixelType();
-    if (pixelType == itk::IOPixelEnum::RGB || pixelType == itk::IOPixelEnum::RGBA)
-    {
-      std::string pixelValue = "Pixel RGB(A) value: ";
-      pixelValue.append(ConvertCompositePixelValueToString(image3D, p));
-      statusBar->DisplayImageInfo(worldposition, p, renderer->GetTime(), pixelValue.c_str());
-    }
-    else if (pixelType == itk::IOPixelEnum::DIFFUSIONTENSOR3D || pixelType == itk::IOPixelEnum::SYMMETRICSECONDRANKTENSOR)
-    {
-      std::string pixelValue = "See ODF Details view. ";
-      statusBar->DisplayImageInfo(worldposition, p, renderer->GetTime(), pixelValue.c_str());
-    }
-    else
-    {
-      ScalarType pixelValue;
-      mitkPixelTypeMultiplex5(
-        FastSinglePixelAccess,
-        image3D->GetChannelDescriptor().GetPixelType(),
-        image3D,
-        image3D->GetVolumeData(renderer->GetTimeStep()),
-        p,
-        pixelValue,
-        component);
-      statusBar->DisplayImageInfo(worldposition, p, renderer->GetTime(), pixelValue);
-    }
-  }
-  else
-  {
-    statusBar->DisplayImageInfoInvalid();
-  }
-}
-
 bool mitk::DisplayActionEventBroadcast::GetBoolProperty(PropertyList::Pointer propertyList, const char* propertyName, bool defaultValue)
 {
   std::string valueAsString;
   if (!propertyList->GetStringProperty(propertyName, valueAsString))
   {
     return defaultValue;
   }
   else
   {
     if (valueAsString == "true")
     {
       return true;
     }
     else
     {
       return false;
     }
   }
 }
diff --git a/Modules/QtWidgets/include/QmitkRenderWindow.h b/Modules/QtWidgets/include/QmitkRenderWindow.h
index 51f83d8b84..b92b71d859 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindow.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindow.h
@@ -1,154 +1,156 @@
 /*============================================================================
 
 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 QMITKRENDERWINDOW_H
 #define QMITKRENDERWINDOW_H
 
 #include "mitkRenderWindowBase.h"
 
 #include "QmitkRenderWindowMenu.h"
 #include <MitkQtWidgetsExports.h>
 
 #include <vtkGenericOpenGLRenderWindow.h>
 #include <QVTKOpenGLNativeWidget.h>
 
 #include "mitkBaseRenderer.h"
 #include "mitkInteractionEventConst.h"
 
 class QDragEnterEvent;
 class QDropEvent;
 class QInputEvent;
 class QMouseEvent;
 
 /**
  * \ingroup QmitkModule
  * \brief MITK implementation of the QVTKWidget
  */
 class MITKQTWIDGETS_EXPORT QmitkRenderWindow : public QVTKOpenGLNativeWidget, public mitk::RenderWindowBase
 {
   Q_OBJECT
 
 public:
   QmitkRenderWindow(
     QWidget *parent = nullptr,
     const QString &name = "unnamed renderwindow",
     mitk::VtkPropRenderer *renderer = nullptr);
   ~QmitkRenderWindow() override;
 
   /**
    * \brief Whether Qt events should be passed to parent (default: true)
    *
    * With introduction of the QVTKWidget the behaviour regarding Qt events changed.
    * QVTKWidget "accepts" Qt events like mouse clicks (i.e. set an "accepted" flag).
    * When this flag is set, Qt fininshed handling of this event -- otherwise it is
    * reached through to the widget's parent.
    *
    * This reaching through to the parent was implicitly required by QmitkMaterialWidget / QmitkMaterialShowCase.
    *
    * The default behaviour of QmitkRenderWindow is now to clear the "accepted" flag
    * of Qt events after they were handled by QVTKWidget. This way parents can also
    * handle events.
    *
    * If you don't want this behaviour, call SetResendQtEvents(true) on your render window.
    */
   virtual void SetResendQtEvents(bool resend);
 
   // Set Layout Index to define the Layout Type
   void SetLayoutIndex(QmitkRenderWindowMenu::LayoutIndex layoutIndex);
 
   // Get Layout Index to define the Layout Type
   QmitkRenderWindowMenu::LayoutIndex GetLayoutIndex();
 
   // MenuWidget need to update the Layout Design List when Layout had changed
   void UpdateLayoutDesignList(QmitkRenderWindowMenu::LayoutDesign layoutDesign);
 
   void UpdateCrosshairVisibility(bool);
 
   void UpdateCrosshairRotationMode(int);
 
   // Activate or Deactivate MenuWidget.
   void ActivateMenuWidget(bool state);
 
   bool GetActivateMenuWidgetFlag() { return m_MenuWidgetActivated; }
   // Get it from the QVTKWidget parent
   vtkRenderWindow *GetVtkRenderWindow() override { return this->renderWindow(); }
 
   vtkRenderWindowInteractor *GetVtkRenderWindowInteractor() override { return nullptr; }
 
 protected:
 
   // catch-all event handler
   bool event(QEvent *e) override;
   // overloaded move handler
   void moveEvent(QMoveEvent *event) override;
   // overloaded show handler
   void showEvent(QShowEvent *event) override;
   // overloaded enter handler
   void enterEvent(QEvent *) override;
   // overloaded leave handler
   void leaveEvent(QEvent *) override;
 
   // Overloaded resize handler, see decs in QVTKOpenGLWidget.
   // Basically, we have to ensure the VTK rendering is updated for each change in window size.
   void resizeGL(int w, int h) override;
 
   /// \brief Simply says we accept the event type.
   void dragEnterEvent(QDragEnterEvent *event) override;
 
   /// \brief If the dropped type is application/x-mitk-datanodes we process the request by converting to mitk::DataNode
   /// pointers and emitting the NodesDropped signal.
   void dropEvent(QDropEvent *event) override;
 
 Q_SIGNALS:
 
   void LayoutDesignChanged(QmitkRenderWindowMenu::LayoutDesign);
 
   void ResetView();
 
   void CrosshairRotationModeChanged(int);
 
   void CrosshairVisibilityChanged(bool);
 
   void moved();
 
   /// \brief Emits a signal to say that this window has had the following nodes dropped on it.
   void NodesDropped(QmitkRenderWindow *thisWindow, std::vector<mitk::DataNode *> nodes);
 
 private Q_SLOTS:
 
   void DeferredHideMenu();
 
 private:
   // Helper Functions to Convert Qt-Events to Mitk-Events
 
   mitk::Point2D GetMousePosition(QMouseEvent *me) const;
   mitk::Point2D GetMousePosition(QWheelEvent *we) const;
   mitk::InteractionEvent::MouseButtons GetEventButton(QMouseEvent *me) const;
   mitk::InteractionEvent::MouseButtons GetButtonState(QMouseEvent *me) const;
   mitk::InteractionEvent::ModifierKeys GetModifiers(QInputEvent *me) const;
   mitk::InteractionEvent::MouseButtons GetButtonState(QWheelEvent *we) const;
   std::string GetKeyLetter(QKeyEvent *ke) const;
   int GetDelta(QWheelEvent *we) const;
 
+  void UpdateStatusBar(mitk::Point2D pointerPositionOnScreen);
+
   bool m_ResendQtEvents;
 
   QmitkRenderWindowMenu *m_MenuWidget;
 
   bool m_MenuWidgetActivated;
 
   QmitkRenderWindowMenu::LayoutIndex m_LayoutIndex;
 
   vtkSmartPointer<vtkGenericOpenGLRenderWindow> m_InternalRenderWindow;
 
 };
 
 #endif // QMITKRENDERWINDOW_H
diff --git a/Modules/QtWidgets/include/QmitkStdMultiWidget.h b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
index 1ecd723bb7..0f45a0bcae 100644
--- a/Modules/QtWidgets/include/QmitkStdMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
@@ -1,162 +1,151 @@
 /*============================================================================
 
 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 QMITKSTDMULTIWIDGET_H
 #define QMITKSTDMULTIWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkAbstractMultiWidget.h"
 
 /**
 * @brief The 'QmitkStdMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
 *        Render windows are predefined in a 2x2 design with 3 different 2D view planes and a 3D render window.
 */
 class MITKQTWIDGETS_EXPORT QmitkStdMultiWidget : public QmitkAbstractMultiWidget
 {
   Q_OBJECT
 
 public:
   QmitkStdMultiWidget(
     QWidget *parent = nullptr,
     Qt::WindowFlags f = nullptr,
     const QString &name = "stdmulti");
 
   ~QmitkStdMultiWidget() override;
 
   virtual void InitializeMultiWidget() override;
 
   virtual QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
   virtual QmitkRenderWindow* GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const override;
 
   virtual void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
   virtual const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
 
   virtual void SetCrosshairVisibility(bool) override;
   virtual bool GetCrosshairVisibility() const override;
   void SetCrosshairGap(unsigned int gapSize) override;
 
   virtual void ResetCrosshair() override;
 
   virtual void SetWidgetPlaneMode(int mode) override;
 
   mitk::SliceNavigationController* GetTimeNavigationController();
 
   void AddPlanesToDataStorage();
   void RemovePlanesFromDataStorage();
 
-  /** \brief Listener to the CrosshairPositionEvent
-
-    Ensures the CrosshairPositionEvent is handled only once and at the end of the Qt-Event loop
-  */
-  void HandleCrosshairPositionEvent();
-
   /**
    * @brief Convenience method to get a render window widget.
    * @param   number of the widget (0-3)
    * @return  The render window widget
    */
   QmitkRenderWindow* GetRenderWindow(unsigned int number) const;
   QmitkRenderWindow* GetRenderWindow1() const;
   QmitkRenderWindow* GetRenderWindow2() const;
   QmitkRenderWindow* GetRenderWindow3() const;
   QmitkRenderWindow* GetRenderWindow4() const;
 
   /**
   * @brief Convenience method to get a widget plane.
   * @param   number of the widget plane (1-3)
   * @return  The widget plane as data node
   */
   mitk::DataNode::Pointer GetWidgetPlane(unsigned int number) const;
   mitk::DataNode::Pointer GetWidgetPlane1() const;
   mitk::DataNode::Pointer GetWidgetPlane2() const;
   mitk::DataNode::Pointer GetWidgetPlane3() const;
 
   /**
   * @brief SetDecorationColor Set the color of the decoration of the 4 widgets.
   *
   * This is used to color the frame of the renderwindow and the corner annatation.
   * For the first 3 widgets, this color is a property of the helper object nodes
   * which contain the respective plane geometry. For widget 4, this is a member,
   * since there is no data node for this widget.
   */
   void SetDecorationColor(unsigned int widgetNumber, mitk::Color color);
   /**
    * @brief GetDecorationColorForWidget Get the color for annotation, crosshair and rectangle.
    * @param widgetNumber Number of the renderwindow (0-3).
    * @return Color in mitk format.
    */
   mitk::Color GetDecorationColor(unsigned int widgetNumber);
 
 public Q_SLOTS:
 
   // mouse events
   virtual void mousePressEvent(QMouseEvent*) override;
   virtual void moveEvent(QMoveEvent* e) override;
   virtual void wheelEvent(QWheelEvent* e) override;
 
-  /// Receives the signal from HandleCrosshairPositionEvent, executes the StatusBar update
-  void HandleCrosshairPositionEventDelayed();
-
   void Fit();
 
   void AddDisplayPlaneSubTree();
 
   void EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p);
 
   void SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer = nullptr);
 
   void SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer = nullptr);
 
 Q_SIGNALS:
 
   void NotifyCrosshairVisibilityChanged(bool visible);
   void NotifyCrosshairRotationModeChanged(int mode);
 
   void WheelMoved(QWheelEvent *);
   void Moved();
 
 private:
 
   virtual void SetLayoutImpl() override;
   virtual void SetInteractionSchemeImpl() override { }
 
   void CreateRenderWindowWidgets();
 
   mitk::SliceNavigationController* m_TimeNavigationController;
 
   /**
   * @brief The 3 helper objects which contain the plane geometry.
   */
   mitk::DataNode::Pointer m_PlaneNode1;
   mitk::DataNode::Pointer m_PlaneNode2;
   mitk::DataNode::Pointer m_PlaneNode3;
 
   /**
    * @brief m_ParentNodeForGeometryPlanes This helper object is added to the datastorage
    * and contains the 3 planes for displaying the image geometry (crosshair and 3D planes).
    */
   mitk::DataNode::Pointer m_ParentNodeForGeometryPlanes;
 
   /**
    * @brief m_DecorationColorWidget4 color for annotation and rectangle of widget 4.
    *
    * For other widgets1-3, the color is a property of the respective data node.
    * There is no node for widget 4, hence, we need an extra member.
    */
   mitk::Color m_DecorationColorWidget4;
 
-  bool m_PendingCrosshairPositionEvent;
-
 };
 
 #endif // QMITKSTDMULTIWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkRenderWindow.cpp b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
index eecc0b070f..6372b632bc 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindow.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
@@ -1,464 +1,489 @@
 /*============================================================================
 
 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 "QmitkRenderWindow.h"
 
 #include "mitkInteractionKeyEvent.h"
 #include "mitkInternalEvent.h"
 #include "mitkMouseDoubleClickEvent.h"
 #include "mitkMouseMoveEvent.h"
 #include "mitkMousePressEvent.h"
 #include "mitkMouseReleaseEvent.h"
 #include "mitkMouseWheelEvent.h"
+#include <mitkStatusBar.h>
+
 #include <QCursor>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QKeyEvent>
 #include <QMouseEvent>
 #include <QResizeEvent>
 #include <QSurfaceFormat>
 #include <QTimer>
 #include <QWheelEvent>
 #include <QWindow>
 
 #include "QmitkMimeTypes.h"
 #include "QmitkRenderWindowMenu.h"
 
 QmitkRenderWindow::QmitkRenderWindow(QWidget *parent, const QString &name, mitk::VtkPropRenderer *)
   : QVTKOpenGLNativeWidget(parent)
   , m_ResendQtEvents(true)
   , m_MenuWidget(nullptr)
   , m_MenuWidgetActivated(false)
   , m_LayoutIndex(QmitkRenderWindowMenu::LayoutIndex::AXIAL)
 {
   m_InternalRenderWindow = vtkSmartPointer<vtkGenericOpenGLRenderWindow>::New();
   m_InternalRenderWindow->SetMultiSamples(0);
   m_InternalRenderWindow->SetAlphaBitPlanes(0);
 
   setRenderWindow(m_InternalRenderWindow);
 
   Initialize(name.toStdString().c_str());
 
   setFocusPolicy(Qt::StrongFocus);
   setMouseTracking(true);
   QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   setSizePolicy(sizePolicy);
 }
 
 QmitkRenderWindow::~QmitkRenderWindow()
 {
   Destroy(); // Destroy mitkRenderWindowBase
 }
 
 void QmitkRenderWindow::SetResendQtEvents(bool resend)
 {
   m_ResendQtEvents = resend;
 }
 
 void QmitkRenderWindow::SetLayoutIndex(QmitkRenderWindowMenu::LayoutIndex layoutIndex)
 {
   m_LayoutIndex = layoutIndex;
   if (nullptr != m_MenuWidget)
   {
     m_MenuWidget->SetLayoutIndex(layoutIndex);
   }
 }
 
 QmitkRenderWindowMenu::LayoutIndex QmitkRenderWindow::GetLayoutIndex()
 {
   if (nullptr != m_MenuWidget)
   {
     return m_MenuWidget->GetLayoutIndex();
   }
   else
   {
     return QmitkRenderWindowMenu::LayoutIndex::AXIAL;
   }
 }
 
 void QmitkRenderWindow::UpdateLayoutDesignList(QmitkRenderWindowMenu::LayoutDesign layoutDesign)
 {
   if (nullptr != m_MenuWidget)
   {
     m_MenuWidget->UpdateLayoutDesignList(layoutDesign);
   }
 }
 
 void QmitkRenderWindow::UpdateCrosshairVisibility(bool visible)
 {
   m_MenuWidget->UpdateCrosshairVisibility(visible);
 }
 
 void QmitkRenderWindow::UpdateCrosshairRotationMode(int mode)
 {
   m_MenuWidget->UpdateCrosshairRotationMode(mode);
 }
 
 void QmitkRenderWindow::ActivateMenuWidget(bool state)
 {
   if (nullptr == m_MenuWidget)
   {
     m_MenuWidget = new QmitkRenderWindowMenu(this, nullptr, m_Renderer);
     m_MenuWidget->SetLayoutIndex(m_LayoutIndex);
   }
 
   m_MenuWidgetActivated = state;
 
   if (m_MenuWidgetActivated)
   {
     connect(m_MenuWidget, &QmitkRenderWindowMenu::LayoutDesignChanged, this, &QmitkRenderWindow::LayoutDesignChanged);
     connect(m_MenuWidget, &QmitkRenderWindowMenu::ResetView, this, &QmitkRenderWindow::ResetView);
     connect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairVisibilityChanged, this, &QmitkRenderWindow::CrosshairVisibilityChanged);
     connect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairRotationModeChanged, this, &QmitkRenderWindow::CrosshairRotationModeChanged);
   }
   else
   {
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::LayoutDesignChanged, this, &QmitkRenderWindow::LayoutDesignChanged);
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::ResetView, this, &QmitkRenderWindow::ResetView);
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairVisibilityChanged, this, &QmitkRenderWindow::CrosshairVisibilityChanged);
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairRotationModeChanged, this, &QmitkRenderWindow::CrosshairRotationModeChanged);
 
     m_MenuWidget->hide();
   }
 }
 
 void QmitkRenderWindow::moveEvent(QMoveEvent *event)
 {
   QVTKOpenGLNativeWidget::moveEvent(event);
 
   // after a move the overlays need to be positioned
   emit moved();
 }
 
 void QmitkRenderWindow::showEvent(QShowEvent *event)
 {
   QVTKOpenGLNativeWidget::showEvent(event);
 
   // this singleshot is necessary to have the overlays positioned correctly after initial show
   // simple call of moved() is no use here!!
   QTimer::singleShot(0, this, SIGNAL(moved()));
 }
 
 bool QmitkRenderWindow::event(QEvent* e)
 {
   mitk::InteractionEvent::Pointer mitkEvent = nullptr;
+  mitk::Point2D mousePosition;
+  bool updateStatusBar = false;
   switch (e->type())
   {
     case QEvent::MouseMove:
     {
       auto me = static_cast<QMouseEvent *>(e);
-      mitkEvent = mitk::MouseMoveEvent::New(m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me));
+      mousePosition = this->GetMousePosition(me);
+      mitkEvent = mitk::MouseMoveEvent::New(m_Renderer, mousePosition, GetButtonState(me), GetModifiers(me));
+      updateStatusBar = true;
       break;
     }
     case QEvent::MouseButtonPress:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mitkEvent = mitk::MousePressEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
       break;
     }
     case QEvent::MouseButtonRelease:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mitkEvent = mitk::MouseReleaseEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
       break;
     }
     case QEvent::MouseButtonDblClick:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mitkEvent = mitk::MouseDoubleClickEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
       break;
     }
     case QEvent::Wheel:
     {
       auto we = static_cast<QWheelEvent *>(e);
-      mitkEvent = mitk::MouseWheelEvent::New( m_Renderer, GetMousePosition(we), GetButtonState(we), GetModifiers(we), GetDelta(we));
+      mousePosition = this->GetMousePosition(we);
+      mitkEvent = mitk::MouseWheelEvent::New(m_Renderer, mousePosition, GetButtonState(we), GetModifiers(we), GetDelta(we));
+      updateStatusBar = true;
       break;
     }
     case QEvent::KeyPress:
     {
       auto ke = static_cast<QKeyEvent*>(e);
       mitkEvent = mitk::InteractionKeyEvent::New(m_Renderer, GetKeyLetter(ke), GetModifiers(ke));
       break;
     }
     case QEvent::Resize:
     {
       if (nullptr != m_MenuWidget)
         m_MenuWidget->MoveWidgetToCorrectPos();
     }
     default:
     {
       break;
     }
   }
 
   if (mitkEvent != nullptr)
   {
     if (this->HandleEvent(mitkEvent.GetPointer())) {
       return m_ResendQtEvents ? false : true;
     }
   }
 
+  if (updateStatusBar)
+  {
+    this->UpdateStatusBar(mousePosition);
+  }
+
   return QVTKOpenGLNativeWidget::event(e);
 }
 
 void QmitkRenderWindow::enterEvent(QEvent *e)
 {
   // TODO implement new event
   QVTKOpenGLNativeWidget::enterEvent(e);
 
   if (nullptr != m_MenuWidget)
     m_MenuWidget->ShowMenu();
 }
 
 void QmitkRenderWindow::leaveEvent(QEvent *e)
 {
+  auto statusBar = mitk::StatusBar::GetInstance();
+  statusBar->DisplayGreyValueText("");
+
   mitk::InternalEvent::Pointer internalEvent = mitk::InternalEvent::New(this->m_Renderer, nullptr, "LeaveRenderWindow");
 
   this->HandleEvent(internalEvent.GetPointer());
 
   if (nullptr != m_MenuWidget)
     m_MenuWidget->HideMenu();
 
   QVTKOpenGLNativeWidget::leaveEvent(e);
 }
 
 void QmitkRenderWindow::resizeGL(int w, int h)
 {
   QVTKOpenGLNativeWidget::resizeGL(w, h);
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(renderWindow());
 }
 
 void QmitkRenderWindow::dragEnterEvent(QDragEnterEvent *event)
 {
   if (event->mimeData()->hasFormat("application/x-mitk-datanodes"))
   {
     event->accept();
   }
 }
 
 void QmitkRenderWindow::dropEvent(QDropEvent *event)
 {
   QList<mitk::DataNode *> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(event->mimeData());
   if (!dataNodeList.empty())
   {
     emit NodesDropped(this, dataNodeList.toVector().toStdVector());
   }
 }
 
 void QmitkRenderWindow::DeferredHideMenu()
 {
   MITK_DEBUG << "QmitkRenderWindow::DeferredHideMenu";
 
   if (nullptr != m_MenuWidget)
   {
     m_MenuWidget->HideMenu();
   }
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QMouseEvent *me) const
 {
   mitk::Point2D point;
   point[0] = me->x();
   // We need to convert the y component, as the display and vtk have other definitions for the y direction
   point[1] = m_Renderer->GetSizeY() - me->y();
   return point;
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QWheelEvent *we) const
 {
   mitk::Point2D point;
   point[0] = we->x();
   // We need to convert the y component, as the display and vtk have other definitions for the y direction
   point[1] = m_Renderer->GetSizeY() - we->y();
   return point;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetEventButton(QMouseEvent *me) const
 {
   mitk::InteractionEvent::MouseButtons eventButton;
   switch (me->button())
   {
   case Qt::LeftButton:
     eventButton = mitk::InteractionEvent::LeftMouseButton;
     break;
   case Qt::RightButton:
     eventButton = mitk::InteractionEvent::RightMouseButton;
     break;
   case Qt::MidButton:
     eventButton = mitk::InteractionEvent::MiddleMouseButton;
     break;
   default:
     eventButton = mitk::InteractionEvent::NoButton;
     break;
   }
   return eventButton;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QMouseEvent *me) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (me->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (me->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (me->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 mitk::InteractionEvent::ModifierKeys QmitkRenderWindow::GetModifiers(QInputEvent *me) const
 {
   mitk::InteractionEvent::ModifierKeys modifiers = mitk::InteractionEvent::NoKey;
 
   if (me->modifiers() & Qt::ALT)
   {
     modifiers = modifiers | mitk::InteractionEvent::AltKey;
   }
   if (me->modifiers() & Qt::CTRL)
   {
     modifiers = modifiers | mitk::InteractionEvent::ControlKey;
   }
   if (me->modifiers() & Qt::SHIFT)
   {
     modifiers = modifiers | mitk::InteractionEvent::ShiftKey;
   }
   return modifiers;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QWheelEvent *we) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (we->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (we->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (we->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 std::string QmitkRenderWindow::GetKeyLetter(QKeyEvent *ke) const
 {
   // Converting Qt Key Event to string element.
   std::string key = "";
   int tkey = ke->key();
   if (tkey < 128)
   { // standard ascii letter
     key = (char)toupper(tkey);
   }
   else
   { // special keys
     switch (tkey)
     {
     case Qt::Key_Return:
       key = mitk::InteractionEvent::KeyReturn;
       break;
     case Qt::Key_Enter:
       key = mitk::InteractionEvent::KeyEnter;
       break;
     case Qt::Key_Escape:
       key = mitk::InteractionEvent::KeyEsc;
       break;
     case Qt::Key_Delete:
       key = mitk::InteractionEvent::KeyDelete;
       break;
     case Qt::Key_Up:
       key = mitk::InteractionEvent::KeyArrowUp;
       break;
     case Qt::Key_Down:
       key = mitk::InteractionEvent::KeyArrowDown;
       break;
     case Qt::Key_Left:
       key = mitk::InteractionEvent::KeyArrowLeft;
       break;
     case Qt::Key_Right:
       key = mitk::InteractionEvent::KeyArrowRight;
       break;
 
     case Qt::Key_F1:
       key = mitk::InteractionEvent::KeyF1;
       break;
     case Qt::Key_F2:
       key = mitk::InteractionEvent::KeyF2;
       break;
     case Qt::Key_F3:
       key = mitk::InteractionEvent::KeyF3;
       break;
     case Qt::Key_F4:
       key = mitk::InteractionEvent::KeyF4;
       break;
     case Qt::Key_F5:
       key = mitk::InteractionEvent::KeyF5;
       break;
     case Qt::Key_F6:
       key = mitk::InteractionEvent::KeyF6;
       break;
     case Qt::Key_F7:
       key = mitk::InteractionEvent::KeyF7;
       break;
     case Qt::Key_F8:
       key = mitk::InteractionEvent::KeyF8;
       break;
     case Qt::Key_F9:
       key = mitk::InteractionEvent::KeyF9;
       break;
     case Qt::Key_F10:
       key = mitk::InteractionEvent::KeyF10;
       break;
     case Qt::Key_F11:
       key = mitk::InteractionEvent::KeyF11;
       break;
     case Qt::Key_F12:
       key = mitk::InteractionEvent::KeyF12;
       break;
 
     case Qt::Key_End:
       key = mitk::InteractionEvent::KeyEnd;
       break;
     case Qt::Key_Home:
       key = mitk::InteractionEvent::KeyPos1;
       break;
     case Qt::Key_Insert:
       key = mitk::InteractionEvent::KeyInsert;
       break;
     case Qt::Key_PageDown:
       key = mitk::InteractionEvent::KeyPageDown;
       break;
     case Qt::Key_PageUp:
       key = mitk::InteractionEvent::KeyPageUp;
       break;
     case Qt::Key_Space:
       key = mitk::InteractionEvent::KeySpace;
       break;
     }
   }
   return key;
 }
 
 int QmitkRenderWindow::GetDelta(QWheelEvent *we) const
 {
   return we->delta();
 }
+
+void QmitkRenderWindow::UpdateStatusBar(mitk::Point2D pointerPositionOnScreen)
+{
+  mitk::Point3D worldPosition;
+  m_Renderer->ForceImmediateUpdate();
+  m_Renderer->DisplayToWorld(pointerPositionOnScreen, worldPosition);
+  auto statusBar = mitk::StatusBar::GetInstance();
+  statusBar->DisplayRendererInfo(worldPosition, m_Renderer->GetTime());
+}
diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index 7a2973bfd3..3ea503ba4a 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,815 +1,713 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 #define SMW_INFO MITK_INFO("widget.stdmulti")
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkCameraController.h>
 #include <mitkImage.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkInteractionConst.h>
 #include <mitkLine.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkPlaneGeometryDataMapper2D.h>
 #include <mitkPointSet.h>
 #include <mitkProperties.h>
 #include <mitkStatusBar.h>
 #include <mitkDisplayActionEventHandlerStd.h>
 #include <mitkVtkLayerController.h>
 
 // qt
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 
 // vtk
 #include <vtkSmartPointer.h>
 
 // c++
 #include <iomanip>
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          const QString &name/* = "stdmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, name)
   , m_TimeNavigationController(nullptr)
-  , m_PendingCrosshairPositionEvent(false)
 {
   m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
 }
 
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   auto allRenderWindows = this->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     m_TimeNavigationController->Disconnect(renderWindow->GetSliceNavigationController());
   }
 }
 
 void QmitkStdMultiWidget::InitializeMultiWidget()
 {
   // yellow is default color for widget4
   m_DecorationColorWidget4[0] = 1.0f;
   m_DecorationColorWidget4[1] = 1.0f;
   m_DecorationColorWidget4[2] = 0.0f;
 
   SetLayout(2, 2);
 
   // transfer colors in WorldGeometry-Nodes of the associated Renderer
   mitk::IntProperty::Pointer layer;
   // of widget 1
   m_PlaneNode1 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetColor(GetDecorationColor(0));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode1->SetProperty("layer", layer);
 
   // of widget 2
   m_PlaneNode2 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetColor(GetDecorationColor(1));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode2->SetProperty("layer", layer);
 
   // of widget 3
   m_PlaneNode3 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetColor(GetDecorationColor(2));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode3->SetProperty("layer", layer);
 
   // the parent node
   m_ParentNodeForGeometryPlanes =
     mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   layer = mitk::IntProperty::New(1000);
   m_ParentNodeForGeometryPlanes->SetProperty("layer", layer);
 
   AddDisplayPlaneSubTree();
 
   SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerStd>());
 
   auto displayActionEventHandler = GetDisplayActionEventHandler();
   if (nullptr != displayActionEventHandler)
   {
     displayActionEventHandler->InitActions();
   }
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   if ("axial" == widgetName)
   {
     return GetRenderWindow1();
   }
 
   if ("sagittal" == widgetName)
   {
     return GetRenderWindow2();
   }
 
   if ("coronal" == widgetName)
   {
     return GetRenderWindow3();
   }
 
   if ("3d" == widgetName)
   {
     return GetRenderWindow4();
   }
 
 
   return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const
 {
   return GetRenderWindow(static_cast<unsigned int>(viewDirection));
 }
 
 void QmitkStdMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& /*widgetName*/)
 {
   GetRenderWindow1()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   GetRenderWindow2()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   GetRenderWindow3()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
 
   RequestUpdateAll();
 }
 
 const mitk::Point3D QmitkStdMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
 {
   const mitk::PlaneGeometry* plane1 = GetRenderWindow1()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry* plane2 = GetRenderWindow2()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry* plane3 = GetRenderWindow3()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ((plane1 != nullptr) && (plane2 != nullptr)
    && (plane1->IntersectionLine(plane2, line)))
   {
     mitk::Point3D point;
     if ((plane3 != nullptr) && (plane3->IntersectionPoint(line, point)))
     {
       return point;
     }
   }
 
   return mitk::Point3D();
 }
 
 void QmitkStdMultiWidget::SetCrosshairVisibility(bool visible)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible);
   }
 
   emit NotifyCrosshairVisibilityChanged(visible);
 
   RequestUpdateAll();
 }
 
 bool QmitkStdMultiWidget::GetCrosshairVisibility() const
 {
   bool crosshairVisibility = true;
 
   if (m_PlaneNode1.IsNotNull())
   {
     bool visibilityProperty = false;
     m_PlaneNode1->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   if (m_PlaneNode2.IsNotNull())
   {
     bool visibilityProperty = false;
     crosshairVisibility &= m_PlaneNode2->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   if (m_PlaneNode3.IsNotNull())
   {
     bool visibilityProperty = false;
     crosshairVisibility &= m_PlaneNode3->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   return crosshairVisibility;
 }
 
 void QmitkStdMultiWidget::SetCrosshairGap(unsigned int gapSize)
 {
   m_PlaneNode1->SetIntProperty("Crosshair.Gap Size", gapSize);
   m_PlaneNode2->SetIntProperty("Crosshair.Gap Size", gapSize);
   m_PlaneNode3->SetIntProperty("Crosshair.Gap Size", gapSize);
 }
 
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
 
   SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   switch (userMode)
   {
   case 0:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKStandard);
     break;
   case 1:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationUncoupled);
     break;
   case 2:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationCoupled);
     break;
   case 3:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKSwivel);
     break;
   }
 
   emit NotifyCrosshairRotationModeChanged(userMode);
 }
 
 mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 void QmitkStdMultiWidget::AddPlanesToDataStorage()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
    && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     dataStorage->Add(m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
   }
 }
 
 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
    && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     dataStorage->Remove(m_PlaneNode1);
     dataStorage->Remove(m_PlaneNode2);
     dataStorage->Remove(m_PlaneNode3);
     dataStorage->Remove(m_ParentNodeForGeometryPlanes);
   }
 }
 
-void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
-{
-  if (!m_PendingCrosshairPositionEvent)
-  {
-    m_PendingCrosshairPositionEvent = true;
-    QTimer::singleShot(0, this, SLOT(HandleCrosshairPositionEventDelayed()));
-  }
-}
-
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(unsigned int number) const
 {
   switch (number)
   {
   case 0:
     return GetRenderWindow1();
   case 1:
     return GetRenderWindow2();
   case 2:
     return GetRenderWindow3();
   case 3:
     return GetRenderWindow4();
   default:
     MITK_ERROR << "Requested unknown render window";
     break;
   }
 
   return nullptr;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 0));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 1));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 0));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 1));
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1() const
 {
   return m_PlaneNode1;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2() const
 {
   return m_PlaneNode2;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3() const
 {
   return m_PlaneNode3;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(unsigned number) const
 {
   switch (number)
   {
   case 1:
     return m_PlaneNode1;
   case 2:
     return m_PlaneNode2;
   case 3:
     return m_PlaneNode3;
   default:
     MITK_ERROR << "Requested unknown render window";
     break;
   }
 
   return nullptr;
 }
 
 void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
 {
   switch (widgetNumber)
   {
   case 0:
     if (m_PlaneNode1.IsNotNull())
     {
       m_PlaneNode1->SetColor(color);
     }
     break;
   case 1:
     if (m_PlaneNode2.IsNotNull())
     {
       m_PlaneNode2->SetColor(color);
     }
     break;
   case 2:
     if (m_PlaneNode3.IsNotNull())
     {
       m_PlaneNode3->SetColor(color);
     }
     break;
   case 3:
     m_DecorationColorWidget4 = color;
     break;
   default:
     MITK_ERROR << "Decoration color for unknown widget!";
     break;
   }
 }
 
 mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber)
 {
   // The implementation looks a bit messy here, but it avoids
   // synchronization of the color of the geometry nodes and an
   // internal member here.
   // Default colors were chosen for decent visibility.
   // Feel free to change your preferences in the workbench.
   float tmp[3] = { 0.0f, 0.0f, 0.0f };
   switch (widgetNumber)
   {
   case 0:
   {
     if (m_PlaneNode1.IsNotNull())
     {
       if (m_PlaneNode1->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode1->GetProperty("color"))->GetColor();
       }
     }
     float red[3] = { 0.753f, 0.0f, 0.0f }; // This is #C00000 in hex
     return mitk::Color(red);
   }
   case 1:
   {
     if (m_PlaneNode2.IsNotNull())
     {
       if (m_PlaneNode2->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode2->GetProperty("color"))->GetColor();
       }
     }
     float green[3] = { 0.0f, 0.69f, 0.0f }; // This is #00B000 in hex
     return mitk::Color(green);
   }
   case 2:
   {
     if (m_PlaneNode3.IsNotNull())
     {
       if (m_PlaneNode3->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode3->GetProperty("color"))->GetColor();
       }
     }
     float blue[3] = { 0.0, 0.502f, 1.0f }; // This is #0080FF in hex
     return mitk::Color(blue);
   }
   case 3:
   {
     return m_DecorationColorWidget4;
   }
   default:
     MITK_ERROR << "Decoration color for unknown widget!";
     float black[3] = { 0.0f, 0.0f, 0.0f };
     return mitk::Color(black);
   }
 }
 
 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent*)
 {
   // nothing here, but necessary for mouse interactions (.xml-configuration files)
 }
 
 void QmitkStdMultiWidget::moveEvent(QMoveEvent* e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the Annotation as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 void QmitkStdMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
-void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
-{
-  auto dataStorage = GetDataStorage();
-  if (nullptr == dataStorage)
-  {
-    return;
-  }
-
-  m_PendingCrosshairPositionEvent = false;
-
-  // find image with highest layer
-  mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
-  mitk::DataStorage::SetOfObjects::ConstPointer nodes = dataStorage->GetSubset(isImageData).GetPointer();
-  mitk::Point3D crosshairPos = GetSelectedPosition("");
-  mitk::BaseRenderer* baseRenderer = GetRenderWindow1()->GetSliceNavigationController()->GetRenderer();
-  auto globalCurrentTimePoint = baseRenderer->GetTime();
-  mitk::DataNode::Pointer node = mitk::FindTopmostVisibleNode(nodes, crosshairPos, globalCurrentTimePoint, baseRenderer);
-
-  mitk::DataNode::Pointer topSourceNode;
-  mitk::Image::Pointer image;
-  bool isBinary = false;
-  int component = 0;
-
-  if (node.IsNotNull())
-  {
-    node->GetBoolProperty("binary", isBinary);
-    if (isBinary)
-    {
-      mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = dataStorage->GetSources(node, nullptr, true);
-      if (!sourcenodes->empty())
-      {
-        topSourceNode = mitk::FindTopmostVisibleNode(sourcenodes, crosshairPos, globalCurrentTimePoint, baseRenderer);
-      }
-      if (topSourceNode.IsNotNull())
-      {
-        image = dynamic_cast<mitk::Image *>(topSourceNode->GetData());
-        topSourceNode->GetIntProperty("Image.Displayed Component", component);
-      }
-      else
-      {
-        image = dynamic_cast<mitk::Image *>(node->GetData());
-        node->GetIntProperty("Image.Displayed Component", component);
-      }
-    }
-    else
-    {
-      image = dynamic_cast<mitk::Image *>(node->GetData());
-      node->GetIntProperty("Image.Displayed Component", component);
-    }
-  }
-
-  std::string statusText;
-  std::stringstream stream;
-  itk::Index<3> p;
-  unsigned int timestep = baseRenderer->GetTimeStep();
-
-  if (image.IsNotNull() && (image->GetTimeSteps() > timestep))
-  {
-    image->GetGeometry()->WorldToIndex(crosshairPos, p);
-    stream.precision(2);
-    stream << "Position: <" << std::fixed << crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", "
-      << std::fixed << crosshairPos[2] << "> mm";
-    stream << "; Index: <" << p[0] << ", " << p[1] << ", " << p[2] << "> ";
-
-    mitk::ScalarType pixelValue;
-
-    mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess,
-      image->GetChannelDescriptor().GetPixelType(),
-      image,
-      image->GetVolumeData(image->GetTimeGeometry()->TimePointToTimeStep(globalCurrentTimePoint)),
-      p,
-      pixelValue,
-      component);
-
-    if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
-    {
-      stream << "; Time: " << globalCurrentTimePoint << " ms; Pixelvalue: " << std::scientific << pixelValue << "  ";
-    }
-    else
-    {
-      stream << "; Time: " << globalCurrentTimePoint << " ms; Pixelvalue: " << pixelValue << "  ";
-    }
-  }
-  else
-  {
-    stream << "No image information at this position!";
-  }
-
-  statusText = stream.str();
-  mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
-}
-
 void QmitkStdMultiWidget::Fit()
 {
   vtkSmartPointer<vtkRenderer> vtkrenderer;
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetCameraController()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
 {
   // add the displayed planes of the multiwidget to a node to which the subtree
   // @a planesSubTree points ...
 
   mitk::PlaneGeometryDataMapper2D::Pointer mapper;
 
   // ... of widget 1
   mitk::BaseRenderer* renderer1 = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow());
   m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane"));
   m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   mitk::BaseRenderer* renderer2 = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow());
   m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane"));
   m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow());
   m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane"));
   m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   m_ParentNodeForGeometryPlanes = mitk::DataNode::New();
   m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets"));
   m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true));
 }
 
 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
 {
   mitk::Point2D pointOnDisplay;
   renderer->WorldToDisplay(p, pointOnDisplay);
 
   if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] ||
     pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] ||
     pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] ||
     pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1])
   {
     mitk::Point2D pointOnPlane;
     renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane);
     renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane);
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
 {
   auto dataStorage = GetDataStorage();
   if (nullptr != dataStorage)
   {
     mitk::DataNode* dataNode = dataStorage->GetNamedNode(widgetName);
     if (dataNode != nullptr)
     {
       dataNode->SetVisibility(visible, renderer);
     }
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible, renderer);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkStdMultiWidget::SetLayoutImpl()
 {
   CreateRenderWindowWidgets();
   GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
 
   // Initialize views as axial, sagittal, coronal to all data objects in DataStorage
   auto geo = GetDataStorage()->ComputeBoundingGeometry3D(GetDataStorage()->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 }
 
 void QmitkStdMultiWidget::CreateRenderWindowWidgets()
 {
   // create axial render window (widget)
   QString renderWindowWidgetName = GetNameFromIndex(0, 0);
   RenderWindowWidgetPointer renderWindowWidget1 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow1 = renderWindowWidget1->GetRenderWindow();
   renderWindow1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
   renderWindowWidget1->SetDecorationColor(GetDecorationColor(0));
   renderWindowWidget1->SetCornerAnnotationText("Axial");
   renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(ViewDirection::AXIAL);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget1);
 
   // create sagittal render window (widget)
   renderWindowWidgetName = GetNameFromIndex(0, 1);
   RenderWindowWidgetPointer renderWindowWidget2 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow2 = renderWindowWidget2->GetRenderWindow();
   renderWindow2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
   renderWindowWidget2->SetDecorationColor(GetDecorationColor(1));
   renderWindowWidget2->setStyleSheet("border: 0px");
   renderWindowWidget2->SetCornerAnnotationText("Sagittal");
   renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(ViewDirection::SAGITTAL);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget2);
 
   // create coronal render window (widget)
   renderWindowWidgetName = GetNameFromIndex(1, 0);
   RenderWindowWidgetPointer renderWindowWidget3 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow3 = renderWindowWidget3->GetRenderWindow();
   renderWindow3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Coronal);
   renderWindowWidget3->SetDecorationColor(GetDecorationColor(2));
   renderWindowWidget3->SetCornerAnnotationText("Coronal");
   renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(ViewDirection::CORONAL);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget3);
 
   // create 3D render window (widget)
   renderWindowWidgetName = GetNameFromIndex(1, 1);
   RenderWindowWidgetPointer renderWindowWidget4 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow4 = renderWindowWidget4->GetRenderWindow();
   renderWindow4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
   renderWindowWidget4->SetDecorationColor(GetDecorationColor(3));
   renderWindowWidget4->SetCornerAnnotationText("3D");
   renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(ViewDirection::THREE_D);
   mitk::BaseRenderer::GetInstance(renderWindowWidget4->GetRenderWindow()->renderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget4);
 
   SetActiveRenderWindowWidget(renderWindowWidget1);
 
   // connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow1->GetSliceNavigationController());
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow2->GetSliceNavigationController());
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow3->GetSliceNavigationController());
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow4->GetSliceNavigationController());
   renderWindow1->GetSliceNavigationController()->ConnectGeometrySendEvent(
     mitk::BaseRenderer::GetInstance(renderWindow4->renderWindow()));
 
   // reverse connection between sliceNavigationControllers and timeNavigationController
   renderWindow1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
   renderWindow2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
   renderWindow3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
   //renderWindow4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
 
   auto layoutManager = GetMultiWidgetLayoutManager();
   connect(renderWindow1, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow1, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow1, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow1, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow1, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow1, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow2, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow2, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow2, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow2, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow2, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow2, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow3, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow3, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow3, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow3, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow3, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow3, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow4, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow4, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow4, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow4, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow4, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow4, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 }
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);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
index b0423f5a91..af22d86bbf 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
@@ -1,563 +1,456 @@
 /*============================================================================
 
 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 "QmitkImageNavigatorView.h"
 
 #include <itkSpatialOrientationAdapter.h>
 
 #include <QmitkStepperAdapter.h>
 #include <QmitkRenderWindow.h>
 
 #include <mitkTimeGeometry.h>
 
 #include <berryConstants.h>
 #include <mitkPlaneGeometry.h>
-#include <mitkNodePredicateDataType.h>
-#include <mitkStatusBar.h>
-#include <mitkPixelTypeMultiplex.h>
-#include <mitkImagePixelReadAccessor.h>
-#include <mitkNodePredicateProperty.h>
-
-#include <mitkCompositePixelValueToString.h>
 
 const std::string QmitkImageNavigatorView::VIEW_ID = "org.mitk.views.imagenavigator";
 
 QmitkImageNavigatorView::QmitkImageNavigatorView()
   : m_AxialStepper(nullptr)
   , m_SagittalStepper(nullptr)
   , m_CoronalStepper(nullptr)
   , m_TimeStepper(nullptr)
   , m_Parent(nullptr)
   , m_IRenderWindowPart(nullptr)
 {
 }
 
 QmitkImageNavigatorView::~QmitkImageNavigatorView()
 {
 }
 
 void QmitkImageNavigatorView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets
   m_Parent = parent;
   m_Controls.setupUi(parent);
 
   connect(m_Controls.m_XWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
   connect(m_Controls.m_YWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
   connect(m_Controls.m_ZWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
 
   m_Parent->setEnabled(false);
 
   mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
   this->RenderWindowPartActivated(renderPart);
 }
 
 void QmitkImageNavigatorView::SetFocus ()
 {
   m_Controls.m_XWorldCoordinateSpinBox->setFocus();
 }
 
 void QmitkImageNavigatorView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (this->m_IRenderWindowPart != renderWindowPart)
   {
     this->m_IRenderWindowPart = renderWindowPart;
     this->m_Parent->setEnabled(true);
 
     QmitkRenderWindow* renderWindow = renderWindowPart->GetQmitkRenderWindow("axial");
     if (renderWindow)
     {
       if (m_AxialStepper) m_AxialStepper->deleteLater();
       m_AxialStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorAxial,
                                                      renderWindow->GetSliceNavigationController()->GetSlice(),
                                                      "sliceNavigatorAxialFromSimpleExample");
       m_Controls.m_SliceNavigatorAxial->setEnabled(true);
       m_Controls.m_AxialLabel->setEnabled(true);
       m_Controls.m_ZWorldCoordinateSpinBox->setEnabled(true);
       connect(m_AxialStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
-      connect(m_AxialStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorAxial->setEnabled(false);
       m_Controls.m_AxialLabel->setEnabled(false);
       m_Controls.m_ZWorldCoordinateSpinBox->setEnabled(false);
     }
 
     renderWindow = renderWindowPart->GetQmitkRenderWindow("sagittal");
     if (renderWindow)
     {
       if (m_SagittalStepper) m_SagittalStepper->deleteLater();
       m_SagittalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorSagittal,
                                                   renderWindow->GetSliceNavigationController()->GetSlice(),
                                                   "sliceNavigatorSagittalFromSimpleExample");
       m_Controls.m_SliceNavigatorSagittal->setEnabled(true);
       m_Controls.m_SagittalLabel->setEnabled(true);
       m_Controls.m_YWorldCoordinateSpinBox->setEnabled(true);
       connect(m_SagittalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
-      connect(m_SagittalStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorSagittal->setEnabled(false);
       m_Controls.m_SagittalLabel->setEnabled(false);
       m_Controls.m_YWorldCoordinateSpinBox->setEnabled(false);
     }
 
     renderWindow = renderWindowPart->GetQmitkRenderWindow("coronal");
     if (renderWindow)
     {
       if (m_CoronalStepper) m_CoronalStepper->deleteLater();
       m_CoronalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorCoronal,
                                                  renderWindow->GetSliceNavigationController()->GetSlice(),
                                                  "sliceNavigatorCoronalFromSimpleExample");
       m_Controls.m_SliceNavigatorCoronal->setEnabled(true);
       m_Controls.m_CoronalLabel->setEnabled(true);
       m_Controls.m_XWorldCoordinateSpinBox->setEnabled(true);
       connect(m_CoronalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
-      connect(m_CoronalStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorCoronal->setEnabled(false);
       m_Controls.m_CoronalLabel->setEnabled(false);
       m_Controls.m_XWorldCoordinateSpinBox->setEnabled(false);
     }
 
     mitk::SliceNavigationController* timeController = renderWindowPart->GetTimeNavigationController();
     if (timeController)
     {
       if (m_TimeStepper) m_TimeStepper->deleteLater();
       m_TimeStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorTime,
                                               timeController->GetTime(),
                                               "sliceNavigatorTimeFromSimpleExample");
       m_Controls.m_SliceNavigatorTime->setEnabled(true);
       m_Controls.m_TimeLabel->setEnabled(true);
-      connect(m_TimeStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorTime->setEnabled(false);
       m_Controls.m_TimeLabel->setEnabled(false);
     }
 
     this->OnRefetch();
-    this->UpdateStatusBar();
-  }
-}
-
-void QmitkImageNavigatorView::UpdateStatusBar()
-{
-  if (m_IRenderWindowPart != nullptr)
-  {
-    mitk::Point3D position = m_IRenderWindowPart->GetSelectedPosition();
-    mitk::BaseRenderer::Pointer baseRenderer = mitk::BaseRenderer::GetInstance(m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetVtkRenderWindow());
-    auto globalCurrentTimePoint = baseRenderer->GetTime();
-    mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
-
-    mitk::DataStorage::SetOfObjects::ConstPointer nodes = GetDataStorage()->GetSubset(isImageData).GetPointer();
-
-    if (nodes.IsNotNull())
-    {
-      mitk::Image::Pointer image3D;
-      mitk::DataNode::Pointer node;
-      mitk::DataNode::Pointer topSourceNode;
-
-      int component = 0;
-
-      node = mitk::FindTopmostVisibleNode(nodes, position, globalCurrentTimePoint, baseRenderer);
-
-      if (node.IsNotNull())
-      {
-        bool isBinary(false);
-        node->GetBoolProperty("binary", isBinary);
-        if (isBinary)
-        {
-          mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = GetDataStorage()->GetSources(node, nullptr, true);
-          if (!sourcenodes->empty())
-          {
-            topSourceNode = mitk::FindTopmostVisibleNode(sourcenodes, position, globalCurrentTimePoint, baseRenderer);
-          }
-          if (topSourceNode.IsNotNull())
-          {
-            image3D = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
-            topSourceNode->GetIntProperty("Image.Displayed Component", component);
-          }
-          else
-          {
-            image3D = dynamic_cast<mitk::Image*>(node->GetData());
-            node->GetIntProperty("Image.Displayed Component", component);
-          }
-        }
-        else
-        {
-          image3D = dynamic_cast<mitk::Image*>(node->GetData());
-          node->GetIntProperty("Image.Displayed Component", component);
-        }
-      }
-
-      // get the position and pixel value from the image and build up status bar text
-      auto statusBar = mitk::StatusBar::GetInstance();
-
-      if (image3D.IsNotNull() && statusBar != nullptr)
-      {
-        itk::Index<3> p;
-        image3D->GetGeometry()->WorldToIndex(position, p);
-
-        auto pixelType = image3D->GetChannelDescriptor().GetPixelType().GetPixelType();
-
-        if (pixelType == itk::IOPixelEnum::RGB || pixelType == itk::IOPixelEnum::RGBA)
-        {
-          std::string pixelValue = "Pixel RGB(A) value: ";
-          pixelValue.append(ConvertCompositePixelValueToString(image3D, p));
-          statusBar->DisplayImageInfo(position, p, globalCurrentTimePoint, pixelValue.c_str());
-        }
-        else if (pixelType == itk::IOPixelEnum::DIFFUSIONTENSOR3D || pixelType == itk::IOPixelEnum::SYMMETRICSECONDRANKTENSOR)
-        {
-          std::string pixelValue = "See ODF Details view. ";
-          statusBar->DisplayImageInfo(position, p, globalCurrentTimePoint, pixelValue.c_str());
-        }
-        else
-        {
-          itk::Index<3> p;
-          image3D->GetGeometry()->WorldToIndex(position, p);
-          mitk::ScalarType pixelValue;
-          mitkPixelTypeMultiplex5(
-            mitk::FastSinglePixelAccess,
-            image3D->GetChannelDescriptor().GetPixelType(),
-            image3D,
-            image3D->GetVolumeData(image3D->GetTimeGeometry()->TimePointToTimeStep(globalCurrentTimePoint)),
-            p,
-            pixelValue,
-            component);
-          statusBar->DisplayImageInfo(position, p, globalCurrentTimePoint, pixelValue);
-        }
-      }
-      else
-      {
-        statusBar->DisplayImageInfoInvalid();
-      }
-    }
   }
 }
 
 void QmitkImageNavigatorView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_IRenderWindowPart = nullptr;
   m_Parent->setEnabled(false);
 }
 
 int QmitkImageNavigatorView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkImageNavigatorView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return 200;
   }
   else
   {
     return preferredResult;
   }
 }
 
 int QmitkImageNavigatorView::GetClosestAxisIndex(mitk::Vector3D normal)
 {
   // cos(theta) = normal . axis
   // cos(theta) = (a, b, c) . (d, e, f)
   // cos(theta) = (a, b, c) . (1, 0, 0) = a
   // cos(theta) = (a, b, c) . (0, 1, 0) = b
   // cos(theta) = (a, b, c) . (0, 0, 1) = c
   double absCosThetaWithAxis[3];
 
   for (int i = 0; i < 3; i++)
   {
     absCosThetaWithAxis[i] = fabs(normal[i]);
   }
   int largestIndex = 0;
   double largestValue = absCosThetaWithAxis[0];
   for (int i = 1; i < 3; i++)
   {
     if (absCosThetaWithAxis[i] > largestValue)
     {
       largestValue = absCosThetaWithAxis[i];
       largestIndex = i;
     }
   }
   return largestIndex;
 }
 
 void QmitkImageNavigatorView::SetBorderColors()
 {
   if (m_IRenderWindowPart)
   {
     QString decoColor;
 
     QmitkRenderWindow* renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("axial");
     if (renderWindow)
     {
       decoColor = GetDecorationColorOfGeometry(renderWindow);
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, decoColor);
       }
     }
 
     renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("sagittal");
     if (renderWindow)
     {
       decoColor = GetDecorationColorOfGeometry(renderWindow);
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, decoColor);
       }
     }
 
     renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("coronal");
     if (renderWindow)
     {
       decoColor = GetDecorationColorOfGeometry(renderWindow);
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, decoColor);
       }
     }
   }
 }
 
 QString QmitkImageNavigatorView::GetDecorationColorOfGeometry(QmitkRenderWindow* renderWindow)
 {
   QColor color;
   float rgb[3] = {1.0f, 1.0f, 1.0f};
   float rgbMax = 255.0f;
   mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow())->GetCurrentWorldPlaneGeometryNode()->GetColor(rgb);
   color.setRed(static_cast<int>(rgb[0]*rgbMax + 0.5));
   color.setGreen(static_cast<int>(rgb[1]*rgbMax + 0.5));
   color.setBlue(static_cast<int>(rgb[2]*rgbMax + 0.5));
   QString colorAsString = QString(color.name());
   return colorAsString;
 }
 
 void QmitkImageNavigatorView::SetBorderColor(int axis, QString colorAsStyleSheetString)
 {
   if (axis == 0)
   {
     this->SetBorderColor(m_Controls.m_XWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
   else if (axis == 1)
   {
     this->SetBorderColor(m_Controls.m_YWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
   else if (axis == 2)
   {
     this->SetBorderColor(m_Controls.m_ZWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
 }
 
 void QmitkImageNavigatorView::SetBorderColor(QDoubleSpinBox *spinBox, QString colorAsStyleSheetString)
 {
   assert(spinBox);
   spinBox->setStyleSheet(QString("border: 2px solid ") + colorAsStyleSheetString + ";");
 }
 
 void QmitkImageNavigatorView::OnMillimetreCoordinateValueChanged()
 {
   if (m_IRenderWindowPart)
   {
     mitk::TimeGeometry::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldTimeGeometry();
 
     if (geometry.IsNotNull())
     {
       mitk::Point3D positionInWorldCoordinates;
       positionInWorldCoordinates[0] = m_Controls.m_XWorldCoordinateSpinBox->value();
       positionInWorldCoordinates[1] = m_Controls.m_YWorldCoordinateSpinBox->value();
       positionInWorldCoordinates[2] = m_Controls.m_ZWorldCoordinateSpinBox->value();
 
       m_IRenderWindowPart->SetSelectedPosition(positionInWorldCoordinates);
     }
   }
 }
 
 void QmitkImageNavigatorView::OnRefetch()
 {
   if (nullptr == m_IRenderWindowPart)
   {
     return;
   }
 
   mitk::TimeGeometry::ConstPointer timeGeometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldTimeGeometry();
 
   if (timeGeometry.IsNull())
   {
     return;
   }
 
   SetVisibilityOfTimeSlider(timeGeometry->CountTimeSteps());
   mitk::TimeStepType timeStep = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetTime()->GetPos();
   mitk::BaseGeometry::Pointer geometry = timeGeometry->GetGeometryForTimeStep(timeStep);
   if (geometry.IsNotNull())
   {
     mitk::BoundingBox::BoundsArrayType bounds = geometry->GetBounds();
 
     mitk::Point3D cornerPoint1InIndexCoordinates;
     cornerPoint1InIndexCoordinates[0] = bounds[0];
     cornerPoint1InIndexCoordinates[1] = bounds[2];
     cornerPoint1InIndexCoordinates[2] = bounds[4];
 
     mitk::Point3D cornerPoint2InIndexCoordinates;
     cornerPoint2InIndexCoordinates[0] = bounds[1];
     cornerPoint2InIndexCoordinates[1] = bounds[3];
     cornerPoint2InIndexCoordinates[2] = bounds[5];
 
     if (!geometry->GetImageGeometry())
     {
       cornerPoint1InIndexCoordinates[0] += 0.5;
       cornerPoint1InIndexCoordinates[1] += 0.5;
       cornerPoint1InIndexCoordinates[2] += 0.5;
       cornerPoint2InIndexCoordinates[0] -= 0.5;
       cornerPoint2InIndexCoordinates[1] -= 0.5;
       cornerPoint2InIndexCoordinates[2] -= 0.5;
     }
 
     mitk::Point3D crossPositionInWorldCoordinates = m_IRenderWindowPart->GetSelectedPosition();
 
     mitk::Point3D cornerPoint1InWorldCoordinates;
     mitk::Point3D cornerPoint2InWorldCoordinates;
 
     geometry->IndexToWorld(cornerPoint1InIndexCoordinates, cornerPoint1InWorldCoordinates);
     geometry->IndexToWorld(cornerPoint2InIndexCoordinates, cornerPoint2InWorldCoordinates);
 
     m_Controls.m_XWorldCoordinateSpinBox->blockSignals(true);
     m_Controls.m_YWorldCoordinateSpinBox->blockSignals(true);
     m_Controls.m_ZWorldCoordinateSpinBox->blockSignals(true);
 
     m_Controls.m_XWorldCoordinateSpinBox->setMinimum(
       std::min(cornerPoint1InWorldCoordinates[0], cornerPoint2InWorldCoordinates[0]));
     m_Controls.m_YWorldCoordinateSpinBox->setMinimum(
       std::min(cornerPoint1InWorldCoordinates[1], cornerPoint2InWorldCoordinates[1]));
     m_Controls.m_ZWorldCoordinateSpinBox->setMinimum(
       std::min(cornerPoint1InWorldCoordinates[2], cornerPoint2InWorldCoordinates[2]));
     m_Controls.m_XWorldCoordinateSpinBox->setMaximum(
       std::max(cornerPoint1InWorldCoordinates[0], cornerPoint2InWorldCoordinates[0]));
     m_Controls.m_YWorldCoordinateSpinBox->setMaximum(
       std::max(cornerPoint1InWorldCoordinates[1], cornerPoint2InWorldCoordinates[1]));
     m_Controls.m_ZWorldCoordinateSpinBox->setMaximum(
       std::max(cornerPoint1InWorldCoordinates[2], cornerPoint2InWorldCoordinates[2]));
 
     m_Controls.m_XWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[0]);
     m_Controls.m_YWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[1]);
     m_Controls.m_ZWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[2]);
 
     m_Controls.m_XWorldCoordinateSpinBox->blockSignals(false);
     m_Controls.m_YWorldCoordinateSpinBox->blockSignals(false);
     m_Controls.m_ZWorldCoordinateSpinBox->blockSignals(false);
 
     /// Calculating 'inverse direction' property.
 
     mitk::AffineTransform3D::MatrixType matrix = geometry->GetIndexToWorldTransform()->GetMatrix();
     matrix.GetVnlMatrix().normalize_columns();
     mitk::AffineTransform3D::MatrixType::InternalMatrixType inverseMatrix = matrix.GetInverse();
 
     for (int worldAxis = 0; worldAxis < 3; ++worldAxis)
     {
       QmitkRenderWindow *renderWindow = worldAxis == 0 ? m_IRenderWindowPart->GetQmitkRenderWindow("sagittal") :
                                         worldAxis == 1 ? m_IRenderWindowPart->GetQmitkRenderWindow("coronal") :
                                                          m_IRenderWindowPart->GetQmitkRenderWindow("axial");
 
       if (renderWindow)
       {
         const mitk::BaseGeometry *rendererGeometry = renderWindow->GetRenderer()->GetCurrentWorldGeometry();
 
         /// Because of some problems with the current way of event signalling,
         /// 'Modified' events are sent out from the stepper while the renderer
         /// does not have a geometry yet. Therefore, we do a nullptr check here.
         /// See bug T22122. This check can be resolved after T22122 got fixed.
         if (rendererGeometry)
         {
           int dominantAxis =
             itk::Function::Max3(inverseMatrix[0][worldAxis], inverseMatrix[1][worldAxis], inverseMatrix[2][worldAxis]);
 
           bool referenceGeometryAxisInverted = inverseMatrix[dominantAxis][worldAxis] < 0;
           bool rendererZAxisInverted = rendererGeometry->GetAxisVector(2)[worldAxis] < 0;
 
           /// `referenceGeometryAxisInverted` tells if the direction of the corresponding axis
           /// of the reference geometry is flipped compared to the 'world direction' or not.
           ///
           /// `rendererZAxisInverted` tells if direction of the renderer geometry z axis is
           /// flipped compared to the 'world direction' or not. This is the same as the indexing
           /// direction in the slice navigation controller and matches the 'top' property when
           /// initialising the renderer planes. (If 'top' was true then the direction is
           /// inverted.)
           ///
           /// The world direction can be +1 ('up') that means right, anterior or superior, or
           /// it can be -1 ('down') that means left, posterior or inferior, respectively.
           ///
           /// If these two do not match, we have to invert the index between the slice navigation
           /// controller and the slider navigator widget, so that the user can see and control
           /// the index according to the reference geometry, rather than the slice navigation
           /// controller. The index in the slice navigation controller depends on in which way
           /// the reference geometry has been resliced for the renderer, and it does not necessarily
           /// match neither the world direction, nor the direction of the corresponding axis of
           /// the reference geometry. Hence, it is a merely internal information that should not
           /// be exposed to the GUI.
           ///
           /// So that one can navigate in the same world direction by dragging the slider
           /// right, regardless of the direction of the corresponding axis of the reference
           /// geometry, we invert the direction of the controls if the reference geometry axis
           /// is inverted but the direction is not ('inversDirection' is false) or the other
           /// way around.
 
           bool inverseDirection = referenceGeometryAxisInverted != rendererZAxisInverted;
 
           QmitkSliderNavigatorWidget* navigatorWidget =
               worldAxis == 0 ? m_Controls.m_SliceNavigatorSagittal :
               worldAxis == 1 ? m_Controls.m_SliceNavigatorCoronal :
                                m_Controls.m_SliceNavigatorAxial;
 
           navigatorWidget->SetInverseDirection(inverseDirection);
 
           // This should be a preference (see T22254)
           // bool invertedControls = referenceGeometryAxisInverted != inverseDirection;
           // navigatorWidget->SetInvertedControls(invertedControls);
         }
       }
     }
   }
 
   this->SetBorderColors();
 }
 
 
 void QmitkImageNavigatorView::SetVisibilityOfTimeSlider(std::size_t timeSteps)
 {
   m_Controls.m_SliceNavigatorTime->setVisible(timeSteps > 1);
   m_Controls.m_TimeLabel->setVisible(timeSteps > 1);
 }
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.h b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.h
index 110ef123c4..419a40aa99 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.h
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.h
@@ -1,95 +1,94 @@
 /*============================================================================
 
 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 QMITKIMAGENAVIGATORVIEW_H
 #define QMITKIMAGENAVIGATORVIEW_H
 
 #include <berryISizeProvider.h>
 
 #include <QmitkAbstractView.h>
 #include <mitkIRenderWindowPartListener.h>
 
 #include "ui_QmitkImageNavigatorViewControls.h"
 
 class QmitkStepperAdapter;
 
 /*!
  * \ingroup org_mitk_gui_qt_imagenavigator_internal
  *
  * \class QmitkImageNavigatorView
  *
  * \brief Provides a means to scan quickly through a dataset via Axial,
  * Coronal and Sagittal sliders, displaying millimetre location and stepper position.
  *
  * For images, the stepper position corresponds to a voxel index. For other datasets
  * such as a surface, it corresponds to a sub-division of the bounding box.
  *
  * \sa QmitkAbstractView
  */
 class QmitkImageNavigatorView :
     public QmitkAbstractView, public mitk::IRenderWindowPartListener,
     public berry::ISizeProvider
 {
 
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkImageNavigatorView();
 
   ~QmitkImageNavigatorView() override;
 
   void CreateQtPartControl(QWidget *parent) override;
 
   int GetSizeFlags(bool width) override;
   int ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult) override;
 
 protected slots:
 
   void OnMillimetreCoordinateValueChanged();
   void OnRefetch();
-  void UpdateStatusBar();
 
 protected:
 
   void SetFocus() override;
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart) override;
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart *renderWindowPart) override;
 
   void SetBorderColors();
   void SetBorderColor(QDoubleSpinBox *spinBox, QString colorAsStyleSheetString);
   void SetBorderColor(int axis, QString colorAsStyleSheetString);
   int  GetClosestAxisIndex(mitk::Vector3D normal);
   void SetVisibilityOfTimeSlider(std::size_t timeSteps);
 
   Ui::QmitkImageNavigatorViewControls m_Controls;
 
   QmitkStepperAdapter* m_AxialStepper;
   QmitkStepperAdapter* m_SagittalStepper;
   QmitkStepperAdapter* m_CoronalStepper;
   QmitkStepperAdapter* m_TimeStepper;
 
   QWidget* m_Parent;
 
   mitk::IRenderWindowPart* m_IRenderWindowPart;
   /**
    * @brief GetDecorationColorOfGeometry helper method to get the color of a helper geometry node.
    * @param renderWindow The renderwindow of the geometry
    * @return the color for decoration in QString format (#RRGGBB).
    */
   QString GetDecorationColorOfGeometry(QmitkRenderWindow *renderWindow);
 };
 
 #endif // QMITKIMAGENAVIGATORVIEW_H