diff --git a/Modules/Core/include/mitkBaseRenderer.h b/Modules/Core/include/mitkBaseRenderer.h
index 47c2993697..dd9ed0707a 100644
--- a/Modules/Core/include/mitkBaseRenderer.h
+++ b/Modules/Core/include/mitkBaseRenderer.h
@@ -1,556 +1,566 @@
 /*===================================================================
 
 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 BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4
 #define BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4
 
 #include "mitkCameraRotationController.h"
 #include "mitkDataStorage.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlaneGeometryData.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkTimeGeometry.h"
 
 #include "mitkBindDispatcherInteractor.h"
 #include "mitkDispatcher.h"
 
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
 
 #include <map>
 #include <set>
 
 // DEPRECATED
 #include <mitkTimeSlicedGeometry.h>
 
 namespace mitk
 {
   class NavigationController;
   class SliceNavigationController;
   class CameraRotationController;
   class CameraController;
   class DataStorage;
   class Mapper;
   class BaseLocalStorageHandler;
   class KeyEvent;
 
   //##Documentation
   //## @brief Organizes the rendering process
   //##
   //## Organizes the rendering process. A Renderer contains a reference to a
   //## DataStorage and asks the mappers of the data objects to render
   //## the data into the renderwindow it is associated to.
   //##
   //## \#Render() checks if rendering is currently allowed by calling
   //## RenderWindow::PrepareRendering(). Initialization of a rendering context
   //## can also be performed in this method.
   //##
   //## The actual rendering code has been moved to \#Repaint()
   //## Both \#Repaint() and \#Update() are declared protected now.
   //##
   //## Note: Separation of the Repaint and Update processes (rendering vs
   //## creating a vtk prop tree) still needs to be worked on. The whole
   //## rendering process also should be reworked to use VTK based classes for
   //## both 2D and 3D rendering.
   //## @ingroup Renderer
   class MITKCORE_EXPORT BaseRenderer : public itk::Object
   {
   public:
     /** \brief This rendering mode enumeration is specified at various constructors
     *  of the Renderer and RenderWindow classes, which autoconfigures the
     *  respective VTK objects. This has to be done at construction time because later
     *  configuring turns out to be not working on most platforms.
     */
     struct RenderingMode
     {
       enum Type
       {
         Standard = 0
       };
     };
 
     typedef std::map<vtkRenderWindow *, BaseRenderer *> BaseRendererMapType;
     static BaseRendererMapType baseRendererMap;
 
     static BaseRenderer *GetInstance(vtkRenderWindow *renWin);
     static void AddInstance(vtkRenderWindow *renWin, BaseRenderer *baseRenderer);
     static void RemoveInstance(vtkRenderWindow *renWin);
 
     static BaseRenderer *GetByName(const std::string &name);
     static vtkRenderWindow *GetRenderWindowByName(const std::string &name);
 
 #pragma GCC visibility push(default)
     itkEventMacro(RendererResetEvent, itk::AnyEvent);
 #pragma GCC visibility pop
 
     /** Standard class typedefs. */
     mitkClassMacroItkParent(BaseRenderer, itk::Object);
 
     BaseRenderer(const char *name = nullptr,
                  vtkRenderWindow *renWin = nullptr,
                  mitk::RenderingManager *rm = nullptr,
                  RenderingMode::Type mode = RenderingMode::Standard);
 
     //##Documentation
-    //## @brief MapperSlotId defines which kind of mapper (e.g., 2D or 3D) shoud be used.
+    //## @brief MapperSlotId defines which kind of mapper (e.g. 2D or 3D) should be used.
     typedef int MapperSlotId;
 
     enum StandardMapperSlot
     {
       Standard2D = 1,
       Standard3D = 2
     };
 
+    //##Documentation
+    //## @brief Possible view directions for render windows.
+    enum class ViewDirection
+    {
+      AXIAL = 0,
+      SAGITTAL,
+      CORONAL,
+      THREE_D
+    };
+
     virtual void SetDataStorage(DataStorage *storage); ///< set the datastorage that will be used for rendering
 
     //##Documentation
     //## return the DataStorage that is used for rendering
     virtual DataStorage::Pointer GetDataStorage() const { return m_DataStorage.GetPointer(); }
     //##Documentation
     //## @brief Access the RenderWindow into which this renderer renders.
     vtkRenderWindow *GetRenderWindow() const { return m_RenderWindow; }
     vtkRenderer *GetVtkRenderer() const { return m_VtkRenderer; }
     //##Documentation
     //## @brief Returns the Dispatcher which handles Events for this BaseRenderer
     Dispatcher::Pointer GetDispatcher() const;
 
     //##Documentation
     //## @brief Default mapper id to use.
     static const MapperSlotId defaultMapper;
 
     //##Documentation
     //## @brief Do the rendering and flush the result.
     virtual void Paint();
 
     //##Documentation
     //## @brief Initialize the RenderWindow. Should only be called from RenderWindow.
     virtual void Initialize();
 
     //##Documentation
     //## @brief Called to inform the renderer that the RenderWindow has been resized.
     virtual void Resize(int w, int h);
 
     //##Documentation
     //## @brief Initialize the renderer with a RenderWindow (@a renderwindow).
     virtual void InitRenderer(vtkRenderWindow *renderwindow);
 
     //##Documentation
     //## @brief Set the initial size. Called by RenderWindow after it has become
     //## visible for the first time.
     virtual void InitSize(int w, int h);
 
     //##Documentation
     //## @brief Draws a point on the widget.
     //## Should be used during conferences to show the position of the remote mouse
     virtual void DrawOverlayMouse(Point2D &p2d);
 
     //##Documentation
     //## @brief Set/Get the WorldGeometry (m_WorldGeometry) for 3D and 2D rendering, that describing the
     //## (maximal) area to be rendered.
     //##
     //## Depending of the type of the passed BaseGeometry more or less information can be extracted:
     //## \li if it is a PlaneGeometry (which is a sub-class of BaseGeometry), m_CurrentWorldPlaneGeometry is
     //## also set to point to it. m_WorldTimeGeometry is set to nullptr.
     //## \li if it is a TimeGeometry, m_WorldTimeGeometry is also set to point to it.
     //## If m_WorldTimeGeometry contains instances of SlicedGeometry3D, m_CurrentWorldPlaneGeometry is set to
     //## one of geometries stored in the SlicedGeometry3D according to the value of m_Slice;  otherwise
     //## a PlaneGeometry describing the top of the bounding-box of the BaseGeometry is set as the
     //## m_CurrentWorldPlaneGeometry.
     //## \li otherwise a PlaneGeometry describing the top of the bounding-box of the BaseGeometry
     //## is set as the m_CurrentWorldPlaneGeometry. m_WorldTimeGeometry is set to nullptr.
     //## @todo add calculation of PlaneGeometry describing the top of the bounding-box of the BaseGeometry
     //## when the passed BaseGeometry is not sliced.
     //## \sa m_WorldGeometry
     //## \sa m_WorldTimeGeometry
     //## \sa m_CurrentWorldPlaneGeometry
     virtual void SetWorldGeometry3D(const BaseGeometry *geometry);
     virtual void SetWorldTimeGeometry(const mitk::TimeGeometry *geometry);
 
     /**
     * \deprecatedSince{2013_09} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see
     * http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
     */
     DEPRECATED(void SetWorldGeometry3D(TimeSlicedGeometry *geometry));
 
     itkGetConstObjectMacro(WorldTimeGeometry, TimeGeometry)
 
       //##Documentation
       //## @brief Get the current 3D-worldgeometry (m_CurrentWorldGeometry) used for 3D-rendering
       itkGetConstObjectMacro(CurrentWorldGeometry, BaseGeometry)
 
       //##Documentation
       //## @brief Get the current 2D-worldgeometry (m_CurrentWorldPlaneGeometry) used for 2D-rendering
       itkGetConstObjectMacro(CurrentWorldPlaneGeometry, PlaneGeometry)
       /**
       * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometry
       */
       DEPRECATED(const PlaneGeometry *GetCurrentWorldGeometry2D())
     {
       return GetCurrentWorldPlaneGeometry();
     };
 
     //##Documentation
     //## Calculates the bounds of the DataStorage (if it contains any valid data),
     //## creates a geometry from these bounds and sets it as world geometry of the renderer.
     //##
     //## Call this method to re-initialize the renderer to the current DataStorage
     //## (e.g. after loading an additional dataset), to ensure that the view is
     //## aligned correctly.
     //## \warn This is not implemented yet.
     virtual bool SetWorldGeometryToDataStorageBounds() { return false; }
     //##Documentation
     //## @brief Set/Get m_Slice which defines together with m_TimeStep the 2D geometry
     //## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
     //##
     //## \sa m_Slice
     virtual void SetSlice(unsigned int slice);
 
     itkGetConstMacro(Slice, unsigned int)
 
       //##Documentation
       //## @brief Set/Get m_TimeStep which defines together with m_Slice the 2D geometry
       //## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
       //##
       //## \sa m_TimeStep
       virtual void SetTimeStep(unsigned int timeStep);
 
     itkGetConstMacro(TimeStep, unsigned int)
 
       //##Documentation
       //## @brief Get the time-step of a BaseData object which
       //## exists at the time of the currently displayed content
       //##
       //## Returns -1 or mitk::BaseData::m_TimeSteps if there
       //## is no data at the current time.
       //## \sa GetTimeStep, m_TimeStep
       int GetTimeStep(const BaseData *data) const;
 
     //##Documentation
     //## @brief Get the time in ms of the currently displayed content
     //##
     //## \sa GetTimeStep, m_TimeStep
     ScalarType GetTime() const;
 
     //##Documentation
     //## @brief SetWorldGeometry is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometrySendEvent
     virtual void SetGeometry(const itk::EventObject &geometrySliceEvent);
 
     //##Documentation
     //## @brief UpdateWorldGeometry is called to re-read the 2D geometry from the
     //## slice navigation controller
     virtual void UpdateGeometry(const itk::EventObject &geometrySliceEvent);
 
     //##Documentation
     //## @brief SetSlice is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometrySliceEvent
     virtual void SetGeometrySlice(const itk::EventObject &geometrySliceEvent);
 
     //##Documentation
     //## @brief SetTimeStep is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometryTimeEvent
     virtual void SetGeometryTime(const itk::EventObject &geometryTimeEvent);
 
     //##Documentation
     //## @brief Get a DataNode pointing to a data object containing the current 2D-worldgeometry
     // m_CurrentWorldPlaneGeometry (for 2D rendering)
     itkGetObjectMacro(CurrentWorldPlaneGeometryNode, DataNode)
       /**
       * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometryNode
       */
       DEPRECATED(DataNode *GetCurrentWorldGeometry2DNode())
     {
       return GetCurrentWorldPlaneGeometryNode();
     };
 
     //##Documentation
     //## @brief Sets timestamp of CurrentWorldPlaneGeometry and forces so reslicing in that renderwindow
     void SendUpdateSlice();
 
     //##Documentation
     //## @brief Get timestamp of last call of SetCurrentWorldPlaneGeometry
     unsigned long GetCurrentWorldPlaneGeometryUpdateTime() { return m_CurrentWorldPlaneGeometryUpdateTime; }
     /**
     * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometryUpdateTime
     */
     DEPRECATED(unsigned long GetCurrentWorldGeometry2DUpdateTime())
     {
       return GetCurrentWorldPlaneGeometryUpdateTime();
     };
     //##Documentation
     //## @brief Get timestamp of last change of current TimeStep
     unsigned long GetTimeStepUpdateTime() { return m_TimeStepUpdateTime; }
     //##Documentation
     //## @brief Perform a picking: find the x,y,z world coordinate of a
     //## display x,y coordinate.
     //## @warning Has to be overwritten in subclasses for the 3D-case.
     //##
     //## Implemented here only for 2D-rendering
     virtual void PickWorldPoint(const Point2D &diplayPosition, Point3D &worldPosition) const = 0;
 
     /** \brief Determines the object (mitk::DataNode) closest to the current
     * position by means of picking
     *
     * \warning Implementation currently empty for 2D rendering; intended to be
     * implemented for 3D renderers */
     virtual DataNode *PickObject(const Point2D & /*displayPosition*/, Point3D & /*worldPosition*/) const
     {
       return nullptr;
     }
 
     //##Documentation
     //## @brief Get the MapperSlotId to use.
     itkGetMacro(MapperID, MapperSlotId) itkGetConstMacro(MapperID, MapperSlotId)
 
       //##Documentation
       //## @brief Set the MapperSlotId to use.
       itkSetMacro(MapperID, MapperSlotId)
 
         virtual int *GetSize() const;
     virtual int *GetViewportSize() const;
 
     void SetSliceNavigationController(SliceNavigationController *SlicenavigationController);
     itkGetObjectMacro(CameraController, CameraController)
       itkGetObjectMacro(SliceNavigationController, SliceNavigationController)
         itkGetObjectMacro(CameraRotationController, CameraRotationController)
 
           itkGetMacro(EmptyWorldGeometry, bool)
 
       //##Documentation
       //## @brief Tells if the displayed region is shifted and rescaled if the render window is resized.
       itkGetMacro(KeepDisplayedRegion, bool)
       //##Documentation
       //## @brief Tells if the displayed region should be shifted and rescaled if the render window is resized.
       itkSetMacro(KeepDisplayedRegion, bool)
 
       //##Documentation
       //## @brief get the name of the Renderer
       //## @note
       const char *GetName() const
     {
       return m_Name.c_str();
     }
 
     //##Documentation
     //## @brief get the x_size of the RendererWindow
     //## @note
     int GetSizeX() const { return GetSize()[0]; }
     //##Documentation
     //## @brief get the y_size of the RendererWindow
     //## @note
     int GetSizeY() const { return GetSize()[1]; }
     const double *GetBounds() const;
 
     void RequestUpdate();
     void ForceImmediateUpdate();
 
     /** Returns number of mappers which are visible and have level-of-detail
     * rendering enabled */
     unsigned int GetNumberOfVisibleLODEnabledMappers() const;
 
     ///**
     //* \brief Setter for the RenderingManager that handles this instance of BaseRenderer
     //*/
     // void SetRenderingManager( mitk::RenderingManager* );
 
     /**
     * \brief Getter for the RenderingManager that handles this instance of BaseRenderer
     */
     virtual mitk::RenderingManager *GetRenderingManager() const;
 
     //##Documentation
     //## @brief This method converts a display point to the 3D world index
     //## using the geometry of the renderWindow.
     void DisplayToWorld(const Point2D &displayPoint, Point3D &worldIndex) const;
 
     //##Documentation
     //## @brief This method converts a display point to the 2D world index, mapped onto the display plane
     //## using the geometry of the renderWindow.
     void DisplayToPlane(const Point2D &displayPoint, Point2D &planePointInMM) const;
 
     //##Documentation
     //## @brief This method converts a 3D world index to the display point
     //## using the geometry of the renderWindow.
     void WorldToDisplay(const Point3D &worldIndex, Point2D &displayPoint) const;
 
     //##Documentation
     //## @brief This method converts a 3D world index to the point on the viewport
     //## using the geometry of the renderWindow.
     void WorldToView(const Point3D &worldIndex, Point2D &viewPoint) const;
 
     //##Documentation
     //## @brief This method converts a 2D plane coordinate to the display point
     //## using the geometry of the renderWindow.
     void PlaneToDisplay(const Point2D &planePointInMM, Point2D &displayPoint) const;
 
     //##Documentation
     //## @brief This method converts a 2D plane coordinate to the point on the viewport
     //## using the geometry of the renderWindow.
     void PlaneToView(const Point2D &planePointInMM, Point2D &viewPoint) const;
 
 
     double GetScaleFactorMMPerDisplayUnit() const;
 
     Point2D GetDisplaySizeInMM() const;
     Point2D GetViewportSizeInMM() const;
 
     Point2D GetOriginInMM() const;
 
     itkGetConstMacro(ConstrainZoomingAndPanning, bool) virtual void SetConstrainZoomingAndPanning(bool constrain);
 
     /**
     * \brief Provides (1) world coordinates for a given mouse position and (2)
     * translates mousePosition to Display coordinates
     * \deprecated Map2DRendererPositionTo3DWorldPosition is deprecated. Please use DisplayToWorld instead.
     */
     DEPRECATED(virtual Point3D Map2DRendererPositionTo3DWorldPosition(const Point2D &mousePosition) const);
 
   protected:
     ~BaseRenderer() override;
 
     //##Documentation
     //## @brief Call update of all mappers. To be implemented in subclasses.
     virtual void Update() = 0;
 
     vtkRenderWindow *m_RenderWindow;
     vtkRenderer *m_VtkRenderer;
 
     //##Documentation
     //## @brief MapperSlotId to use. Defines which kind of mapper (e.g., 2D or 3D) shoud be used.
     MapperSlotId m_MapperID;
 
     //##Documentation
     //## @brief The DataStorage that is used for rendering.
     DataStorage::Pointer m_DataStorage;
 
     //##Documentation
     //## @brief The RenderingManager that manages this instance
     RenderingManager::Pointer m_RenderingManager;
 
     //##Documentation
     //## @brief Timestamp of last call of Update().
     unsigned long m_LastUpdateTime;
 
     //##Documentation
     //## @brief CameraController for 3D rendering
     //## @note preliminary.
     itk::SmartPointer<CameraController> m_CameraController;
     SliceNavigationController::Pointer m_SliceNavigationController;
     CameraRotationController::Pointer m_CameraRotationController;
 
     //##Documentation
     //## @brief Sets m_CurrentWorldPlaneGeometry
     virtual void SetCurrentWorldPlaneGeometry(const PlaneGeometry *geometry2d);
     /**
     * \deprecatedSince{2014_10} Please use SetCurrentWorldPlaneGeometry
     */
     DEPRECATED(void SetCurrentWorldGeometry2D(PlaneGeometry *geometry2d)) { SetCurrentWorldPlaneGeometry(geometry2d); };
     //##Documentation
     //## @brief Sets m_CurrentWorldGeometry
     virtual void SetCurrentWorldGeometry(const BaseGeometry *geometry);
 
   private:
     //##Documentation
     //## m_WorldTimeGeometry is set by SetWorldGeometry if the passed BaseGeometry is a
     //## TimeGeometry (or a sub-class of it). If it contains instances of SlicedGeometry3D,
     //## m_Slice and m_TimeStep (set via SetSlice and SetTimeStep, respectively) define
     //## which 2D geometry stored in m_WorldTimeGeometry (if available)
     //## is used as m_CurrentWorldPlaneGeometry.
     //## \sa m_CurrentWorldPlaneGeometry
     TimeGeometry::ConstPointer m_WorldTimeGeometry;
 
     //##Documentation
     //## Pointer to the current 3D-worldgeometry.
     BaseGeometry::ConstPointer m_CurrentWorldGeometry;
 
     //##Documentation
     //## Pointer to the current 2D-worldgeometry. The 2D-worldgeometry
     //## describes the maximal area (2D manifold) to be rendered in case we
     //## are doing 2D-rendering.
     //## It is const, since we are not allowed to change it (it may be taken
     //## directly from the geometry of an image-slice and thus it would be
     //## very strange when suddenly the image-slice changes its geometry).
     PlaneGeometry::Pointer m_CurrentWorldPlaneGeometry;
 
     //##Documentation
     //## Defines together with m_Slice which 2D geometry stored in m_WorldTimeGeometry
     //## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
     //## \sa m_WorldTimeGeometry
     unsigned int m_Slice;
     //##Documentation
     //## Defines together with m_TimeStep which 2D geometry stored in m_WorldTimeGeometry
     //## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
     //## \sa m_WorldTimeGeometry
     unsigned int m_TimeStep;
 
     //##Documentation
     //## @brief timestamp of last call of SetWorldGeometry
     itk::TimeStamp m_CurrentWorldPlaneGeometryUpdateTime;
 
     //##Documentation
     //## @brief timestamp of last change of the current time step
     itk::TimeStamp m_TimeStepUpdateTime;
 
     //##Documentation
     //## @brief Helper class which establishes connection between Interactors and Dispatcher via a common DataStorage.
     BindDispatcherInteractor *m_BindDispatcherInteractor;
 
     //##Documentation
     //## @brief Tells if the displayed region should be shifted or rescaled if the render window is resized.
     bool m_KeepDisplayedRegion;
 
   protected:
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
     //##Documentation
     //## Data object containing the m_CurrentWorldPlaneGeometry defined above.
     PlaneGeometryData::Pointer m_CurrentWorldPlaneGeometryData;
 
     //##Documentation
     //## DataNode objects containing the m_CurrentWorldPlaneGeometryData defined above.
     DataNode::Pointer m_CurrentWorldPlaneGeometryNode;
 
     //##Documentation
     //## @brief test only
     unsigned long m_CurrentWorldPlaneGeometryTransformTime;
 
     std::string m_Name;
 
     double m_Bounds[6];
 
     bool m_EmptyWorldGeometry;
 
     typedef std::set<Mapper *> LODEnabledMappersType;
 
     /** Number of mappers which are visible and have level-of-detail
     * rendering enabled */
     unsigned int m_NumberOfVisibleLODEnabledMappers;
 
     // Local Storage Handling for mappers
 
   protected:
     std::list<mitk::BaseLocalStorageHandler *> m_RegisteredLocalStorageHandlers;
 
     bool m_ConstrainZoomingAndPanning;
 
   public:
     void RemoveAllLocalStorages();
     void RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
     void UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
   };
 } // namespace mitk
 
 #endif /* BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4 */
diff --git a/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h b/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
index d83878a2be..55637967ae 100644
--- a/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
@@ -1,150 +1,152 @@
 /*===================================================================
 
 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 <mitkInteractionSchemeSwitcher.h>
 #include <mitkPoint.h>
 
 // qt
 #include <QWidget>
 
 // c++
 #include <map>
 #include <memory>
 
 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::Standard,
                            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;
 
   int GetRowCount() const;
   int GetColumnCount() const;
   virtual void SetLayout(int row, int column);
 
   virtual void Synchronize(bool synchronized);
   virtual void SetInteractionScheme(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
 
   mitk::InteractionEventHandler* GetInteractionEventHandler();
 
   RenderWindowWidgetMap GetRenderWindowWidgets() const;
   RenderWindowWidgetPointer GetRenderWindowWidget(int row, int column) const;
   RenderWindowWidgetPointer GetRenderWindowWidget(const QString& widgetName) const;
   RenderWindowHash GetRenderWindows() const;
   QmitkRenderWindow* GetRenderWindow(int row, int column) const;
   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;
 
 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 d1b225fee5..86102f22b9 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,85 +1,87 @@
 /*===================================================================
 
 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"
 
 class QGridLayout;
 
 /**
 * @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 'ResetLayout'-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::Standard,
                       const QString& multiWidgetName = "mxnmulti");
 
   virtual ~QmitkMxNMultiWidget() = default;
 
   virtual void InitializeMultiWidget() override;
   virtual void MultiWidgetOpened() override;
   virtual void MultiWidgetClosed() override;
 
+  virtual QmitkRenderWindow* GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const override;
+
   virtual void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget) 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 activate) override;
   virtual bool GetCrosshairVisibility() const override { return m_CrosshairVisibility; }
 
 public Q_SLOTS:
 
   // mouse events
   virtual void wheelEvent(QWheelEvent* e) override;
   virtual void mousePressEvent(QMouseEvent* e) override;
   virtual void moveEvent(QMoveEvent* e) override;
 
 Q_SIGNALS:
 
   void WheelMoved(QWheelEvent *);
   void Moved();
 
 private:
 
   virtual void SetLayoutImpl() override;
   virtual void SynchronizeImpl() override { }
   virtual void SetInteractionSchemeImpl() override { }
 
   void InitializeLayout();
   void CreateRenderWindowWidget();
   void FillMultiWidgetLayout();
 
   QGridLayout* m_GridLayout;
   bool m_CrosshairVisibility;
 
 };
 
 #endif // QMITKMXNMULTIWIDGET_H
diff --git a/Modules/QtWidgets/include/QmitkStdMultiWidget.h b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
index 594d4af4b1..4b2d5ef6c0 100644
--- a/Modules/QtWidgets/include/QmitkStdMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
@@ -1,229 +1,223 @@
 /*===================================================================
 
 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"
 
 #include <QFrame>
 #include <qsplitter.h>
 #include <qwidget.h>
 
 class QHBoxLayout;
 
 /**
 * @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:
 
   enum
   {
     PLANE_MODE_SLICING = 0,
     PLANE_MODE_ROTATION,
     PLANE_MODE_SWIVEL
   };
 
-  enum
-  {
-    AXIAL = 0,
-    SAGITTAL,
-    CORONAL,
-    THREE_D
-  };
-
   QmitkStdMultiWidget(QWidget *parent = nullptr,
                       Qt::WindowFlags f = 0,
                       mitk::RenderingManager *renderingManager = nullptr,
                       mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard,
                       const QString &name = "stdmulti");
 
   ~QmitkStdMultiWidget() override;
 
   virtual void InitializeMultiWidget() 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 { return true; }
 
   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();
 
   void ActivateMenuWidget(bool state);
 
   bool IsMenuWidgetEnabled() const;
 
   /**
    * @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 wheelEvent(QWheelEvent* e) override;
   virtual void moveEvent(QMoveEvent* 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);
 
   void SetWidgetPlanesLocked(bool locked);
 
   void SetWidgetPlanesRotationLocked(bool locked);
 
   void SetWidgetPlanesRotationLinked(bool link);
 
   void SetWidgetPlaneMode(int mode);
 
   //void SetWidgetPlaneModeToSlicing(bool activate);
 
   //void SetWidgetPlaneModeToRotation(bool activate);
 
   //void SetWidgetPlaneModeToSwivel(bool activate);
 
   void ResetCrosshair();
 
 Q_SIGNALS:
 
   void LeftMouseClicked(mitk::Point3D pointValue);
   void WheelMoved(QWheelEvent *);
   void WidgetPlanesRotationLinked(bool);
   void WidgetPlanesRotationEnabled(bool);
   void ViewsInitialized();
   void WidgetPlaneModeSlicing(bool);
   void WidgetPlaneModeRotation(bool);
   void WidgetPlaneModeSwivel(bool);
   void WidgetPlaneModeChange(int);
   void WidgetNotifyNewCrossHairMode(int);
   void Moved();
 
 private:
 
   virtual void SetLayoutImpl() override;
   virtual void SynchronizeImpl() override { }
   virtual void SetInteractionSchemeImpl() override { }
 
   void CreateRenderWindowWidgets();
   void InitializeLayout();
 
   void UpdateAllWidgets();
 
   void HideAllWidgetToolbars();
 
   QHBoxLayout* hBoxLayout;
 
   mitk::RenderingManager *m_RenderingManager;
   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;
 
   int m_PlaneMode;
 
   /**
    * @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;
 
   QSplitter* m_MainSplit;
   QSplitter* m_LayoutSplit;
   QSplitter* m_SubSplit1;
   QSplitter* m_SubSplit2;
 
   QWidget* mitkWidget1Container;
   QWidget* mitkWidget2Container;
   QWidget* mitkWidget3Container;
   QWidget* mitkWidget4Container;
 
   bool m_PendingCrosshairPositionEvent;
   bool m_CrosshairNavigationEnabled;
 
 };
 
 #endif // QMITKSTDMULTIWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index bf9866ebe5..cbc4122fd6 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,214 +1,221 @@
 /*===================================================================
 
 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"
 
 // qt
 #include <QGridLayout>
 
 QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          mitk::RenderingManager* renderingManager/* = nullptr*/,
                                          mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/,
                                          const QString& multiWidgetName/* = "mxnmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, renderingManager, renderingMode, multiWidgetName)
   , m_GridLayout(nullptr)
   , m_CrosshairVisibility(false)
 {
   // nothing here
 }
 
 void QmitkMxNMultiWidget::InitializeMultiWidget()
 {
   SetLayout(1, 1);
 }
 
 void QmitkMxNMultiWidget::MultiWidgetOpened()
 {
   SetCrosshairVisibility(true);
 }
 
 void QmitkMxNMultiWidget::MultiWidgetClosed()
 {
   SetCrosshairVisibility(false);
 }
 
+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)
   {
     currentActiveRenderWindowWidget->setStyleSheet("border: 2px solid white");
   }
 
   // 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;
 }
 
 //////////////////////////////////////////////////////////////////////////
 // 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;
   }
 
   InitializeLayout();
 }
 
 void QmitkMxNMultiWidget::InitializeLayout()
 {
   delete m_GridLayout;
   m_GridLayout = new QGridLayout(this);
   m_GridLayout->setContentsMargins(0, 0, 0, 0);
   setLayout(m_GridLayout);
 
   FillMultiWidgetLayout();
   resize(QSize(364, 477).expandedTo(minimumSizeHint()));
 
   auto firstRenderWindowWidget = GetFirstRenderWindowWidget();
   if (nullptr != firstRenderWindowWidget)
   {
     SetActiveRenderWindowWidget(firstRenderWindowWidget);
   }
 }
 
 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());
   renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
 
   connect(renderWindowWidget.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkMxNMultiWidget::mousePressEvent);
 
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget);
 }
 
 void QmitkMxNMultiWidget::FillMultiWidgetLayout()
 {
   for (int row = 0; row < GetRowCount(); ++row)
   {
     for (int column = 0; column < GetColumnCount(); ++column)
     {
       RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(row, column);
       if (nullptr != renderWindowWidget)
       {
         m_GridLayout->addWidget(renderWindowWidget.get(), row, column);
       }
     }
   }
 }
diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index cdcdd34080..e988001598 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,847 +1,852 @@
 /*===================================================================
 
 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"
 
 #include <QHBoxLayout>
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 #include <qsplitter.h>
 
 #include "mitkImagePixelReadAccessor.h"
 #include "mitkPixelTypeMultiplex.h"
 #include <mitkCameraController.h>
 #include <mitkImage.h>
 #include <mitkInteractionConst.h>
 #include <mitkLine.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkPlaneGeometryDataMapper2D.h>
 #include <mitkPointSet.h>
 #include <mitkProperties.h>
 #include <mitkStatusBar.h>
 #include <mitkVtkLayerController.h>
 #include <vtkSmartPointer.h>
 
 #include <iomanip>
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          mitk::RenderingManager *renderingManager/* = nullptr*/,
                                          mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/,
                                          const QString &name/* = "stdmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, renderingManager, renderingMode, name)
   , hBoxLayout(nullptr)
   , m_RenderingManager(renderingManager)
   , m_TimeNavigationController(nullptr)
   , m_PlaneMode(PLANE_MODE_SLICING)
   , m_MainSplit(nullptr)
   , m_LayoutSplit(nullptr)
   , m_SubSplit1(nullptr)
   , m_SubSplit2(nullptr)
   , m_PendingCrosshairPositionEvent(false)
   , m_CrosshairNavigationEnabled(false)
 {
   // use the global RenderingManager if none was specified
   if (m_RenderingManager == nullptr)
   {
     m_RenderingManager = mitk::RenderingManager::GetInstance();
   }
   m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
 
   // create SignalSlot Connection
   /*
   connect(m_RenderWindow1, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
   connect(m_RenderWindow1, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
   connect(m_RenderWindow1, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
   connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), m_RenderWindow1, SLOT(OnWidgetPlaneModeChanged(int)));
 
   connect(m_RenderWindow2, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
   connect(m_RenderWindow2, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
   connect(m_RenderWindow2, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
   connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), m_RenderWindow2, SLOT(OnWidgetPlaneModeChanged(int)));
 
   connect(m_RenderWindow3, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
   connect(m_RenderWindow3, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
   connect(m_RenderWindow3, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
   connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), m_RenderWindow3, SLOT(OnWidgetPlaneModeChanged(int)));
 
   connect(m_RenderWindow4, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
   connect(m_RenderWindow4, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
   connect(m_RenderWindow4, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
   connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), m_RenderWindow4, SLOT(OnWidgetPlaneModeChanged(int)));
   */
 }
 
 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()
 {
   SetLayout(2, 2);
 
   // Yellow is default color for widget4
   m_DecorationColorWidget4[0] = 1.0f;
   m_DecorationColorWidget4[1] = 1.0f;
   m_DecorationColorWidget4[2] = 0.0f;
 
   // 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);
 
   // Set plane mode (slicing/rotation behavior) to slicing (default)
   m_PlaneMode = PLANE_MODE_SLICING;
 
   AddDisplayPlaneSubTree();
 
   ActivateMenuWidget(true);
 }
 
+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::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();
 }
 
 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()));
   }
 }
 
 void QmitkStdMultiWidget::ActivateMenuWidget(bool state)
 {
   GetRenderWindow1()->ActivateMenuWidget(state, this);
   GetRenderWindow2()->ActivateMenuWidget(state, this);
   GetRenderWindow3()->ActivateMenuWidget(state, this);
   GetRenderWindow4()->ActivateMenuWidget(state, this);
 }
 
 bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const
 {
   return GetRenderWindow1()->GetActivateMenuWidgetFlag();
 }
 
 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::wheelEvent(QWheelEvent *e)
 {
   emit WheelMoved(e);
 }
 
 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::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);
   }
   m_RenderingManager->RequestUpdateAll();
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked)
 {
   // do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked)
 {
   // do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked(bool link)
 {
   emit WidgetPlanesRotationLinked(link);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
 {
   /*
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   emit WidgetNotifyNewCrossHairMode(userMode);
   // Convert user interface mode to actual mode
   {
   switch (userMode)
   {
   case 0:
   m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::MITK);
   break;
   case 1:
   m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATION);
   break;
 
   case 2:
   m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATIONLINKED);
   break;
 
   case 3:
   m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::SWIVEL);
   break;
   }
   }
   */
 }
 
 /*
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing(bool activate)
 {
 if (activate)
 {
 this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
 }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation(bool activate)
 {
 if (activate)
 {
 this->SetWidgetPlaneMode(PLANE_MODE_ROTATION);
 }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel(bool activate)
 {
 if (activate)
 {
 this->SetWidgetPlaneMode(PLANE_MODE_SWIVEL);
 }
 }
 */
 
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   m_RenderingManager->InitializeViewsByBoundingObjects(dataStorage);
   // m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
   // reset interactor to normal slicing
   SetWidgetPlaneMode(PLANE_MODE_SLICING);
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkStdMultiWidget::SetLayoutImpl()
 {
   CreateRenderWindowWidgets();
   InitializeLayout();
 
   // Initialize views as axial, sagittal, coronal to all data objects in DataStorage
   auto geo = GetDataStorage()->ComputeBoundingGeometry3D(GetDataStorage()->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 }
 
 void QmitkStdMultiWidget::CreateRenderWindowWidgets()
 {
   // create axial render window (widget)
   QString renderWindowWidgetName = GetNameFromIndex(0, 0);
   RenderWindowWidgetPointer renderWindowWidget1 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow1 = renderWindowWidget1->GetRenderWindow();
   renderWindow1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
   renderWindowWidget1->SetDecorationColor(GetDecorationColor(0));
   renderWindowWidget1->SetCornerAnnotationText("Axial");
-  renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(AXIAL);
+  renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(static_cast<unsigned int>(ViewDirection::AXIAL));
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget1);
 
   // create sagittal render window (widget)
   renderWindowWidgetName = GetNameFromIndex(0, 1);
   RenderWindowWidgetPointer renderWindowWidget2 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow2 = renderWindowWidget2->GetRenderWindow();
   renderWindow2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
   renderWindowWidget2->SetDecorationColor(GetDecorationColor(1));
   renderWindowWidget2->setStyleSheet("border: 0px");
   renderWindowWidget2->SetCornerAnnotationText("Sagittal");
-  renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(SAGITTAL);
+  renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(static_cast<unsigned int>(ViewDirection::SAGITTAL));
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget2);
 
   // create coronal render window (widget)
   renderWindowWidgetName = GetNameFromIndex(1, 0);
   RenderWindowWidgetPointer renderWindowWidget3 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow3 = renderWindowWidget3->GetRenderWindow();
   renderWindow3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
   renderWindowWidget3->SetDecorationColor(GetDecorationColor(2));
   renderWindowWidget3->SetCornerAnnotationText("Coronal");
-  renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(CORONAL);
+  renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(static_cast<unsigned int>(ViewDirection::CORONAL));
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget3);
 
   // create 3D render window (widget)
   renderWindowWidgetName = GetNameFromIndex(1, 1);
   RenderWindowWidgetPointer renderWindowWidget4 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow4 = renderWindowWidget4->GetRenderWindow();
   renderWindow4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
   renderWindowWidget4->SetDecorationColor(GetDecorationColor(3));
   renderWindowWidget4->SetCornerAnnotationText("3D");
+  renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(static_cast<unsigned int>(ViewDirection::THREE_D));
   mitk::BaseRenderer::GetInstance(renderWindowWidget4->GetRenderWindow()->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
-  renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(THREE_D);
   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);
 }
 
 void QmitkStdMultiWidget::InitializeLayout()
 {
   // create layouts
   hBoxLayout = new QHBoxLayout(this);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   // create main split
   m_MainSplit = new QSplitter(this);
   hBoxLayout->addWidget(m_MainSplit);
 
   // create vertical layout split and add to the main split
   m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter(m_LayoutSplit);
   m_SubSplit2 = new QSplitter(m_LayoutSplit);
 
   m_SubSplit1->addWidget(GetRenderWindowWidget(0, 0).get());
   m_SubSplit1->addWidget(GetRenderWindowWidget(0, 1).get());
   m_SubSplit2->addWidget(GetRenderWindowWidget(1, 0).get());
   m_SubSplit2->addWidget(GetRenderWindowWidget(1, 1).get());
 
   resize(QSize(364, 477).expandedTo(minimumSizeHint()));
 }
 
 void QmitkStdMultiWidget::UpdateAllWidgets()
 {
   GetRenderWindow1()->resize(mitkWidget1Container->frameSize().width() - 1, mitkWidget1Container->frameSize().height());
   GetRenderWindow1()->resize(mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height());
 
   GetRenderWindow2()->resize(mitkWidget2Container->frameSize().width() - 1, mitkWidget2Container->frameSize().height());
   GetRenderWindow2()->resize(mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height());
 
   GetRenderWindow3()->resize(mitkWidget3Container->frameSize().width() - 1, mitkWidget3Container->frameSize().height());
   GetRenderWindow3()->resize(mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height());
 
   GetRenderWindow4()->resize(mitkWidget4Container->frameSize().width() - 1, mitkWidget4Container->frameSize().height());
   GetRenderWindow4()->resize(mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height());
 }
 
 void QmitkStdMultiWidget::HideAllWidgetToolbars()
 {
   GetRenderWindow1()->HideRenderWindowMenu();
   GetRenderWindow2()->HideRenderWindowMenu();
   GetRenderWindow3()->HideRenderWindowMenu();
   GetRenderWindow4()->HideRenderWindowMenu();
 }
diff --git a/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h b/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
index 89afbcd99a..8d9890d42c 100644
--- a/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
+++ b/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
@@ -1,191 +1,194 @@
 /*===================================================================
 
 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 MITKIRENDERWINDOWPART_H
 #define MITKIRENDERWINDOWPART_H
 
 #include <QString>
 #include <QStringList>
 #include <QHash>
 #include <QtPlugin>
 
+#include <mitkBaseRenderer.h>
 #include <mitkNumericTypes.h>
 #include <mitkRenderingManager.h>
 
 #include <org_mitk_gui_common_Export.h>
 
 class QmitkRenderWindow;
 
 namespace mitk {
 
 struct IRenderingManager;
 class SliceNavigationController;
 
 /**
  * \ingroup org_mitk_gui_common
  *
  * \brief Interface for a MITK Workbench Part providing a render window.
  *
  * This interface allows generic access to Workbench parts which provide some
  * kind of render window. The interface is intended to be implemented by
  * subclasses of berry::IWorkbenchPart. Usually, the interface is implemented
  * by a Workbench editor.
  *
  * A IRenderWindowPart provides zero or more QmitkRenderWindow instances which can
  * be controlled via this interface. QmitkRenderWindow instances have an associated
- * \e id, which is implementation specific. However, implementations should consider
- * to use one of the following ids for certain QmitkRenderWindow instances to maximize
- * reusability (they are free to map multiple ids to one QmitkRenderWindow internally):
- * <ul>
- * <li>axial</li>
- * <li>sagittal</li>
- * <li>coronal</li>
- * <li>3d</li>
- * </ul>
+ * \e id, which is implementation specific.
+ * Additionally the defined values AXIAL, SAGITTAL, CORONAL, THREE_D from mitk::BaseRenderer
+ * can be used to retrieve a specific QmitkRenderWindow.
  *
  * \see ILinkedRenderWindowPart
  * \see IRenderWindowPartListener
  * \see QmitkAbstractRenderEditor
  */
 struct MITK_GUI_COMMON_PLUGIN IRenderWindowPart {
 
   static const QString DECORATION_BORDER; // = "border"
   static const QString DECORATION_LOGO; // = "logo"
   static const QString DECORATION_MENU; // = "menu"
   static const QString DECORATION_BACKGROUND; // = "background"
   static const QString DECORATION_CORNER_ANNOTATION; // = "corner annotation"
 
   virtual ~IRenderWindowPart();
 
   /**
    * Get the currently active (focused) render window.
    * Focus handling is implementation specific.
    *
    * \return The active QmitkRenderWindow instance; <code>nullptr</code>
    *         if no render window is active.
    */
   virtual QmitkRenderWindow* GetActiveQmitkRenderWindow() const = 0;
 
   /**
    * Get all render windows with their ids.
    *
    * \return A hash map mapping the render window id to the QmitkRenderWindow instance.
    */
   virtual QHash<QString,QmitkRenderWindow*> GetQmitkRenderWindows() const  = 0;
 
   /**
    * Get a render window with a specific id.
    *
    * \param id The render window id.
    * \return The QmitkRenderWindow instance for <code>id</code>
    */
   virtual QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const = 0;
 
+  /**
+  * Get a render window with a specific view direction.
+  *
+  * \param viewDirection The render window view direction.
+  * \return The QmitkRenderWindow instance for <code>viewDirection</code>
+  */
+  virtual QmitkRenderWindow* GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const = 0;
+
   /**
    * Get the rendering manager used by this render window part.
    *
    * \return The current IRenderingManager instance or <code>nullptr</code>
    *         if no rendering manager is used.
    */
   virtual mitk::IRenderingManager* GetRenderingManager() const = 0;
 
   /**
    * Request an update of all render windows.
    *
    * \param requestType Specifies the type of render windows for which an update
    *        will be requested.
    */
   virtual void RequestUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL) = 0;
 
   /**
    * Force an immediate update of all render windows.
    *
    * \param requestType Specifies the type of render windows for which an immediate update
    *        will be requested.
    */
   virtual void ForceImmediateUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL) = 0;
 
   /**
    * Get the SliceNavigationController for controlling time positions.
    *
    * \return A SliceNavigationController if the render window supports this
    *         operation; otherwise returns <code>nullptr</code>.
    */
   virtual mitk::SliceNavigationController* GetTimeNavigationController() const = 0;
 
   /**
    * Get the selected position in the render window with id <code>id</code>
    * or in the active render window if <code>id</code> is nullptr.
    *
    * \param id The render window id.
    * \return The currently selected position in world coordinates.
    */
   virtual mitk::Point3D GetSelectedPosition(const QString& id = QString()) const = 0;
 
   /**
    * Set the selected position in the render window with id <code>id</code>
    * or in the active render window if <code>id</code> is nullptr.
    *
    * \param pos The position in world coordinates which should be selected.
    * \param id The render window id in which the selection should take place.
    */
   virtual void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) = 0;
 
   /**
    * Enable \e decorations like colored borders, menu widgets, logos, text annotations, etc.
    *
    * Decorations are implementation specific. A set of standardized decoration names is listed
    * in GetDecorations().
    *
    * \param enable If <code>true</code> enable the decorations specified in <code>decorations</code>,
    *        otherwise disable them.
    * \param decorations A list of decoration names. If empty, all supported decorations are affected.
    *
    * \see GetDecorations()
    */
   virtual void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) = 0;
 
   /**
    * Return if a specific decoration is enabled.
    *
    * \return <code>true</code> if the decoration is enabled, <code>false</code> if it is disabled
    *         or unknown.
    *
    * \see GetDecorations()
    */
   virtual bool IsDecorationEnabled(const QString& decoration) const = 0;
 
   /**
    * Get a list of supported decorations.
    *
    * The following decoration names are standardized and should not be used for other decoration types:
    * <ul>
    * <li>\e DECORATION_BORDER Any border decorations like colored rectangles, etc.
    * <li>\e DECORATION_MENU Menus associated with render windows
    * <li>\e DECORATION_BACKGROUND All kinds of backgrounds (patterns, gradients, etc.) except for solid colored backgrounds
    * <li>\e DECORATION_LOGO Any kind of logo overlayed on the rendered scene
    * </ul>
    *
    * \return A list of supported decoration names.
    */
   virtual QStringList GetDecorations() const = 0;
 };
 
 }
 
 Q_DECLARE_INTERFACE(mitk::IRenderWindowPart, "org.mitk.ui.IRenderWindowPart")
 
 #endif // MITKIRENDERWINDOWPART_H
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
index 501701bec0..f5d57b8c9a 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
@@ -1,241 +1,252 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkAbstractMultiWidgetEditor.h"
 
 // mitk qt widgets module
 #include <QmitkAbstractMultiWidget.h>
 #include <QmitkRenderWindowWidget.h>
 
 // mitk gui qt common plugin
 #include "QmitkMultiWidgetDecorationManager.h"
 
 // berry
 #include <berryIWorkbenchPartConstants.h>
 
 const QString QmitkAbstractMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.abstractmultiwidget";
 
 struct QmitkAbstractMultiWidgetEditor::Impl final
 {
   Impl();
   ~Impl() = default;
 
   QmitkAbstractMultiWidget* m_MultiWidget;
 
   std::unique_ptr<QmitkMultiWidgetDecorationManager> m_MultiWidgetDecorationManager;
 };
 
 QmitkAbstractMultiWidgetEditor::Impl::Impl()
   : m_MultiWidget(nullptr)
 {
   // nothing here
 }
 
 QmitkAbstractMultiWidgetEditor::QmitkAbstractMultiWidgetEditor()
   : m_Impl(std::make_unique<Impl>())
 {
   // nothing here
 }
 
 QmitkAbstractMultiWidgetEditor::~QmitkAbstractMultiWidgetEditor() {}
 
 QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetActiveQmitkRenderWindow() const
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr != multiWidget)
   {
     auto activeRenderWindowWidget = multiWidget->GetActiveRenderWindowWidget();
     if (nullptr != activeRenderWindowWidget)
     {
       return activeRenderWindowWidget->GetRenderWindow();
     }
   }
 
   return nullptr;
 }
 
 QHash<QString, QmitkRenderWindow*> QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow*> result;
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return result;
   }
 
   result = multiWidget->GetRenderWindows();
   return result;
 }
 
 QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindow(const QString& id) const
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return nullptr;
   }
 
   return multiWidget->GetRenderWindow(id);
 }
 
+QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const
+{
+  const auto& multiWidget = GetMultiWidget();
+  if (nullptr == multiWidget)
+  {
+    return nullptr;
+  }
+
+  return multiWidget->GetRenderWindow(viewDirection);
+}
+
 mitk::Point3D QmitkAbstractMultiWidgetEditor::GetSelectedPosition(const QString& id/* = QString()*/) const
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return mitk::Point3D();
   }
 
   return multiWidget->GetSelectedPosition(id);
 }
 
 void QmitkAbstractMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D& pos, const QString& id/* = QString()*/)
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr != multiWidget)
   {
     return multiWidget->SetSelectedPosition(pos, id);
   }
 }
 
 void QmitkAbstractMultiWidgetEditor::EnableDecorations(bool enable, const QStringList& decorations)
 {
   m_Impl->m_MultiWidgetDecorationManager->ShowDecorations(enable, decorations);
 }
 
 bool QmitkAbstractMultiWidgetEditor::IsDecorationEnabled(const QString& decoration) const
 {
   return m_Impl->m_MultiWidgetDecorationManager->IsDecorationVisible(decoration);
 }
 
 QStringList QmitkAbstractMultiWidgetEditor::GetDecorations() const
 {
   return m_Impl->m_MultiWidgetDecorationManager->GetDecorations();
 }
 
 berry::IPartListener::Events::Types QmitkAbstractMultiWidgetEditor::GetPartEventTypes() const
 {
   return Events::CLOSED | Events::OPENED;
 }
 
 void QmitkAbstractMultiWidgetEditor::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkAbstractMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = GetMultiWidget();
     if (nullptr != multiWidget)
     {
       multiWidget->MultiWidgetOpened();
     }
   }
 }
 
 void QmitkAbstractMultiWidgetEditor::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkAbstractMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = GetMultiWidget();
     if (nullptr != multiWidget)
     {
       multiWidget->MultiWidgetClosed();
     }
   }
 }
 
 QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindowByIndex(int index) const
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return nullptr;
   }
 
   QString renderWindowName = multiWidget->GetNameFromIndex(index);
   return multiWidget->GetRenderWindow(renderWindowName);
 }
 
 QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindowByIndex(int row, int column) const
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return nullptr;
   }
 
   QString renderWindowName = multiWidget->GetNameFromIndex(row, column);
   return multiWidget->GetRenderWindow(renderWindowName);
 }
 
 void QmitkAbstractMultiWidgetEditor::SetMultiWidget(QmitkAbstractMultiWidget* multiWidget)
 {
   m_Impl->m_MultiWidget = multiWidget;
   m_Impl->m_MultiWidgetDecorationManager.reset(new QmitkMultiWidgetDecorationManager(multiWidget));
 }
 
 QmitkAbstractMultiWidget* QmitkAbstractMultiWidgetEditor::GetMultiWidget() const
 {
   return m_Impl->m_MultiWidget;
 }
 
 int QmitkAbstractMultiWidgetEditor::GetRowCount() const
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return 0;
   }
 
   return multiWidget->GetRowCount();
 }
 
 int QmitkAbstractMultiWidgetEditor::GetColumnCount() const
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return 0;
   }
 
   return multiWidget->GetColumnCount();
 }
 
 void QmitkAbstractMultiWidgetEditor::OnLayoutSet(int row, int column)
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr != multiWidget)
   {
     multiWidget->SetLayout(row, column);
     FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
   }
 }
 
  void QmitkAbstractMultiWidgetEditor::OnSynchronize(bool synchronized)
  {
    const auto& multiWidget = GetMultiWidget();
    if (nullptr != multiWidget)
    {
      multiWidget->Synchronize(synchronized);
    }
  }
 
  void QmitkAbstractMultiWidgetEditor::OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
  {
    const auto& multiWidget = GetMultiWidget();
    if (nullptr != multiWidget)
    {
      multiWidget->SetInteractionScheme(scheme);
    }
  }
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
index b87b1622fc..f90972722e 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
@@ -1,139 +1,143 @@
 /*===================================================================
 
 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 QMITKABSTRACTMULTIWIDGETEDITOR_H
 #define QMITKABSTRACTMULTIWIDGETEDITOR_H
 
 #include <org_mitk_gui_qt_common_Export.h>
 
 // org mitk gui qt common plugin
 #include <QmitkAbstractRenderEditor.h>
 
 // mitk core
 #include <mitkInteractionSchemeSwitcher.h>
 
 // berry
 #include <berryIPartListener.h>
 
 // c++
 #include <memory>
 
 class QmitkAbstractMultiWidget;
 class QmitkLevelWindowWidget;
 
 class MITK_QT_COMMON QmitkAbstractMultiWidgetEditor : public QmitkAbstractRenderEditor, public berry::IPartListener
 {
   Q_OBJECT
 
 public:
 
   berryObjectMacro(QmitkAbstractMultiWidgetEditor, QmitkAbstractRenderEditor, IPartListener)
 
   static const QString EDITOR_ID;
 
   QmitkAbstractMultiWidgetEditor();
   virtual ~QmitkAbstractMultiWidgetEditor() override;
 
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual QmitkRenderWindow* GetActiveQmitkRenderWindow() const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual QHash<QString, QmitkRenderWindow*> GetQmitkRenderWindows() const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
+  virtual QmitkRenderWindow* GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const override;
+  /**
+  * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
+  */
   virtual mitk::Point3D GetSelectedPosition(const QString& id = QString()) const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual bool IsDecorationEnabled(const QString& decoration) const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual QStringList GetDecorations() const override;
   /**
   * @brief Overridden from berry::IPartListener
   */
   virtual berry::IPartListener::Events::Types GetPartEventTypes() const override;
   /**
   * @brief Overridden from berry::IPartListener
   */
   virtual void PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef) override;
   /**
   * @brief Overridden from berry::IPartListener
   */
   virtual void PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef) override;
   /**
-  * @brief Retrieve a QmitkRenderWindow by it's index.
+  * @brief Retrieve a QmitkRenderWindow by its index.
   */
   virtual QmitkRenderWindow* GetQmitkRenderWindowByIndex(int index) const;
   /**
   * @brief Retrieve a QmitkRenderWindow by the row and column position.
   */
   virtual QmitkRenderWindow* GetQmitkRenderWindowByIndex(int row, int column) const;
   /**
   * @brief Set the current multi widget of this editor.
   */
   virtual void SetMultiWidget(QmitkAbstractMultiWidget* multiWidget);
   /**
   * @brief Return the current multi widget of this editor.
   */
   virtual QmitkAbstractMultiWidget* GetMultiWidget() const;
   /**
   * @brief Return the number of rows of the underlying multi widget.
   */
   virtual int GetRowCount() const;
   /**
   * @brief Return the number of columns of the underlying multi widget.
   */
   virtual int GetColumnCount() const;
 
   virtual QmitkLevelWindowWidget* GetLevelWindowWidget() const = 0;
 
 public Q_SLOTS:
   /**
   * @brief A slot that can be called if the layout has been changed.
   *        This function will call the function 'SetLayout' of the multi widget where
   *        custom behavior can be implemented.
   *        Finally 'FirePropertyChange' is called to inform the workbench about an input change.
   */
   virtual void OnLayoutSet(int row, int column);
   virtual void OnSynchronize(bool synchronized);
   virtual void OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
 
 private:
 
   struct Impl;
   std::unique_ptr<Impl> m_Impl;
 
 };
 
 #endif // QMITKABSTRACTMULTIWIDGETEDITOR_H
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
index e74ee05ea4..4a582e777e 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
@@ -1,404 +1,405 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkStdMultiWidgetEditor.h"
 
 #include <berryUIException.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPreferences.h>
 
 #include <mitkColorProperty.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 #include <mitkDataStorageEditorInput.h>
 #include <mitkIDataStorageService.h>
 
 // mitk qt widgets module
 #include <QmitkInteractionSchemeToolBar.h>
 #include <QmitkLevelWindowWidget.h>
 #include <QmitkRenderWindowWidget.h>
 #include <QmitkStdMultiWidget.h>
 
 // mitk gui qt common plugin
 #include <QmitkMultiWidgetDecorationManager.h>
 
 const QString QmitkStdMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.stdmultiwidget";
 
 struct QmitkStdMultiWidgetEditor::Impl final
 {
   Impl();
   ~Impl() = default;
 
   QmitkInteractionSchemeToolBar* m_InteractionSchemeToolBar;
   QmitkLevelWindowWidget* m_LevelWindowWidget;
 
   std::unique_ptr<QmitkMultiWidgetDecorationManager> m_MultiWidgetDecorationManager;
 };
 
 QmitkStdMultiWidgetEditor::Impl::Impl()
   : m_InteractionSchemeToolBar(nullptr)
   , m_LevelWindowWidget(nullptr)
 {
 }
 
 //////////////////////////////////////////////////////////////////////////
 // QmitkStdMultiWidgetEditor
 //////////////////////////////////////////////////////////////////////////
 QmitkStdMultiWidgetEditor::QmitkStdMultiWidgetEditor()
   : m_Impl(std::make_unique<Impl>())
 {}
 
 QmitkStdMultiWidgetEditor::~QmitkStdMultiWidgetEditor()
 {
   GetSite()->GetPage()->RemovePartListener(this);
 }
 
 berry::IPartListener::Events::Types QmitkStdMultiWidgetEditor::GetPartEventTypes() const
 {
   return Events::CLOSED | Events::OPENED | Events::HIDDEN | Events::VISIBLE;
 }
 
 void QmitkStdMultiWidgetEditor::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = GetMultiWidget();
     if (nullptr != multiWidget)
     {
       //multiWidget->RemovePlanesFromDataStorage();
       //multiWidget->ActivateRenderWindowMenu(false);
     }
   }
 }
 
 void QmitkStdMultiWidgetEditor::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = GetMultiWidget();
     if (nullptr != multiWidget)
     {
       //multiWidget->AddPlanesToDataStorage();
       //multiWidget->ActivateRenderWindowMenu(true);
     }
   }
 }
 
 void QmitkStdMultiWidgetEditor::PartHidden(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = GetMultiWidget();
     if (nullptr != multiWidget)
     {
       //multiWidget->ActivateRenderWindowMenu(false);
     }
   }
 }
 
 void QmitkStdMultiWidgetEditor::PartVisible(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = GetMultiWidget();
     if (nullptr != multiWidget)
     {
       //multiWidget->ActivateRenderWindowMenu(true);
     }
   }
 }
 
 QmitkLevelWindowWidget* QmitkStdMultiWidgetEditor::GetLevelWindowWidget() const
 {
   return m_Impl->m_LevelWindowWidget;
 }
 
 void QmitkStdMultiWidgetEditor::EnableSlicingPlanes(bool enable)
 {
   const auto& multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
   if (nullptr == multiWidget)
   {
     return;
   }
   
   multiWidget->SetWidgetPlanesVisibility(enable);
 }
 
 bool QmitkStdMultiWidgetEditor::IsSlicingPlanesEnabled() const
 {
   const auto& multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
   if (nullptr == multiWidget)
   {
     return false;
   }
 
   mitk::DataNode::Pointer node = multiWidget->GetWidgetPlane1();
   if (node.IsNotNull())
   {
     bool visible = false;
     node->GetVisibility(visible, nullptr);
     return visible;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkStdMultiWidgetEditor::OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return;
   }
 
   if (mitk::InteractionSchemeSwitcher::PACSStandard == scheme)
   {
     m_Impl->m_InteractionSchemeToolBar->setVisible(true);
   }
   else
   {
     m_Impl->m_InteractionSchemeToolBar->setVisible(false);
   }
 
   multiWidget->SetInteractionScheme(scheme);
 }
 
 void QmitkStdMultiWidgetEditor::SetFocus()
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr != multiWidget)
   {
     multiWidget->setFocus();
   }
 }
 
 void QmitkStdMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   QHBoxLayout* layout = new QHBoxLayout(parent);
   layout->setContentsMargins(0, 0, 0, 0);
 
   berry::IBerryPreferences* preferences = dynamic_cast<berry::IBerryPreferences*>(GetPreferences().GetPointer());
 
   auto multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     mitk::BaseRenderer::RenderingMode::Type renderingMode = static_cast<mitk::BaseRenderer::RenderingMode::Type>(preferences->GetInt("Rendering Mode", 0));
     multiWidget = new QmitkStdMultiWidget(parent, 0, nullptr, renderingMode);
 
     // create left toolbar: interaction scheme toolbar to switch how the render window navigation behaves (in PACS mode)
     if (nullptr == m_Impl->m_InteractionSchemeToolBar)
     {
       m_Impl->m_InteractionSchemeToolBar = new QmitkInteractionSchemeToolBar(parent);
       //layout->addWidget(m_Impl->m_InteractionSchemeToolBar);
     }
     m_Impl->m_InteractionSchemeToolBar->SetInteractionEventHandler(multiWidget->GetInteractionEventHandler());
 
 
     // add center widget: the std multi widget
     layout->addWidget(multiWidget);
 
     multiWidget->SetDataStorage(GetDataStorage());
     multiWidget->InitializeMultiWidget();
     SetMultiWidget(multiWidget);
   }
 
   // create level window slider on the right side
   if (nullptr == m_Impl->m_LevelWindowWidget)
   {
     m_Impl->m_LevelWindowWidget = new QmitkLevelWindowWidget(parent);
     m_Impl->m_LevelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
 
     QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     sizePolicy.setHorizontalStretch(0);
     sizePolicy.setVerticalStretch(0);
     sizePolicy.setHeightForWidth(m_Impl->m_LevelWindowWidget->sizePolicy().hasHeightForWidth());
     m_Impl->m_LevelWindowWidget->setSizePolicy(sizePolicy);
     m_Impl->m_LevelWindowWidget->setMaximumWidth(50);
   }
 
   /*
   auto splitter = new QSplitter(parent);
   splitter->addWidget(multiWidget);
   splitter->addWidget(m_Impl->m_LevelWindowWidget);
   //layout->
   splitter->show();
   */
 
 
   //d->m_StdMultiWidget->EnableNavigationControllerEventListening();
 
   m_Impl->m_MultiWidgetDecorationManager = std::make_unique<QmitkMultiWidgetDecorationManager>(multiWidget);
 
   GetSite()->GetPage()->AddPartListener(this);
 
   InitializePreferences(preferences);
   OnPreferencesChanged(preferences);
 }
 
 void QmitkStdMultiWidgetEditor::OnPreferencesChanged(const berry::IBerryPreferences* preferences)
 {
   const auto& multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
   if (nullptr == multiWidget)
   {
     return;
   }
 
   // change and apply decoration preferences
   GetPreferenceDecorations(preferences);
   m_Impl->m_MultiWidgetDecorationManager->DecorationPreferencesChanged(preferences);
 
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = multiWidget->GetRenderWindowWidgets();
   int i = 0;
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     auto decorationColor = renderWindowWidget.second->GetDecorationColor();
     multiWidget->SetDecorationColor(i, decorationColor);
 
     ++i;
   }
 
   int crosshairgapsize = preferences->GetInt("crosshair gap size", 32);
   multiWidget->GetWidgetPlane1()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize);
   multiWidget->GetWidgetPlane2()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize);
   multiWidget->GetWidgetPlane3()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize);
 
   // zooming and panning preferences
   bool constrainedZooming = preferences->GetBool("Use constrained zooming and panning", true);
   mitk::RenderingManager::GetInstance()->SetConstrainedPanningZooming(constrainedZooming);
 
   // mouse modes switcher toolbar
   bool PACSInteractionScheme = preferences->GetBool("PACS like mouse interaction", false);
   OnInteractionSchemeChanged(PACSInteractionScheme ?
     mitk::InteractionSchemeSwitcher::PACSStandard :
     mitk::InteractionSchemeSwitcher::MITKStandard);
 
   // level window setting
   bool showLevelWindowWidget = preferences->GetBool("Show level/window widget", true);
   ShowLevelWindowWidget(showLevelWindowWidget);
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(GetDataStorage());
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkStdMultiWidgetEditor::InitializePreferences(berry::IBerryPreferences * preferences)
 {
   auto multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return;
   }
 
   GetPreferenceDecorations(preferences); //overwrite if preferences are defined
 
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = multiWidget->GetRenderWindowWidgets();
   int i = 0;
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     QString widgetName = "widget" + QString::number(i + 1);
 
     auto gradientBackgroundColors = renderWindowWidget.second->GetGradientBackgroundColors();
     preferences->Put(widgetName + " first background color", MitkColorToHex(gradientBackgroundColors.first));
     preferences->Put(widgetName + " second background color", MitkColorToHex(gradientBackgroundColors.second));
 
     auto decorationColor = renderWindowWidget.second->GetDecorationColor();
     preferences->Put(widgetName + " decoration color", MitkColorToHex(decorationColor));
 
     auto cornerAnnotation = renderWindowWidget.second->GetCornerAnnotationText();
     preferences->Put(widgetName + " corner annotation", QString::fromStdString(cornerAnnotation));
 
     ++i;
   }
 }
 
 void QmitkStdMultiWidgetEditor::GetPreferenceDecorations(const berry::IBerryPreferences * preferences)
 {
   auto multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
   if (nullptr == multiWidget)
   {
     return;
   }
 
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = multiWidget->GetRenderWindowWidgets();
   int i = 0;
   auto hexBlack = "#000000";
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     QString widgetName = "widget" + QString::number(i + 1);
+
     auto upper = preferences->Get(widgetName + " first background color", hexBlack);
     auto lower = preferences->Get(widgetName + " second background color", hexBlack);
     renderWindowWidget.second->SetGradientBackgroundColors(HexColorToMitkColor(upper), HexColorToMitkColor(lower));
 
     auto defaultDecorationColor = multiWidget->GetDecorationColor(i);
     auto decorationColor = preferences->Get(widgetName + " decoration color", MitkColorToHex(defaultDecorationColor));
     renderWindowWidget.second->SetDecorationColor(HexColorToMitkColor(decorationColor));
     
     auto defaultCornerAnnotation = renderWindowWidget.second->GetCornerAnnotationText();
     auto cornerAnnotation = preferences->Get(widgetName + " corner annotation", QString::fromStdString(defaultCornerAnnotation));
     renderWindowWidget.second->SetCornerAnnotationText(cornerAnnotation.toStdString());
 
     ++i;
   }
 }
 
 mitk::Color QmitkStdMultiWidgetEditor::HexColorToMitkColor(const QString& widgetColorInHex)
 {
   QColor qColor(widgetColorInHex);
   mitk::Color returnColor;
   float colorMax = 255.0f;
   if (widgetColorInHex.isEmpty()) // default value
   {
     returnColor[0] = 1.0;
     returnColor[1] = 1.0;
     returnColor[2] = 1.0;
     MITK_ERROR << "Using default color for unknown widget " << qPrintable(widgetColorInHex);
   }
   else
   {
     returnColor[0] = qColor.red() / colorMax;
     returnColor[1] = qColor.green() / colorMax;
     returnColor[2] = qColor.blue() / colorMax;
   }
   return returnColor;
 }
 
 QString QmitkStdMultiWidgetEditor::MitkColorToHex(const mitk::Color& color)
 {
   QColor returnColor;
   float colorMax = 255.0f;
   returnColor.setRed(static_cast<int>(color[0] * colorMax + 0.5));
   returnColor.setGreen(static_cast<int>(color[1] * colorMax + 0.5));
   returnColor.setBlue(static_cast<int>(color[2] * colorMax + 0.5));
   return returnColor.name();
 }
 
 void QmitkStdMultiWidgetEditor::ShowLevelWindowWidget(bool show)
 {
   if (show)
   {
     m_Impl->m_LevelWindowWidget->disconnect(this);
     m_Impl->m_LevelWindowWidget->SetDataStorage(GetDataStorage());
     m_Impl->m_LevelWindowWidget->show();
   }
   else
   {
     m_Impl->m_LevelWindowWidget->disconnect(this);
     m_Impl->m_LevelWindowWidget->hide();
   }
 }