diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake
index b4f33cdb1e..e13405173c 100644
--- a/Modules/Core/files.cmake
+++ b/Modules/Core/files.cmake
@@ -1,321 +1,323 @@
 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
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.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/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/mitkVtkVolumeRenderingProperty.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/mitkDisplayCoordinateOperation.cpp
-  Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkDisplayActionEventBroadcast.cpp
   Interactions/mitkDisplayActionEventFunctions.cpp
   Interactions/mitkDisplayActionEventHandler.cpp
+  Interactions/mitkDisplayActionEventHandlerDesynchronized.cpp
+  Interactions/mitkDisplayActionEventHandlerStd.cpp
+  Interactions/mitkDisplayActionEventHandlerSynchronized.cpp
+  Interactions/mitkDisplayCoordinateOperation.cpp
+  Interactions/mitkDisplayInteractor.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/mitkMouseModeSwitcher.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/mitkStdDisplayActionEventHandler.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/mitkVtkLoggingAdapter.cpp
   IO/mitkPreferenceListReaderOptionsFunctor.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/DisplayConfig.xml
 Interactions/DisplayConfigPACS.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITK.xml
 Interactions/DisplayConfigMITKNoCrosshair.xml
 Interactions/DisplayConfigMITKRotation.xml
 Interactions/DisplayConfigMITKRotationUnCoupled.xml
 Interactions/DisplayConfigMITKSwivel.xml
 Interactions/DisplayConfigMITKLimited.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 mitkAnatomicalStructureColorPresets.xml
 )
diff --git a/Modules/Core/include/mitkDisplayActionEventHandler.h b/Modules/Core/include/mitkDisplayActionEventHandler.h
index a45d6acf85..f9356ebae2 100644
--- a/Modules/Core/include/mitkDisplayActionEventHandler.h
+++ b/Modules/Core/include/mitkDisplayActionEventHandler.h
@@ -1,99 +1,119 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKDISPLAYACTIONEVENTHANDLER_H
 #define MITKDISPLAYACTIONEVENTHANDLER_H
 
 #include <MitkCoreExports.h>
 
 // mitk core
 #include "mitkDisplayActionEventBroadcast.h"
 #include "mitkDisplayActionEvents.h"
 #include "mitkStdFunctionCommand.h"
 
 namespace mitk
 {
   /**
   * @brief This class simplifies the process of adding an itkEventObject-itkCommand pair as an observer of a
   *        DisplayActionEventBroadcast instance.
   *        The 'SetObservableBroadcast'-function can be used to define the broadcast instance that should be observed.
   *        The 'ConnectDisplayActionEvent'-function can be used to add a an observer to the broadcast.
   *        Such an observer consists of a DisplayActionEvent (an itkEventObject) and a StdFunctionCommand (an itkCommand).
   *        The StdFunctionCommand is created inside the function by the given two std::functions.
   */
   class MITKCORE_EXPORT DisplayActionEventHandler
   {
   public:
 
     using OberserverTagType = unsigned long;
 
+    virtual ~DisplayActionEventHandler();
+
     /**
     * @brief Sets the display action event broadcast class that should be observed.
     *     This class receives events from the given broadcast class and triggers the "corresponding functions" to perform the custom actions.
     *     "Corresponding functions" are std::functions inside commands that observe the specific display action event.
     *
     * @post If the same broadcast class was already set, nothing changed
     * @post If a different broadcast class was already set, the observing commands are removed as observer.
     *       Attention: All registered commands are removed from the list of observer.
     *
-    * @par  observableBroadcast   The 'DisplayActionEventBroadcast'-class that should be observed.
+    * @param  observableBroadcast   The 'DisplayActionEventBroadcast'-class that should be observed.
     */
     void SetObservableBroadcast(DisplayActionEventBroadcast* observableBroadcast);
 
     /**
     * @brief Uses the given std::functions to customize a command:
     *     The display action event is used to define on which event the command should react.
     *     The display action event broadcast class member is then observed by the newly created command.
     *     A tag for the command is returned and stored in a member vector.
     *
     * @pre    The class' observable (the display action event broadcast) has to be set to connect display events.
     * @throw  mitk::Exception, if the class' observable is null.
     *
-    * @par displayActionEvent   The 'DisplayActionEvent' on which the command should react.
-    * @par actionFunction       A custom std::Function that will be executed if the command receives the correct event.
-    * @par filterFunction       A custom std::Function that will be checked before the execution of the action function.
+    * @param displayActionEvent   The 'DisplayActionEvent' on which the command should react.
+    * @param actionFunction       A custom std::Function that will be executed if the command receives the correct event.
+    * @param filterFunction       A custom std::Function that will be checked before the execution of the action function.
     *                           If the filter function is not specified, a default filter always returning 'true' will be used.
     *
     * @return   A tag to identify, receive or remove the newly created 'StdFunctionCommand'.
     */
     OberserverTagType ConnectDisplayActionEvent(const DisplayActionEvent& displayActionEvent,
       const StdFunctionCommand::ActionFunction& actionFunction,
       const StdFunctionCommand::FilterFunction& filterFunction = [](const itk::EventObject&) { return true; });
 
     /**
     * @brief Uses the given observer tag to remove the corresponding custom command as an observer of the observed
     *     display action event broadcast class.
     *     If the given tag is not contained in the member vector of observer tags, nothing happens.
     *
     * @pre    The class' observable (the display action event broadcast) has to be set to connect display events.
     * @throw  mitk::Exception, if the class' observable is null.
     *
-    * @par observerTag   The tag to identify the 'StdFunctionCommand' observer.
+    * @param observerTag   The tag to identify the 'StdFunctionCommand' observer.
     */
     void DisconnectObserver(OberserverTagType observerTag);
 
-    const std::vector<OberserverTagType>& GetAllObserverTags() { return m_ObserverTags; };
+    const std::vector<OberserverTagType>& GetAllObserverTags() { return m_ObserverTags; }
+
+    /**
+    * @brief This function can be used by sub-classes to initialize a set of pre-defined
+    *        DisplayActionEventFunctions and connect them to the observable broadcast member.
+    *        In order to customize a sub-class behavior this function calls the virtual function
+    *        InitActionsImpl.
+    *        All currently connected display action events will be removed as observer from the broadcast instance.
+    *
+    * @pre    The class' observable (the display action event broadcast) has to be set.
+    * @throw  mitk::Exception, if the class' observable is null.
+    */
+    void InitActions();
 
   protected:
 
+    /**
+    * @brief Sub-classes need to implement this function to define a customized behavior
+    *        for default action pre-definition.
+    */
+    virtual void InitActionsImpl() { }
+
     WeakPointer<DisplayActionEventBroadcast> m_ObservableBroadcast;
     std::vector<OberserverTagType> m_ObserverTags;
 
   };
 
 } // end namespace mitk
 
 #endif // MITKDISPLAYACTIONEVENTHANDLER_H
diff --git a/Modules/Core/include/mitkStdDisplayActionEventHandler.h b/Modules/Core/include/mitkDisplayActionEventHandlerDesynchronized.h
similarity index 65%
copy from Modules/Core/include/mitkStdDisplayActionEventHandler.h
copy to Modules/Core/include/mitkDisplayActionEventHandlerDesynchronized.h
index 76758df9eb..fcb947d18e 100644
--- a/Modules/Core/include/mitkStdDisplayActionEventHandler.h
+++ b/Modules/Core/include/mitkDisplayActionEventHandlerDesynchronized.h
@@ -1,41 +1,41 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#ifndef MITKSTDDISPLAYACTIONEVENTHANDLER_H
-#define MITKSTDDISPLAYACTIONEVENTHANDLER_H
+#ifndef MITKDISPLAYACTIONEVENTHANDLERDESYNCHRONIZED_H
+#define MITKDISPLAYACTIONEVENTHANDLERDESYNCHRONIZED_H
 
 #include <MitkCoreExports.h>
 
 // mitk core
 #include "mitkDisplayActionEventHandler.h"
 
 namespace mitk
 {
-  class MITKCORE_EXPORT StdDisplayActionEventHandler : public DisplayActionEventHandler
+  class MITKCORE_EXPORT DisplayActionEventHandlerDesynchronized : public DisplayActionEventHandler
   {
-  public:
+  protected:
 
     /**
-    * @brief Initializes common standard display actions by using the default display action event functions.
+    * @brief Initializes common desynchronized display actions by using the desynchronized display action event functions.
     *
     * @pre    The class' observable (the display action event broadcast) has to be set to connect display events.
     * @throw  mitk::Exception, if the class' observable is null.
     */
-    void InitStdActions();
+    void InitActionsImpl() override;
   };
 } // end namespace mitk
 
-#endif // MITKSTDDISPLAYACTIONEVENTHANDLER_H
+#endif // MITKDISPLAYACTIONEVENTHANDLERDESYNCHRONIZED_H
diff --git a/Modules/Core/include/mitkStdDisplayActionEventHandler.h b/Modules/Core/include/mitkDisplayActionEventHandlerStd.h
similarity index 63%
copy from Modules/Core/include/mitkStdDisplayActionEventHandler.h
copy to Modules/Core/include/mitkDisplayActionEventHandlerStd.h
index 76758df9eb..0d351ff03f 100644
--- a/Modules/Core/include/mitkStdDisplayActionEventHandler.h
+++ b/Modules/Core/include/mitkDisplayActionEventHandlerStd.h
@@ -1,41 +1,46 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#ifndef MITKSTDDISPLAYACTIONEVENTHANDLER_H
-#define MITKSTDDISPLAYACTIONEVENTHANDLER_H
+#ifndef MITKDISPLAYACTIONEVENTHANDLERSTD_H
+#define MITKDISPLAYACTIONEVENTHANDLERSTD_H
 
 #include <MitkCoreExports.h>
 
 // mitk core
 #include "mitkDisplayActionEventHandler.h"
 
 namespace mitk
 {
-  class MITKCORE_EXPORT StdDisplayActionEventHandler : public DisplayActionEventHandler
+  class MITKCORE_EXPORT DisplayActionEventHandlerStd : public DisplayActionEventHandler
   {
-  public:
+  protected:
 
     /**
-    * @brief Initializes common standard display actions by using the default display action event functions.
+    * @brief Initializes common standard display actions by using mixed synchronized and desynchronized display action event functions.
+    *        Uses:
+    *           - 'SetCrosshairSynchronizedAction'
+    *           - 'MoveSenderCameraAction'
+    *           - 'ZoomSenderCameraAction'
+    *           - 'ScrollSliceStepperAction'
     *
     * @pre    The class' observable (the display action event broadcast) has to be set to connect display events.
     * @throw  mitk::Exception, if the class' observable is null.
     */
-    void InitStdActions();
+    void InitActionsImpl() override;
   };
 } // end namespace mitk
 
-#endif // MITKSTDDISPLAYACTIONEVENTHANDLER_H
+#endif // MITKSTDDISPLAYACTIONEVENTHANDLERSTD_H
diff --git a/Modules/Core/include/mitkStdDisplayActionEventHandler.h b/Modules/Core/include/mitkDisplayActionEventHandlerSynchronized.h
similarity index 66%
rename from Modules/Core/include/mitkStdDisplayActionEventHandler.h
rename to Modules/Core/include/mitkDisplayActionEventHandlerSynchronized.h
index 76758df9eb..9894399497 100644
--- a/Modules/Core/include/mitkStdDisplayActionEventHandler.h
+++ b/Modules/Core/include/mitkDisplayActionEventHandlerSynchronized.h
@@ -1,41 +1,41 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#ifndef MITKSTDDISPLAYACTIONEVENTHANDLER_H
-#define MITKSTDDISPLAYACTIONEVENTHANDLER_H
+#ifndef MITKDISPLAYACTIONEVENTHANDLERSYNCHRONIZED_H
+#define MITKDISPLAYACTIONEVENTHANDLERSYNCHRONIZED_H
 
 #include <MitkCoreExports.h>
 
 // mitk core
 #include "mitkDisplayActionEventHandler.h"
 
 namespace mitk
 {
-  class MITKCORE_EXPORT StdDisplayActionEventHandler : public DisplayActionEventHandler
+  class MITKCORE_EXPORT DisplayActionEventHandlerSynchronized : public DisplayActionEventHandler
   {
-  public:
+  protected:
 
     /**
-    * @brief Initializes common standard display actions by using the default display action event functions.
+    * @brief Initializes common synchronized display actions by using the synchronized display action event functions.
     *
     * @pre    The class' observable (the display action event broadcast) has to be set to connect display events.
     * @throw  mitk::Exception, if the class' observable is null.
     */
-    void InitStdActions();
+    void InitActionsImpl() override;
   };
 } // end namespace mitk
 
-#endif // MITKSTDDISPLAYACTIONEVENTHANDLER_H
+#endif // MITKDISPLAYACTIONEVENTHANDLERSYNCHRONIZED_H
diff --git a/Modules/Core/src/Interactions/mitkDisplayActionEventHandler.cpp b/Modules/Core/src/Interactions/mitkDisplayActionEventHandler.cpp
index f28c3c6a99..5f333bb1a6 100644
--- a/Modules/Core/src/Interactions/mitkDisplayActionEventHandler.cpp
+++ b/Modules/Core/src/Interactions/mitkDisplayActionEventHandler.cpp
@@ -1,75 +1,109 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkDisplayActionEventHandler.h"
 
+mitk::DisplayActionEventHandler::~DisplayActionEventHandler()
+{
+  if (!m_ObservableBroadcast.IsExpired())
+  {
+    auto observableBroadcastPtr = m_ObservableBroadcast.Lock();
+
+    // remove current observer
+    for (const auto& tag : m_ObserverTags)
+    {
+      observableBroadcastPtr->RemoveObserver(tag);
+    }
+    m_ObserverTags.clear();
+  }
+}
+
 void mitk::DisplayActionEventHandler::SetObservableBroadcast(DisplayActionEventBroadcast* observableBroadcast)
 {
   if (m_ObservableBroadcast == observableBroadcast)
   {
     // no need to update the broadcast class
     return;
   }
 
   if (!m_ObservableBroadcast.IsExpired())
   {
     auto observableBroadcastPtr = m_ObservableBroadcast.Lock();
 
     // remove current observer
     for (const auto& tag : m_ObserverTags)
     {
       observableBroadcastPtr->RemoveObserver(tag);
     }
     m_ObserverTags.clear();
   }
 
   // set new broadcast class
   m_ObservableBroadcast = observableBroadcast;
 }
 
 mitk::DisplayActionEventHandler::OberserverTagType mitk::DisplayActionEventHandler::ConnectDisplayActionEvent(const DisplayActionEvent& displayActionEvent,
   const StdFunctionCommand::ActionFunction& actionFunction,
   const StdFunctionCommand::FilterFunction& filterFunction)
 {
   if (m_ObservableBroadcast.IsExpired())
   {
     mitkThrow() << "No display action event broadcast class set to observe. Use 'SetObservableBroadcast' before connecting events.";
   }
 
   auto observableBroadcast = m_ObservableBroadcast.Lock();
   auto command = StdFunctionCommand::New();
   command->SetCommandAction(actionFunction);
   command->SetCommandFilter(filterFunction);
   OberserverTagType tag = observableBroadcast->AddObserver(displayActionEvent, command);
   m_ObserverTags.push_back(tag);
   return tag;
 }
 
 void mitk::DisplayActionEventHandler::DisconnectObserver(OberserverTagType observerTag)
 {
   if (m_ObservableBroadcast.IsExpired())
   {
     mitkThrow() << "No display action event broadcast class set to observe. Use 'SetObservableBroadcast' before disconnecting observer.";
   }
 
   auto observableBroadcast = m_ObservableBroadcast.Lock();
   std::vector<OberserverTagType>::iterator observerTagPosition = std::find(m_ObserverTags.begin(), m_ObserverTags.end(), observerTag);
   if (observerTagPosition != m_ObserverTags.end())
   {
     observableBroadcast->RemoveObserver(observerTag);
     m_ObserverTags.erase(observerTagPosition);
   }
 }
+
+void mitk::DisplayActionEventHandler::InitActions()
+{
+  if (m_ObservableBroadcast.IsExpired())
+  {
+    mitkThrow() << "No display action event broadcast class set to observe. Use 'SetObservableBroadcast' before initializing actions.";
+  }
+
+  auto observableBroadcast = m_ObservableBroadcast.Lock();
+  // remove all current display action events as observer
+  auto allObserverTags = GetAllObserverTags();
+  for (const auto& tag : allObserverTags)
+  {
+    observableBroadcast->RemoveObserver(tag);
+  }
+  m_ObserverTags.clear();
+
+  InitActionsImpl();
+}
diff --git a/Modules/Core/src/Interactions/mitkStdDisplayActionEventHandler.cpp b/Modules/Core/src/Interactions/mitkDisplayActionEventHandlerDesynchronized.cpp
similarity index 78%
copy from Modules/Core/src/Interactions/mitkStdDisplayActionEventHandler.cpp
copy to Modules/Core/src/Interactions/mitkDisplayActionEventHandlerDesynchronized.cpp
index 95bae2ae2a..27a78e9cdb 100644
--- a/Modules/Core/src/Interactions/mitkStdDisplayActionEventHandler.cpp
+++ b/Modules/Core/src/Interactions/mitkDisplayActionEventHandlerDesynchronized.cpp
@@ -1,45 +1,41 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#include "mitkStdDisplayActionEventHandler.h"
+#include "mitkDisplayActionEventHandlerDesynchronized.h"
 
 // mitk core
 #include "mitkDisplayActionEventFunctions.h"
 
 // itk
 #include <itkEventObject.h>
 
-void mitk::StdDisplayActionEventHandler::InitStdActions()
+void mitk::DisplayActionEventHandlerDesynchronized::InitActionsImpl()
 {
-  if (m_ObservableBroadcast.IsExpired())
-  {
-    mitkThrow() << "No display action event broadcast class set to observe. Use 'SetObservableBroadcast' before initializing actions.";
-  }
-
-  auto observableBroadcast = m_ObservableBroadcast.Lock();
-
   StdFunctionCommand::ActionFunction actionFunction = DisplayActionEventFunctions::MoveSenderCameraAction();
   ConnectDisplayActionEvent(DisplayMoveEvent(nullptr, Vector2D()), actionFunction);
 
   actionFunction = DisplayActionEventFunctions::SetCrosshairAction();
   ConnectDisplayActionEvent(DisplaySetCrosshairEvent(nullptr, Point3D()), actionFunction);
 
   actionFunction = DisplayActionEventFunctions::ZoomSenderCameraAction();
   ConnectDisplayActionEvent(DisplayZoomEvent(nullptr, 0.0, Point2D()), actionFunction);
 
   actionFunction = DisplayActionEventFunctions::ScrollSliceStepperAction();
   ConnectDisplayActionEvent(DisplayScrollEvent(nullptr, 0), actionFunction);
+
+  actionFunction = mitk::DisplayActionEventFunctions::SetLevelWindowAction();
+  ConnectDisplayActionEvent(mitk::DisplaySetLevelWindowEvent(nullptr, mitk::ScalarType(), mitk::ScalarType()), actionFunction);
 }
diff --git a/Modules/Core/src/Interactions/mitkStdDisplayActionEventHandler.cpp b/Modules/Core/src/Interactions/mitkDisplayActionEventHandlerStd.cpp
similarity index 65%
copy from Modules/Core/src/Interactions/mitkStdDisplayActionEventHandler.cpp
copy to Modules/Core/src/Interactions/mitkDisplayActionEventHandlerStd.cpp
index 95bae2ae2a..649cc7286d 100644
--- a/Modules/Core/src/Interactions/mitkStdDisplayActionEventHandler.cpp
+++ b/Modules/Core/src/Interactions/mitkDisplayActionEventHandlerStd.cpp
@@ -1,45 +1,45 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#include "mitkStdDisplayActionEventHandler.h"
+#include "mitkDisplayActionEventHandlerStd.h"
 
 // mitk core
 #include "mitkDisplayActionEventFunctions.h"
 
 // itk
 #include <itkEventObject.h>
 
-void mitk::StdDisplayActionEventHandler::InitStdActions()
+void mitk::DisplayActionEventHandlerStd::InitActionsImpl()
 {
-  if (m_ObservableBroadcast.IsExpired())
-  {
-    mitkThrow() << "No display action event broadcast class set to observe. Use 'SetObservableBroadcast' before initializing actions.";
-  }
-
-  auto observableBroadcast = m_ObservableBroadcast.Lock();
+  // synchronized action event function
+  StdFunctionCommand::ActionFunction actionFunction = DisplayActionEventFunctions::SetCrosshairSynchronizedAction();
+  ConnectDisplayActionEvent(DisplaySetCrosshairEvent(nullptr, Point3D()), actionFunction);
 
-  StdFunctionCommand::ActionFunction actionFunction = DisplayActionEventFunctions::MoveSenderCameraAction();
+  // desynchronized action event function
+  actionFunction = DisplayActionEventFunctions::MoveSenderCameraAction();
   ConnectDisplayActionEvent(DisplayMoveEvent(nullptr, Vector2D()), actionFunction);
 
-  actionFunction = DisplayActionEventFunctions::SetCrosshairAction();
-  ConnectDisplayActionEvent(DisplaySetCrosshairEvent(nullptr, Point3D()), actionFunction);
-
+  // desynchronized action event function
   actionFunction = DisplayActionEventFunctions::ZoomSenderCameraAction();
   ConnectDisplayActionEvent(DisplayZoomEvent(nullptr, 0.0, Point2D()), actionFunction);
 
+  // desynchronized action event function
   actionFunction = DisplayActionEventFunctions::ScrollSliceStepperAction();
   ConnectDisplayActionEvent(DisplayScrollEvent(nullptr, 0), actionFunction);
+
+  actionFunction = mitk::DisplayActionEventFunctions::SetLevelWindowAction();
+  ConnectDisplayActionEvent(mitk::DisplaySetLevelWindowEvent(nullptr, mitk::ScalarType(), mitk::ScalarType()), actionFunction);
 }
diff --git a/Modules/Core/src/Interactions/mitkStdDisplayActionEventHandler.cpp b/Modules/Core/src/Interactions/mitkDisplayActionEventHandlerSynchronized.cpp
similarity index 65%
rename from Modules/Core/src/Interactions/mitkStdDisplayActionEventHandler.cpp
rename to Modules/Core/src/Interactions/mitkDisplayActionEventHandlerSynchronized.cpp
index 95bae2ae2a..b18c6c85e0 100644
--- a/Modules/Core/src/Interactions/mitkStdDisplayActionEventHandler.cpp
+++ b/Modules/Core/src/Interactions/mitkDisplayActionEventHandlerSynchronized.cpp
@@ -1,45 +1,41 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#include "mitkStdDisplayActionEventHandler.h"
+#include "mitkDisplayActionEventHandlerSynchronized.h"
 
 // mitk core
 #include "mitkDisplayActionEventFunctions.h"
 
 // itk
 #include <itkEventObject.h>
 
-void mitk::StdDisplayActionEventHandler::InitStdActions()
+void mitk::DisplayActionEventHandlerSynchronized::InitActionsImpl()
 {
-  if (m_ObservableBroadcast.IsExpired())
-  {
-    mitkThrow() << "No display action event broadcast class set to observe. Use 'SetObservableBroadcast' before initializing actions.";
-  }
-
-  auto observableBroadcast = m_ObservableBroadcast.Lock();
-
-  StdFunctionCommand::ActionFunction actionFunction = DisplayActionEventFunctions::MoveSenderCameraAction();
+  StdFunctionCommand::ActionFunction actionFunction = DisplayActionEventFunctions::MoveCameraSynchronizedAction();
   ConnectDisplayActionEvent(DisplayMoveEvent(nullptr, Vector2D()), actionFunction);
 
-  actionFunction = DisplayActionEventFunctions::SetCrosshairAction();
+  actionFunction = DisplayActionEventFunctions::SetCrosshairSynchronizedAction();
   ConnectDisplayActionEvent(DisplaySetCrosshairEvent(nullptr, Point3D()), actionFunction);
 
-  actionFunction = DisplayActionEventFunctions::ZoomSenderCameraAction();
+  actionFunction = DisplayActionEventFunctions::ZoomCameraSynchronizedAction();
   ConnectDisplayActionEvent(DisplayZoomEvent(nullptr, 0.0, Point2D()), actionFunction);
 
-  actionFunction = DisplayActionEventFunctions::ScrollSliceStepperAction();
+  actionFunction = DisplayActionEventFunctions::ScrollSliceStepperSynchronizedAction();
   ConnectDisplayActionEvent(DisplayScrollEvent(nullptr, 0), actionFunction);
+
+  actionFunction = mitk::DisplayActionEventFunctions::SetLevelWindowAction();
+  ConnectDisplayActionEvent(mitk::DisplaySetLevelWindowEvent(nullptr, mitk::ScalarType(), mitk::ScalarType()), actionFunction);
 }
diff --git a/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h b/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
index afe4f0af85..299eeaff85 100644
--- a/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
@@ -1,167 +1,165 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QMITKABSTRACTMULTIWIDGET_H
 #define QMITKABSTRACTMULTIWIDGET_H
 
 // mitk qt widgets module
 #include "MitkQtWidgetsExports.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
+#include <mitkDisplayActionEventHandler.h>
 #include <mitkInteractionSchemeSwitcher.h>
 #include <mitkPoint.h>
 
 // qt
 #include <QWidget>
 
 // c++
 #include <map>
 #include <memory>
 
 class QmitkMultiWidgetLayoutManager;
 class QmitkRenderWindow;
 class QmitkRenderWindowWidget;
 
 namespace mitk
 {
   class DataStorage;
   class InteractionEventHandler;
   class RenderingManager;
 }
 
 /**
 * @brief The 'QmitkAbstractMultiWidget' is a 'QWidget' that can be subclassed to display multiple render windows at once.
 *        Render windows can dynamically be added and removed to change the layout of the multi widget.
 *        A subclass of this multi widget can be used inside a 'QmitkAbstractMultiWidgetEditor'.
 *
 *        The class uses the 'DisplayActionEventBroadcast' and 'DisplayActionEventHandler' classes to
 *        load a state machine and set an event configuration.
 *
 *        Using the 'Synchronize' function the user can enable or disable the synchronization of display action events.
 *        See 'DisplayActionEventFunctions'-class for the different synchronized and non-synchronized functions used.
 */
 class MITKQTWIDGETS_EXPORT QmitkAbstractMultiWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
   using RenderWindowWidgetPointer = std::shared_ptr<QmitkRenderWindowWidget>;
   using RenderWindowWidgetMap = std::map<QString, std::shared_ptr<QmitkRenderWindowWidget>>;
   using RenderWindowHash = QHash<QString, QmitkRenderWindow*>;
   using ViewDirection = mitk::BaseRenderer::ViewDirection;
 
   QmitkAbstractMultiWidget(QWidget* parent = 0,
                            Qt::WindowFlags f = 0,
                            mitk::RenderingManager* renderingManager = nullptr,
                            mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::FastApproximateAntiAliasing,
                            const QString& multiWidgetName = "multiwidget");
 
   virtual ~QmitkAbstractMultiWidget();
   
   virtual void InitializeMultiWidget() = 0;
   virtual void MultiWidgetOpened() { }
   virtual void MultiWidgetClosed() { }
 
   virtual void SetDataStorage(mitk::DataStorage* dataStorage);
   mitk::DataStorage* GetDataStorage() const;
 
   mitk::RenderingManager* GetRenderingManager() const;
 
   int GetRowCount() const;
   int GetColumnCount() const;
   virtual void SetLayout(int row, int column);
 
-  virtual void Synchronize(bool synchronized);
+  virtual void Synchronize(bool synchronized) { };
   virtual void SetInteractionScheme(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
 
   mitk::InteractionEventHandler* GetInteractionEventHandler();
+  void SetDisplayActionEventHandler(std::unique_ptr<mitk::DisplayActionEventHandler> displayActionEventHandler);
+  mitk::DisplayActionEventHandler* GetDisplayActionEventHandler();
 
   RenderWindowWidgetMap GetRenderWindowWidgets() const;
   RenderWindowWidgetMap Get2DRenderWindowWidgets() const;
   RenderWindowWidgetMap Get3DRenderWindowWidgets() const;
   RenderWindowWidgetPointer GetRenderWindowWidget(int row, int column) const;
   RenderWindowWidgetPointer GetRenderWindowWidget(const QString& widgetName) const;
   RenderWindowWidgetPointer GetRenderWindowWidget(const QmitkRenderWindow* renderWindow) const;
   RenderWindowHash GetRenderWindows() const;
   QmitkRenderWindow* GetRenderWindow(int row, int column) const;
   virtual QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const;
   virtual QmitkRenderWindow* GetRenderWindow(const ViewDirection& viewDirection) const = 0;
 
   virtual void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget);
   RenderWindowWidgetPointer GetActiveRenderWindowWidget() const;
   RenderWindowWidgetPointer GetFirstRenderWindowWidget() const;
   RenderWindowWidgetPointer GetLastRenderWindowWidget() const;
   
   virtual QString GetNameFromIndex(int row, int column) const;
   virtual QString GetNameFromIndex(size_t index) const;
 
   unsigned int GetNumberOfRenderWindowWidgets() const;
 
   void RequestUpdate(const QString& widgetName);
   void RequestUpdateAll();
   void ForceImmediateUpdate(const QString& widgetName);
   void ForceImmediateUpdateAll();
 
   virtual void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) = 0;
   virtual const mitk::Point3D GetSelectedPosition(const QString& widgetName) const = 0;
 
   virtual void SetCrosshairVisibility(bool visible) = 0;
   virtual bool GetCrosshairVisibility() const = 0;
 
   virtual void ResetCrosshair() = 0;
 
   virtual void SetWidgetPlaneMode(int mode) = 0;
 
   virtual void ActivateMenuWidget(bool state);
   virtual bool IsMenuWidgetEnabled() const;
 
   QmitkMultiWidgetLayoutManager* GetMultiWidgetLayoutManager() const;
 
 Q_SIGNALS:
 
   void ActiveRenderWindowChanged();
 
 protected:
 
   virtual void AddRenderWindowWidget(const QString& widgetName, RenderWindowWidgetPointer renderWindowWidget);
   virtual void RemoveRenderWindowWidget();
 
 private:
 
   /**
   * @brief This function will be called by the function 'SetLayout' and
   *        can be implemented and customized in the subclasses.
   */
   virtual void SetLayoutImpl() = 0;
   /**
-  * @brief This function will be called by the function 'Synchronize' and
-  *        can be implemented and customized in the subclasses.
-  */
-  virtual void SynchronizeImpl() = 0;
-  /**
   * @brief This function will be called by the function 'SetInteractionScheme' and
   *        can be implemented and customized in the subclasses.
   */
   virtual void SetInteractionSchemeImpl() = 0;
 
   struct Impl;
   std::unique_ptr<Impl> m_Impl;
 
 };
 
 #endif // QMITKABSTRACTMULTIWIDGET_H
diff --git a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
index 23292859c5..1d2fca537a 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,87 +1,88 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QMITKMXNMULTIWIDGET_H
 #define QMITKMXNMULTIWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkAbstractMultiWidget.h"
 
 /**
 * @brief The 'QmitkMxNMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
 *        Render windows can dynamically be added and removed to change the layout of the multi widget. This
 *        is done by using the 'SetLayout'-function to define a layout. This will automatically add or remove
 *        the appropriate number of render window widgets.
 */
 class MITKQTWIDGETS_EXPORT QmitkMxNMultiWidget : public QmitkAbstractMultiWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkMxNMultiWidget(QWidget* parent = nullptr,
                       Qt::WindowFlags f = 0,
                       mitk::RenderingManager* renderingManager = nullptr,
                       mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::FastApproximateAntiAliasing,
                       const QString& multiWidgetName = "mxnmulti");
 
   ~QmitkMxNMultiWidget() = default;
 
   void InitializeMultiWidget() override;
   void MultiWidgetOpened() override;
   void MultiWidgetClosed() override;
 
+  void Synchronize(bool synchronized) override;
+
   QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
   QmitkRenderWindow* GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const override;
 
   void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget) override;
 
   void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
   const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
 
   void SetCrosshairVisibility(bool activate) override;
   bool GetCrosshairVisibility() const override { return m_CrosshairVisibility; }
 
   void ResetCrosshair() override;
 
   void SetWidgetPlaneMode(int userMode) override;
 
 public Q_SLOTS:
 
   // mouse events
   void wheelEvent(QWheelEvent* e) override;
   void mousePressEvent(QMouseEvent* e) override;
   void moveEvent(QMoveEvent* e) override;
 
 Q_SIGNALS:
 
   void WheelMoved(QWheelEvent *);
   void Moved();
 
 private:
 
   void SetLayoutImpl() override;
-  void SynchronizeImpl() override { }
   void SetInteractionSchemeImpl() override { }
 
   void CreateRenderWindowWidget();
 
   bool m_CrosshairVisibility;
 
 };
 
 #endif // QMITKMXNMULTIWIDGET_H
diff --git a/Modules/QtWidgets/include/QmitkStdMultiWidget.h b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
index 23b7b295ee..56eec67d28 100644
--- a/Modules/QtWidgets/include/QmitkStdMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
@@ -1,165 +1,164 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef 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,
     mitk::RenderingManager *renderingManager = nullptr,
     mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::FastApproximateAntiAliasing,
     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;
 
   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 WheelMoved(QWheelEvent *);
   void Moved();
 
 private:
 
   virtual void SetLayoutImpl() override;
-  virtual void SynchronizeImpl() 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/QmitkAbstractMultiWidget.cpp b/Modules/QtWidgets/src/QmitkAbstractMultiWidget.cpp
index 440c982c9b..1619d91ff7 100644
--- a/Modules/QtWidgets/src/QmitkAbstractMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkAbstractMultiWidget.cpp
@@ -1,455 +1,410 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // mitk qt widgets module
 #include "QmitkAbstractMultiWidget.h"
 #include "QmitkLevelWindowWidget.h"
 #include "QmitkMultiWidgetLayoutManager.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkDataStorage.h>
-#include <mitkDisplayActionEvents.h>
 #include <mitkDisplayActionEventBroadcast.h>
-#include <mitkDisplayActionEventFunctions.h>
-#include <mitkDisplayActionEventHandler.h>
 
 // qt
 #include <QMouseEvent>
 
 // c++
 #include <iomanip>
 
 struct QmitkAbstractMultiWidget::Impl final
 {
   Impl(QmitkAbstractMultiWidget* multiWidget,
        mitk::RenderingManager* renderingManager,
        mitk::BaseRenderer::RenderingMode::Type renderingMode,
        const QString& multiWidgetName);
 
   void SetDataStorage(mitk::DataStorage* dataStorage)
   {
     if (dataStorage == m_DataStorage)
     {
       return;
     }
 
     m_DataStorage = dataStorage;
     // set new data storage for the render window widgets
     for (const auto& renderWindowWidget : m_RenderWindowWidgets)
     {
       renderWindowWidget.second->SetDataStorage(m_DataStorage);
     }
   }
 
-  void Synchronize(bool synchronized)
-  {
-    auto allObserverTags = m_DisplayActionEventHandler->GetAllObserverTags();
-    for (auto observerTag : allObserverTags)
-    {
-      m_DisplayActionEventHandler->DisconnectObserver(observerTag);
-    }
-
-    if (synchronized)
-    {
-      mitk::StdFunctionCommand::ActionFunction actionFunction = mitk::DisplayActionEventFunctions::MoveCameraSynchronizedAction();
-      m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayMoveEvent(nullptr, mitk::Vector2D()), actionFunction);
-
-      actionFunction = mitk::DisplayActionEventFunctions::SetCrosshairSynchronizedAction();
-      m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplaySetCrosshairEvent(nullptr, mitk::Point3D()), actionFunction);
-
-      actionFunction = mitk::DisplayActionEventFunctions::ZoomCameraSynchronizedAction();
-      m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayZoomEvent(nullptr, 0.0, mitk::Point2D()), actionFunction);
-
-      actionFunction = mitk::DisplayActionEventFunctions::ScrollSliceStepperSynchronizedAction();
-      m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayScrollEvent(nullptr, 0), actionFunction);
-    }
-    else
-    {
-      mitk::StdFunctionCommand::ActionFunction actionFunction = mitk::DisplayActionEventFunctions::MoveSenderCameraAction();
-      m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayMoveEvent(nullptr, mitk::Vector2D()), actionFunction);
-
-      actionFunction = mitk::DisplayActionEventFunctions::SetCrosshairAction();
-      m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplaySetCrosshairEvent(nullptr, mitk::Point3D()), actionFunction);
-
-      actionFunction = mitk::DisplayActionEventFunctions::ZoomSenderCameraAction();
-      m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayZoomEvent(nullptr, 0.0, mitk::Point2D()), actionFunction);
-
-      actionFunction = mitk::DisplayActionEventFunctions::ScrollSliceStepperAction();
-      m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayScrollEvent(nullptr, 0), actionFunction);
-    }
-
-    // use the standard 'set level window' action for both modes
-    mitk::StdFunctionCommand::ActionFunction actionFunction = mitk::DisplayActionEventFunctions::SetLevelWindowAction();
-    m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplaySetLevelWindowEvent(nullptr, mitk::ScalarType(), mitk::ScalarType()), actionFunction);
-  }
-
   void InitializeDisplayActionEventHandling()
   {
     m_DisplayActionEventBroadcast = mitk::DisplayActionEventBroadcast::New();
     m_DisplayActionEventBroadcast->LoadStateMachine("DisplayInteraction.xml");
     m_DisplayActionEventBroadcast->SetEventConfig("DisplayConfigPACS.xml");
-
-    m_DisplayActionEventHandler = std::make_unique<mitk::DisplayActionEventHandler>();
-    m_DisplayActionEventHandler->SetObservableBroadcast(m_DisplayActionEventBroadcast);
-
-    Synchronize(true);
   }
   
   mitk::DataStorage::Pointer m_DataStorage;
 
   mitk::RenderingManager* m_RenderingManager;
   mitk::BaseRenderer::RenderingMode::Type m_RenderingMode;
   QString m_MultiWidgetName;
 
   RenderWindowWidgetMap m_RenderWindowWidgets;
   RenderWindowWidgetPointer m_ActiveRenderWindowWidget;
 
   int m_MultiWidgetRows;
   int m_MultiWidgetColumns;
 
   // interaction
   mitk::DisplayActionEventBroadcast::Pointer m_DisplayActionEventBroadcast;
   std::unique_ptr<mitk::DisplayActionEventHandler> m_DisplayActionEventHandler;
   QmitkMultiWidgetLayoutManager* m_LayoutManager;
 };
 
 QmitkAbstractMultiWidget::Impl::Impl(QmitkAbstractMultiWidget* multiWidget,
                                      mitk::RenderingManager* renderingManager,
                                      mitk::BaseRenderer::RenderingMode::Type renderingMode,
                                      const QString& multiWidgetName)
   : m_DataStorage(nullptr)
   , m_RenderingManager(renderingManager)
   , m_RenderingMode(renderingMode)
   , m_MultiWidgetName(multiWidgetName)
   , m_MultiWidgetRows(0)
   , m_MultiWidgetColumns(0)
   , m_DisplayActionEventBroadcast(nullptr)
   , m_DisplayActionEventHandler(nullptr)
   , m_LayoutManager(new QmitkMultiWidgetLayoutManager(multiWidget))
 {
   InitializeDisplayActionEventHandling();
 }
 
 QmitkAbstractMultiWidget::QmitkAbstractMultiWidget(QWidget* parent,
                                                    Qt::WindowFlags f/* = 0*/,
                                                    mitk::RenderingManager* renderingManager/* = nullptr*/,
                                                    mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::FastApproximateAntiAliasing*/,
                                                    const QString& multiWidgetName/* = "multiwidget"*/)
   : QWidget(parent, f)
   , m_Impl(std::make_unique<Impl>(this, renderingManager, renderingMode, multiWidgetName))
 {
   // nothing here
 }
 
 QmitkAbstractMultiWidget::~QmitkAbstractMultiWidget() { }
 
 void QmitkAbstractMultiWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   m_Impl->SetDataStorage(dataStorage);
 }
 
 mitk::DataStorage* QmitkAbstractMultiWidget::GetDataStorage() const
 {
   return m_Impl->m_DataStorage;
 }
 
 mitk::RenderingManager* QmitkAbstractMultiWidget::GetRenderingManager() const
 {
   // use the global rendering manager if none was specified
   if (m_Impl->m_RenderingManager == nullptr)
   {
     return mitk::RenderingManager::GetInstance();
   }
 
   return m_Impl->m_RenderingManager;
 }
 
 int QmitkAbstractMultiWidget::GetRowCount() const
 {
   return m_Impl->m_MultiWidgetRows;
 }
 
 int QmitkAbstractMultiWidget::GetColumnCount() const
 {
   return m_Impl->m_MultiWidgetColumns;
 }
 
 void QmitkAbstractMultiWidget::SetLayout(int row, int column)
 {
   m_Impl->m_MultiWidgetRows = row;
   m_Impl->m_MultiWidgetColumns = column;
   SetLayoutImpl();
 }
 
-void QmitkAbstractMultiWidget::Synchronize(bool synchronized)
-{
-  m_Impl->Synchronize(synchronized);
-  SynchronizeImpl();
-}
-
 void QmitkAbstractMultiWidget::SetInteractionScheme(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
 {
   auto interactionSchemeSwitcher = mitk::InteractionSchemeSwitcher::New();
   auto interactionEventHandler = GetInteractionEventHandler();
   try
   {
     interactionSchemeSwitcher->SetInteractionScheme(interactionEventHandler, scheme);
   }
   catch (const mitk::Exception&)
   {
     return;
   }
 
   SetInteractionSchemeImpl();
 }
 
 mitk::InteractionEventHandler* QmitkAbstractMultiWidget::GetInteractionEventHandler()
 {
   return m_Impl->m_DisplayActionEventBroadcast.GetPointer();
 }
 
+void QmitkAbstractMultiWidget::SetDisplayActionEventHandler(std::unique_ptr<mitk::DisplayActionEventHandler> displayActionEventHandler)
+{
+  m_Impl->m_DisplayActionEventHandler = std::move(displayActionEventHandler);
+  m_Impl->m_DisplayActionEventHandler->SetObservableBroadcast(m_Impl->m_DisplayActionEventBroadcast);
+}
+
+mitk::DisplayActionEventHandler* QmitkAbstractMultiWidget::GetDisplayActionEventHandler()
+{
+  return m_Impl->m_DisplayActionEventHandler.get();
+}
+
 QmitkAbstractMultiWidget::RenderWindowWidgetMap QmitkAbstractMultiWidget::GetRenderWindowWidgets() const
 {
   return m_Impl->m_RenderWindowWidgets;
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetMap QmitkAbstractMultiWidget::Get2DRenderWindowWidgets() const
 {
   RenderWindowWidgetMap renderWindowWidgets2D;
 
   auto renderWindowWidgets = GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     auto renderWindow = renderWindowWidget.second->GetRenderWindow();
     if(mitk::BaseRenderer::Standard2D == mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow())->GetMapperID())
     {
       renderWindowWidgets2D.insert(std::make_pair(renderWindowWidget.first, renderWindowWidget.second));
     }
   }
 
   return renderWindowWidgets2D;
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetMap QmitkAbstractMultiWidget::Get3DRenderWindowWidgets() const
 {
   RenderWindowWidgetMap renderWindowWidgets3D;
 
   auto renderWindowWidgets = GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     auto renderWindow = renderWindowWidget.second->GetRenderWindow();
     if (mitk::BaseRenderer::Standard3D == mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow())->GetMapperID())
     {
       renderWindowWidgets3D.insert(std::make_pair(renderWindowWidget.first, renderWindowWidget.second));
     }
   }
 
   return renderWindowWidgets3D;
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetRenderWindowWidget(int row, int column) const
 {
   return GetRenderWindowWidget(GetNameFromIndex(row, column));
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetRenderWindowWidget(const QString& widgetName) const
 {
   RenderWindowWidgetMap::const_iterator it = m_Impl->m_RenderWindowWidgets.find(widgetName);
   if (it != m_Impl->m_RenderWindowWidgets.end())
   {
     return it->second;
   }
 
   return nullptr;
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetRenderWindowWidget(const QmitkRenderWindow* renderWindow) const
 {
   auto renderWindowWidgets = GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     if (renderWindowWidget.second->GetRenderWindow() == renderWindow)
     {
       return renderWindowWidget.second;
     }
   }
 
   return nullptr;
 }
 
 QmitkAbstractMultiWidget::RenderWindowHash QmitkAbstractMultiWidget::GetRenderWindows() const
 {
   RenderWindowHash result;
   // create QHash on demand
   auto renderWindowWidgets = GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     result.insert(renderWindowWidget.first, renderWindowWidget.second->GetRenderWindow());
   }
 
   return result;
 }
 
 QmitkRenderWindow* QmitkAbstractMultiWidget::GetRenderWindow(int row, int column) const
 {
   return GetRenderWindow(GetNameFromIndex(row, column));
 }
 
 QmitkRenderWindow* QmitkAbstractMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->GetRenderWindow();
   }
 
   return nullptr;
 }
 
 void QmitkAbstractMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
 {
   m_Impl->m_ActiveRenderWindowWidget = activeRenderWindowWidget;
   emit ActiveRenderWindowChanged();
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetActiveRenderWindowWidget() const
 {
   return m_Impl->m_ActiveRenderWindowWidget;
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetFirstRenderWindowWidget() const
 {
   if (!m_Impl->m_RenderWindowWidgets.empty())
   {
     return m_Impl->m_RenderWindowWidgets.begin()->second;
   }
   else
   {
     return nullptr;
   }
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetLastRenderWindowWidget() const
 {
   if (!m_Impl->m_RenderWindowWidgets.empty())
   {
     return m_Impl->m_RenderWindowWidgets.rbegin()->second;
   }
   else
   {
     return nullptr;
   }
 }
 
 QString QmitkAbstractMultiWidget::GetNameFromIndex(int row, int column) const
 {
   if (0 <= row && m_Impl->m_MultiWidgetRows > row && 0 <= column && m_Impl->m_MultiWidgetColumns > column)
   {
     return GetNameFromIndex(row * m_Impl->m_MultiWidgetColumns + column);
   }
 
   return QString();
 }
 
 QString QmitkAbstractMultiWidget::GetNameFromIndex(size_t index) const
 {
   if (index <= m_Impl->m_RenderWindowWidgets.size())
   {
     return m_Impl->m_MultiWidgetName + ".widget" + QString::number(index);
   }
 
   return QString();
 }
 
 unsigned int QmitkAbstractMultiWidget::GetNumberOfRenderWindowWidgets() const
 {
   return m_Impl->m_RenderWindowWidgets.size();
 }
 
 void QmitkAbstractMultiWidget::RequestUpdate(const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->RequestUpdate();
   }
 }
 
 void QmitkAbstractMultiWidget::RequestUpdateAll()
 {
   for (const auto& renderWindowWidget : m_Impl->m_RenderWindowWidgets)
   {
     renderWindowWidget.second->RequestUpdate();
   }
 }
 
 void QmitkAbstractMultiWidget::ForceImmediateUpdate(const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->ForceImmediateUpdate();
   }
 }
 
 void QmitkAbstractMultiWidget::ForceImmediateUpdateAll()
 {
   for (const auto& renderWindowWidget : m_Impl->m_RenderWindowWidgets)
   {
     renderWindowWidget.second->ForceImmediateUpdate();
   }
 }
 
 void QmitkAbstractMultiWidget::ActivateMenuWidget(bool state)
 {
   for (const auto& renderWindowWidget : m_Impl->m_RenderWindowWidgets)
   {
     auto renderWindow = renderWindowWidget.second->GetRenderWindow();
     renderWindow->ActivateMenuWidget(state);
   }
 }
 
 bool QmitkAbstractMultiWidget::IsMenuWidgetEnabled() const
 {
   return m_Impl->m_ActiveRenderWindowWidget->GetRenderWindow()->GetActivateMenuWidgetFlag();
 }
 
 QmitkMultiWidgetLayoutManager* QmitkAbstractMultiWidget::GetMultiWidgetLayoutManager() const
 {
   return m_Impl->m_LayoutManager;
 }
 
 void QmitkAbstractMultiWidget::AddRenderWindowWidget(const QString& widgetName, RenderWindowWidgetPointer renderWindowWidget)
 {
   m_Impl->m_RenderWindowWidgets.insert(std::make_pair(widgetName, renderWindowWidget));
 }
 
 void QmitkAbstractMultiWidget::RemoveRenderWindowWidget()
 {
   auto iterator = m_Impl->m_RenderWindowWidgets.find(GetNameFromIndex(GetRenderWindowWidgets().size() - 1));
   if (iterator == m_Impl->m_RenderWindowWidgets.end())
   {
     return;
   }
 
   // disconnect each signal of this render window widget
   RenderWindowWidgetPointer renderWindowWidgetToRemove = iterator->second;
   disconnect(renderWindowWidgetToRemove.get(), 0, 0, 0);
 
   // erase the render window from the map
   m_Impl->m_RenderWindowWidgets.erase(iterator);
 }
diff --git a/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp b/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
index 532fac175c..ad913b5f70 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
@@ -1,113 +1,113 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkMultiWidgetConfigurationToolBar.h"
 
 // mitk qt widgets module
 #include "QmitkAbstractMultiWidget.h"
 #include "QmitkMultiWidgetLayoutSelectionWidget.h"
 
 QmitkMultiWidgetConfigurationToolBar::QmitkMultiWidgetConfigurationToolBar(QmitkAbstractMultiWidget* multiWidget)
   : QToolBar(multiWidget)
   , m_MultiWidget(multiWidget)
 {
   QToolBar::setOrientation(Qt::Vertical);
   QToolBar::setIconSize(QSize(17, 17));
 
   InitializeToolBar();
 }
 
 QmitkMultiWidgetConfigurationToolBar::~QmitkMultiWidgetConfigurationToolBar()
 {
   // nothing here
 }
 
 void QmitkMultiWidgetConfigurationToolBar::InitializeToolBar()
 {
   // create popup to show a widget to modify the multi widget layout
   m_LayoutSelectionPopup = new QmitkMultiWidgetLayoutSelectionWidget(this);
   m_LayoutSelectionPopup->hide();
 
   AddButtons();
 
   connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::LayoutSet, this, &QmitkMultiWidgetConfigurationToolBar::LayoutSet);
 }
 
 void QmitkMultiWidgetConfigurationToolBar::AddButtons()
 {
   QAction* setLayoutAction = new QAction(QIcon(":/Qmitk/mwLayout.png"), tr("Set multi widget layout"), this);
   connect(setLayoutAction, &QAction::triggered, this, &QmitkMultiWidgetConfigurationToolBar::OnSetLayout);
   QToolBar::addAction(setLayoutAction);
 
-  m_SynchronizeAction = new QAction(QIcon(":/Qmitk/mwSynchronized.png"), tr("Desynchronize render windows"), this);
+  m_SynchronizeAction = new QAction(QIcon(":/Qmitk/mwDesynchronized.png"), tr("Synchronize render windows"), this);
   m_SynchronizeAction->setCheckable(true);
-  m_SynchronizeAction->setChecked(true);
+  m_SynchronizeAction->setChecked(false);
   connect(m_SynchronizeAction, &QAction::triggered, this, &QmitkMultiWidgetConfigurationToolBar::OnSynchronize);
   QToolBar::addAction(m_SynchronizeAction);
 
   m_InteractionSchemeChangeAction = new QAction(QIcon(":/Qmitk/mwMITK.png"), tr("Change to PACS interaction"), this);
   m_InteractionSchemeChangeAction->setCheckable(true);
   m_InteractionSchemeChangeAction->setChecked(false);
   connect(m_InteractionSchemeChangeAction, &QAction::triggered, this, &QmitkMultiWidgetConfigurationToolBar::OnInteractionSchemeChanged);
   QToolBar::addAction(m_InteractionSchemeChangeAction);
 }
 
 void QmitkMultiWidgetConfigurationToolBar::OnSetLayout()
 {
   if (nullptr != m_MultiWidget)
   {
     m_LayoutSelectionPopup->setWindowFlags(Qt::Popup);
     m_LayoutSelectionPopup->move(this->cursor().pos().x() - m_LayoutSelectionPopup->width(), this->cursor().pos().y());
     m_LayoutSelectionPopup->show();
   }
 }
 
 void QmitkMultiWidgetConfigurationToolBar::OnSynchronize()
 {
   bool synchronized = m_SynchronizeAction->isChecked();
   if (synchronized)
   {
     m_SynchronizeAction->setIcon(QIcon(":/Qmitk/mwSynchronized.png"));
     m_SynchronizeAction->setText(tr("Desynchronize render windows"));
   }
   else
   {
     m_SynchronizeAction->setIcon(QIcon(":/Qmitk/mwDesynchronized.png"));
     m_SynchronizeAction->setText(tr("Synchronize render windows"));
   }
 
   m_SynchronizeAction->setChecked(synchronized);
   emit Synchronized(synchronized);
 }
 
 void QmitkMultiWidgetConfigurationToolBar::OnInteractionSchemeChanged()
 {
   bool PACSInteractionScheme = m_InteractionSchemeChangeAction->isChecked();
   if (PACSInteractionScheme)
   {
     m_InteractionSchemeChangeAction->setIcon(QIcon(":/Qmitk/mwPACS.png"));
     m_InteractionSchemeChangeAction->setText(tr("Change to MITK interaction"));
     emit InteractionSchemeChanged(mitk::InteractionSchemeSwitcher::PACSStandard);
   }
   else
   {
     m_InteractionSchemeChangeAction->setIcon(QIcon(":/Qmitk/mwMITK.png"));
     m_InteractionSchemeChangeAction->setText(tr("Change to PACS interaction"));
     emit InteractionSchemeChanged(mitk::InteractionSchemeSwitcher::MITKStandard);
   }
 
   m_InteractionSchemeChangeAction->setChecked(PACSInteractionScheme);
 }
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index d38432440a..e987a452f2 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,257 +1,284 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkMxNMultiWidget.h"
 #include "QmitkRenderWindowWidget.h"
 
+// mitk core
+#include <mitkDisplayActionEventFunctions.h>
+#include <mitkDisplayActionEventHandlerDesynchronized.h>
+#include <mitkDisplayActionEventHandlerSynchronized.h>
+
 // qt
 #include <QGridLayout>
 
 QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          mitk::RenderingManager* renderingManager/* = nullptr*/,
                                          mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::FastApproximateAntiAliasing*/,
                                          const QString& multiWidgetName/* = "mxnmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, renderingManager, renderingMode, multiWidgetName)
   , m_CrosshairVisibility(false)
 {
   // nothing here
 }
 
 void QmitkMxNMultiWidget::InitializeMultiWidget()
 {
   SetLayout(1, 1);
-
   ActivateMenuWidget(true);
+  SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
+  auto displayActionEventHandler = GetDisplayActionEventHandler();
+  if (nullptr != displayActionEventHandler)
+  {
+    displayActionEventHandler->InitActions();
+  }
 }
 
 void QmitkMxNMultiWidget::MultiWidgetOpened()
 {
   SetCrosshairVisibility(true);
 }
 
 void QmitkMxNMultiWidget::MultiWidgetClosed()
 {
   SetCrosshairVisibility(false);
 }
 
+void QmitkMxNMultiWidget::Synchronize(bool synchronized)
+{
+  if (synchronized)
+  {
+    SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerSynchronized>());
+  }
+  else
+  {
+    SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
+  }
+
+  auto displayActionEventHandler = GetDisplayActionEventHandler();
+  if (nullptr != displayActionEventHandler)
+  {
+    displayActionEventHandler->InitActions();
+  }
+}
+
 QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   if ("axial" == widgetName || "sagittal" == widgetName || "coronal" == widgetName || "3d" == widgetName)
   {
     return GetActiveRenderWindowWidget()->GetRenderWindow();
   }
 
   return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& /*viewDirection*/) const
 {
   // currently no mapping between view directions and render windows
   // simply return the currently active render window
   return GetActiveRenderWindowWidget()->GetRenderWindow();
 }
 
 void QmitkMxNMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
 {
   auto currentActiveRenderWindowWidget = GetActiveRenderWindowWidget();
   if (currentActiveRenderWindowWidget == activeRenderWindowWidget)
   {
     return;
   }
 
   // reset the decoration color of the previously active render window widget
   if (nullptr != currentActiveRenderWindowWidget)
   {
     auto decorationColor = currentActiveRenderWindowWidget->GetDecorationColor();
     QColor hexColor(decorationColor[0] * 255, decorationColor[1] * 255, decorationColor[2] * 255);
     currentActiveRenderWindowWidget->setStyleSheet("border: 2px solid " + hexColor.name(QColor::HexRgb));
-
   }
 
   // set the new decoration color of the currently active render window widget
   if (nullptr != activeRenderWindowWidget)
   {
     activeRenderWindowWidget->setStyleSheet("border: 2px solid #FF6464");
   }
 
   QmitkAbstractMultiWidget::SetActiveRenderWindowWidget(activeRenderWindowWidget);
 }
 
 void QmitkMxNMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget;
   if (widgetName.isNull())
   {
     renderWindowWidget = GetActiveRenderWindowWidget();
   }
   else
   {
     renderWindowWidget = GetRenderWindowWidget(widgetName);
   }
 
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
     renderWindowWidget->RequestUpdate();
     return;
   }
 
   MITK_ERROR << "Position can not be set for an unknown render window widget.";
 }
 
 const mitk::Point3D QmitkMxNMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
 {
   // see T26208
   return mitk::Point3D();
 }
 
 void QmitkMxNMultiWidget::SetCrosshairVisibility(bool activate)
 {
   auto renderWindowWidgets = GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->ActivateCrosshair(activate);
   }
 
   m_CrosshairVisibility = activate;
 }
 
 void QmitkMxNMultiWidget::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   auto renderingManager = GetRenderingManager();
   if (nullptr == renderingManager)
   {
     return;
   }
 
   renderingManager->InitializeViewsByBoundingObjects(dataStorage);
 
   SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
 }
 
 void QmitkMxNMultiWidget::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;
+    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;
   }
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PUBLIC SLOTS
 // MOUSE EVENTS
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkMxNMultiWidget::mousePressEvent(QMouseEvent* e)
 {
   if (QEvent::MouseButtonPress != e->type())
   {
     return;
   }
 
   auto renderWindowWidget = dynamic_cast<QmitkRenderWindowWidget*>(this->sender());
   if (nullptr == renderWindowWidget)
   {
     return;
   }
 
   auto renderWindowWidgetPointer = GetRenderWindowWidget(renderWindowWidget->GetWidgetName());
   SetActiveRenderWindowWidget(renderWindowWidgetPointer);
 }
 
 void QmitkMxNMultiWidget::moveEvent(QMoveEvent* e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the overlays as the MultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::SetLayoutImpl()
 {
   int requiredRenderWindowWidgets = GetRowCount() * GetColumnCount();
   int existingRenderWindowWidgets = GetRenderWindowWidgets().size();
 
   int difference = requiredRenderWindowWidgets - existingRenderWindowWidgets;
   while (0 < difference)
   {
     // more render window widgets needed
     CreateRenderWindowWidget();
     --difference;
   }
 
   while (0 > difference)
   {
     // less render window widgets needed
     RemoveRenderWindowWidget();
     ++difference;
   }
 
   auto firstRenderWindowWidget = GetFirstRenderWindowWidget();
   if (nullptr != firstRenderWindowWidget)
   {
     SetActiveRenderWindowWidget(firstRenderWindowWidget);
   }
 
   GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
 }
 
 void QmitkMxNMultiWidget::CreateRenderWindowWidget()
 {
   // create the render window widget and connect signal / slot
   QString renderWindowWidgetName = GetNameFromIndex(GetNumberOfRenderWindowWidgets());
   RenderWindowWidgetPointer renderWindowWidget = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
   renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
 
   connect(renderWindowWidget.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkMxNMultiWidget::mousePressEvent);
 
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget);
 
   auto renderWindow = renderWindowWidget->GetRenderWindow();
   auto layoutManager = GetMultiWidgetLayoutManager();
   connect(renderWindow, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(renderWindow, &QmitkRenderWindow::ResetView, this, &QmitkMxNMultiWidget::ResetCrosshair);
   connect(renderWindow, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkMxNMultiWidget::SetCrosshairVisibility);
   connect(renderWindow, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkMxNMultiWidget::SetWidgetPlaneMode);
 }
diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index 01291db031..b1edfd36b8 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,808 +1,817 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #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*/,
                                          mitk::RenderingManager *renderingManager/* = nullptr*/,
                                          mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::FastApproximateAntiAliasing*/,
                                          const QString &name/* = "stdmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, renderingManager, renderingMode, name)
   , m_TimeNavigationController(nullptr)
   , m_PendingCrosshairPositionEvent(false)
 {
   m_TimeNavigationController = GetRenderingManager()->GetTimeNavigationController();
 }
 
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   m_TimeNavigationController->Disconnect(GetRenderWindow1()->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(GetRenderWindow2()->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(GetRenderWindow3()->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(GetRenderWindow4()->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()->GetRenderWindow())->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()->GetRenderWindow())->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()->GetRenderWindow())->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()->GetRenderWindow())->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);
   }
 
   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::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   GetRenderingManager()->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;
   }
 }
 
 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* e)
 {
   if (QEvent::MouseButtonPress != e->type())
   {
     return;
   }
 
   auto renderWindowWidget = dynamic_cast<QmitkRenderWindowWidget*>(this->sender());
   if (nullptr == renderWindowWidget)
   {
     return;
   }
 
   auto renderWindowWidgetPointer = GetRenderWindowWidget(renderWindowWidget->GetWidgetName());
   SetActiveRenderWindowWidget(renderWindowWidgetPointer);
 }
 
 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()->GetRenderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->GetRenderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->GetRenderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow4()->GetRenderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   mitk::BaseRenderer::GetInstance(GetRenderWindow1()->GetRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow2()->GetRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow3()->GetRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow4()->GetRenderWindow())->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()->GetRenderWindow());
   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()->GetRenderWindow());
   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()->GetRenderWindow());
   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);
   }
   GetRenderingManager()->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());
   GetRenderingManager()->InitializeViews(geo);
 }
 
 void QmitkStdMultiWidget::CreateRenderWindowWidgets()
 {
   // create axial render window (widget)
   QString renderWindowWidgetName = GetNameFromIndex(0, 0);
   RenderWindowWidgetPointer renderWindowWidget1 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
   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(), GetRenderingManager());
   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(), GetRenderingManager());
   auto renderWindow3 = renderWindowWidget3->GetRenderWindow();
   renderWindow3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
   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(), GetRenderingManager());
   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()->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget4);
 
   SetActiveRenderWindowWidget(renderWindowWidget1);
 
   // connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow1->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow2->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow3->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow4->GetSliceNavigationController(), false);
   renderWindow1->GetSliceNavigationController()->ConnectGeometrySendEvent(
     mitk::BaseRenderer::GetInstance(renderWindow4->GetRenderWindow()));
 
   // reverse connection between sliceNavigationControllers and timeNavigationController
   renderWindow1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   renderWindow2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   renderWindow3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   //renderWindow4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
 
   auto layoutManager = GetMultiWidgetLayoutManager();
   connect(renderWindowWidget1.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
   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(renderWindowWidget2.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
   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(renderWindowWidget3.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
   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(renderWindowWidget4.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
   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);
 }