diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
index e14078520e..d3bd049a66 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
@@ -1,212 +1,212 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "SimpleRenderWindowView.h"
 
 #include <QmitkRenderWindow.h>
 
 #include "org_mitk_example_gui_customviewer_views_Activator.h"
 #include <berryIBerryPreferences.h>
 #include <ctkServiceTracker.h>
 #include <mitkIRenderingManager.h>
 #include <mitkInteractionConst.h>
 #include <mitkSliceNavigationController.h>
 
 #include <QVBoxLayout>
 #include <mitkPlaneGeometry.h>
 
 /**
  * \brief Helper class adapted from QmitkAbstractRenderEditor by defining the correct plugin context.
  *
  *  This helper class adapted from QmitkAbstractRenderEditor provides the rendering manager interface.
  */
 // //! [SimpleRenderWindowViewHelper]
 class AbstractRenderWindowViewPrivate
 {
 public:
   AbstractRenderWindowViewPrivate()
     : m_RenderingManagerInterface(mitk::MakeRenderingManagerInterface(mitk::RenderingManager::GetInstance())),
       m_PrefServiceTracker(org_mitk_example_gui_customviewer_views_Activator::GetPluginContext())
   // //! [SimpleRenderWindowViewHelper]
   {
     m_PrefServiceTracker.open();
   }
 
   ~AbstractRenderWindowViewPrivate() { delete m_RenderingManagerInterface; }
   mitk::IRenderingManager *m_RenderingManagerInterface;
   ctkServiceTracker<berry::IPreferencesService *> m_PrefServiceTracker;
   berry::IBerryPreferences::Pointer m_Prefs;
 };
 
 const std::string SimpleRenderWindowView::VIEW_ID = "org.mitk.customviewer.views.simplerenderwindowview";
 
 SimpleRenderWindowView::SimpleRenderWindowView() : m_RenderWindow(nullptr), d(new AbstractRenderWindowViewPrivate)
 {
 }
 
 SimpleRenderWindowView::~SimpleRenderWindowView()
 {
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetActiveQmitkRenderWindow() const
 {
   return m_RenderWindow;
 }
 
 QHash<QString, QmitkRenderWindow *> SimpleRenderWindowView::GetRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow *> wnds;
   wnds.insert("axial", m_RenderWindow);
   return wnds;
 }
 
 QHash<QString, QmitkRenderWindow *> SimpleRenderWindowView::GetQmitkRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow *> wnds;
   wnds.insert("axial", m_RenderWindow);
   return wnds;
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetRenderWindow(const QString &id) const
 {
   if (id == "axial")
   {
     return m_RenderWindow;
   }
   return nullptr;
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetQmitkRenderWindow(const QString &id) const
 {
   if (id == "axial")
   {
     return m_RenderWindow;
   }
   return nullptr;
 }
 
-QmitkRenderWindow *SimpleRenderWindowView::GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection &viewDirection) const
+QmitkRenderWindow *SimpleRenderWindowView::GetQmitkRenderWindow(const mitk::AnatomicalPlane& orientation) const
 {
-  if (viewDirection == mitk::BaseRenderer::ViewDirection::AXIAL)
+  if (orientation == mitk::AnatomicalPlane::Axial)
   {
     return m_RenderWindow;
   }
   return 0;
 }
 
 void SimpleRenderWindowView::SetFocus()
 {
   m_RenderWindow->setFocus();
 }
 
 // //! [SimpleRenderWindowViewCreatePartControl]
 void SimpleRenderWindowView::CreateQtPartControl(QWidget *parent)
 {
   QVBoxLayout *layout = new QVBoxLayout(parent);
   layout->setContentsMargins(0, 0, 0, 0);
 
   m_RenderWindow = new QmitkRenderWindow(parent);
   layout->addWidget(m_RenderWindow);
 
   mitk::DataStorage::Pointer ds = this->GetDataStorage();
   m_RenderWindow->GetRenderer()->SetDataStorage(ds);
 
   this->RequestUpdate();
 }
 // //! [SimpleRenderWindowViewCreatePartControl]
 
 mitk::IRenderingManager *SimpleRenderWindowView::GetRenderingManager() const
 {
   // we use the global rendering manager here. This should maybe replaced
   // by a local one, managing only the render windows specific for the view
   return d->m_RenderingManagerInterface;
 }
 
 void SimpleRenderWindowView::RequestUpdate(mitk::RenderingManager::RequestType requestType)
 {
   if (GetRenderingManager())
     GetRenderingManager()->RequestUpdateAll(requestType);
 }
 
 void SimpleRenderWindowView::ForceImmediateUpdate(mitk::RenderingManager::RequestType requestType)
 {
   if (GetRenderingManager())
     GetRenderingManager()->ForceImmediateUpdateAll(requestType);
 }
 
 void SimpleRenderWindowView::SetReferenceGeometry(const mitk::TimeGeometry* /*referenceGeometry*/, bool /*resetCamera*/)
 {
   // not implemented
 }
 
 bool SimpleRenderWindowView::HasCoupledRenderWindows() const
 {
   return false;
 }
 
 mitk::SliceNavigationController *SimpleRenderWindowView::GetTimeNavigationController() const
 {
   if (GetRenderingManager())
     return GetRenderingManager()->GetTimeNavigationController();
   return nullptr;
 }
 
 mitk::Point3D SimpleRenderWindowView::GetSelectedPosition(const QString& /*id*/) const
 {
   const mitk::PlaneGeometry* pg = m_RenderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   if (pg)
   {
     return pg->GetCenter();
   }
   else
   {
     return mitk::Point3D();
   }
 }
 
 void SimpleRenderWindowView::SetSelectedPosition(const mitk::Point3D&, const QString&)
 {
 }
 
 mitk::TimePointType SimpleRenderWindowView::GetSelectedTimePoint(const QString& /*id*/) const
 {
   auto timeNavigator = this->GetTimeNavigationController();
   if (nullptr != timeNavigator)
   {
     return timeNavigator->GetSelectedTimePoint();
   }
   return 0;
 }
 
 void SimpleRenderWindowView::EnableDecorations(bool enable, const QStringList& decorations)
 {
   if (decorations.isEmpty() || decorations.contains(DECORATION_MENU))
   {
     m_RenderWindow->ActivateMenuWidget(enable);
   }
 }
 
 bool SimpleRenderWindowView::IsDecorationEnabled(const QString& decoration) const
 {
   if (decoration == DECORATION_MENU)
   {
     return m_RenderWindow->GetActivateMenuWidgetFlag();
   }
   return false;
 }
 
 QStringList SimpleRenderWindowView::GetDecorations() const
 {
   QStringList decorations;
   decorations << DECORATION_MENU;
   return decorations;
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.h b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.h
index ac3b152408..1c3ff52d3e 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.h
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.h
@@ -1,157 +1,157 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef SimpleRenderWindowView_H_
 #define SimpleRenderWindowView_H_
 
 #include <QmitkAbstractView.h>
 #include <berryQtViewPart.h>
 #include <mitkIRenderWindowPart.h>
 
 class QmitkRenderWindow;
 class AbstractRenderWindowViewPrivate;
 
 /**
  * \brief A view class suited for the ViewerPerspective within the custom viewer plug-in.
  *
  * This view class contributes data node rendering functionality to the ViewerPerspective.
  * Being a subclass of QmitkAbstractView, this class yields access to the data storage and
  * thus is interconnected with the mitk::QmitkDataManagerView present in the same perspective.
  * As a subclass of mitk::IRenderWindowPart, this class provides an instance of QmitkRenderWindow.
  * A SimpleRenderWindowView instance is part of the ViewerPerspective for data visualization.
  */
 // //! [SimpleRenderWindowViewDeclaration]
 class SimpleRenderWindowView : public QmitkAbstractView, public mitk::IRenderWindowPart
 // //! [SimpleRenderWindowViewDeclaration]
 {
   Q_OBJECT
 
 public:
   /**
    * Standard constructor.
    */
   SimpleRenderWindowView();
 
   ~SimpleRenderWindowView() override;
 
   /**
    *  String based view identifier.
    */
   static const std::string VIEW_ID;
 
   berryObjectMacro(SimpleRenderWindowView);
 
   // -------------------  mitk::IRenderWindowPart  ----------------------
 
   /**
    * \see mitk::IRenderWindowPart::GetActiveQmitkRenderWindow()
    */
   QmitkRenderWindow *GetActiveQmitkRenderWindow() const override;
 
   QHash<QString, QmitkRenderWindow *> GetRenderWindows() const;
 
   /**
    * \see mitk::IRenderWindowPart::GetQmitkRenderWindows()
    */
   QHash<QString, QmitkRenderWindow *> GetQmitkRenderWindows() const override;
 
   QmitkRenderWindow *GetRenderWindow(const QString &id) const;
 
   /**
    * \see mitk::IRenderWindowPart::GetQmitkRenderWindow(QString)
    */
   QmitkRenderWindow *GetQmitkRenderWindow(const QString &id) const override;
 
   /**
-  * \see mitk::IRenderWindowPart::GetQmitkRenderWindow(mitk::BaseRenderer::ViewDirection)
+  * \see mitk::IRenderWindowPart::GetQmitkRenderWindow(mitk::AnatomicalPlane)
   */
-  QmitkRenderWindow *GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection &viewDirection) const override;
+  QmitkRenderWindow *GetQmitkRenderWindow(const mitk::AnatomicalPlane &orientation) const override;
 
   /**
    * \see mitk::QmitkAbstractRenderEditor::GetRenderingManager()
    */
   mitk::IRenderingManager *GetRenderingManager() const override;
 
   /**
    * \see mitk::QmitkAbstractRenderEditor::RequestUpdate()
    */
   void RequestUpdate(
     mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL) override;
 
   /**
    * \see mitk::QmitkAbstractRenderEditor::ForceImmediateUpdate()
    */
   void ForceImmediateUpdate(mitk::RenderingManager::RequestType) override;
 
   /**
   * \see mitk::IRenderWindowPart::SetReferenceGeometry()
   */
   void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) override;
 
   /**
   * \see mitk::IRenderWindowPart::HasCoupledRenderWindows
   */
   bool HasCoupledRenderWindows() const override;
 
   /**
    * \see mitk::IRenderWindowPart::GetTimeNavigationController()
    */
   mitk::SliceNavigationController *GetTimeNavigationController() const override;
 
   /**
    * \see mitk::IRenderWindowPart::GetSelectionPosition()
    */
   mitk::Point3D GetSelectedPosition(const QString& id = QString()) const override;
 
   /**
    * \see mitk::IRenderWindowPart::SetSelectedPosition()
    */
   void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) override;
 
   /**
   * \see mitk::IRenderWindowPart::GetSelectedTimePoint()
   */
   mitk::TimePointType GetSelectedTimePoint(const QString& id = QString()) const override;
 
   /**
    * \see mitk::IRenderWindowPart::EnableDecorations()
    */
   void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) override;
 
   /**
    * \see mitk::IRenderWindowPart::IsDecorationEnabled()
    */
   bool IsDecorationEnabled(const QString& decoration) const override;
 
   /**
    * \see mitk::IRenderWindowPart::GetDecorations()
    */
   QStringList GetDecorations() const override; 
 
 protected:
   void SetFocus() override;
 
   /**
    * Creates the QmitkRenderWindow whose renderer is being connected to the view's data storage.
    */
   void CreateQtPartControl(QWidget *parent) override;
 
 private:
   /**
    * The view's render window.
    */
   QmitkRenderWindow *m_RenderWindow;
 
   QScopedPointer<AbstractRenderWindowViewPrivate> d;
 };
 
 #endif /*SimpleRenderWindowView_H_*/
diff --git a/Modules/Core/include/mitkBaseRenderer.h b/Modules/Core/include/mitkBaseRenderer.h
index 150e690082..f1e053d528 100644
--- a/Modules/Core/include/mitkBaseRenderer.h
+++ b/Modules/Core/include/mitkBaseRenderer.h
@@ -1,482 +1,471 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKBASERENDERER_H
 #define MITKBASERENDERER_H
 
 #include <mitkDataStorage.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkPlaneGeometryData.h>
 #include <mitkTimeGeometry.h>
 
 #include <mitkCameraController.h>
 #include <mitkCameraRotationController.h>
 #include <mitkSliceNavigationController.h>
 
 #include <mitkBindDispatcherInteractor.h>
 #include <mitkDispatcher.h>
 
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
 
 #include <map>
 #include <set>
 
 namespace mitk
 {
   class Mapper;
   class BaseLocalStorageHandler;
 
 #pragma GCC visibility push(default)
   itkEventMacroDeclaration(RendererResetEvent, itk::AnyEvent);
 #pragma GCC visibility pop
 
   /*
    * \brief Organizes the rendering process
    *
    * A BaseRenderer contains a reference to a given vtkRenderWindow
    * and a corresponding vtkRenderer.
    * The BaseRenderer defines which mapper should be used (2D / 3D)
    * and which view direction should be rendered.
    *
    * All existing BaseRenderer are stored in a static variable
    * that can be accessed / modified via the static functions.
    * VtkPropRenderer is a concrete implementation of a BaseRenderer.
    */
   class MITKCORE_EXPORT BaseRenderer : public itk::Object
   {
   public:
 
     typedef std::map<vtkRenderWindow*, BaseRenderer*> BaseRendererMapType;
     static BaseRendererMapType baseRendererMap;
 
     /**
      * \brief Defines which kind of mapper (e.g. 2D or 3D) should be used.
      */
     enum StandardMapperSlot
     {
       Standard2D = 1,
       Standard3D = 2
     };
 
-    /**
-     * \brief Defines which view direction should be rendered.
-     */
-    enum class ViewDirection
-    {
-      AXIAL = 0,
-      SAGITTAL,
-      CORONAL,
-      THREE_D
-    };
-
     static BaseRenderer* GetInstance(vtkRenderWindow* renderWindow);
     static void AddInstance(vtkRenderWindow* renderWindow, BaseRenderer* baseRenderer);
     static void RemoveInstance(vtkRenderWindow* renderWindow);
 
     static BaseRenderer* GetByName(const std::string& name);
     static vtkRenderWindow* GetRenderWindowByName(const std::string& name);
 
     /**
      * \brief Get a map of specific RenderWindows
      */
     static BaseRendererMapType GetSpecificRenderWindows(MapperSlotId mapper);
 
     /**
      * \brief Convenience function: Get a map of all 2D RenderWindows
      */
     static BaseRendererMapType GetAll2DRenderWindows();
 
     /**
      * \brief Convenience function: Get a map of all 3D RenderWindows
      */
     static BaseRendererMapType GetAll3DRenderWindows();
 
     mitkClassMacroItkParent(BaseRenderer, itk::Object);
 
     BaseRenderer(const char* name = nullptr, vtkRenderWindow* renderWindow = nullptr);
 
     void RemoveAllLocalStorages();
     void RegisterLocalStorageHandler(BaseLocalStorageHandler* lsh);
     void UnregisterLocalStorageHandler(BaseLocalStorageHandler* lsh);
 
     virtual void SetDataStorage(DataStorage* storage);
 
     virtual DataStorage::Pointer GetDataStorage() const
     {
       return m_DataStorage.GetPointer();
     }
 
     vtkRenderWindow* GetRenderWindow() const
     {
       return m_RenderWindow;
     }
 
     vtkRenderer* GetVtkRenderer() const
     {
       return m_VtkRenderer;
     }
 
     /**
      * \brief Get the dispatcher, which handles events for this base renderer.
      */
     Dispatcher::Pointer GetDispatcher() const;
 
     /**
      * \brief Set a new size for the render window.
      */
     virtual void Resize(int w, int h);
 
     /**
      * \brief Initialize the base renderer with a vtk render window.
      *        Set the new renderer for the camera controller.
      */
     virtual void InitRenderer(vtkRenderWindow* renderwindow);
 
     /**
      * \brief Set the initial size for the render window.
      */
     virtual void InitSize(int w, int h);
 
     virtual void DrawOverlayMouse(Point2D&)
     {
       MITK_INFO << "BaseRenderer::DrawOverlayMouse() should be in concret implementation OpenGLRenderer." << std::endl;
     }
 
     /**
      * \brief Set the world time geometry using the given TimeGeometry.
      *
      * Setting a new world time geometry updates the current world geometry and the
      * curent world plane geometry, using the currently selected slice and timestep.
      */
     virtual void SetWorldTimeGeometry(const mitk::TimeGeometry* geometry);
     itkGetConstObjectMacro(WorldTimeGeometry, TimeGeometry);
 
     /**
      * \brief Get the current time-extracted 3D-geometry.
      */
     itkGetConstObjectMacro(CurrentWorldGeometry, BaseGeometry);
 
     /**
      * \brief Get the current slice-extracted 2D-geometry.
      */
     itkGetConstObjectMacro(CurrentWorldPlaneGeometry, PlaneGeometry);
 
     virtual bool SetWorldGeometryToDataStorageBounds()
     {
       return false;
     }
 
     /**
      * \brief Set the slice that should be used for geometry extraction.
      *
      * The slice defines the current slice-extracted 2D-geometry (CurrentWorldPlaneGeometry).
      * Setting a new slice will update the current world geometry and the
      * curent world plane geometry.
      */
     virtual void SetSlice(unsigned int slice);
 
     itkGetConstMacro(Slice, unsigned int);
 
     /**
      * \brief Set the timestep that should be used for geometry extraction.
      *
      * The timestep defines the current time-extracted 3D-geometry (CurrentWorldGeometry).
      * Setting a new timestep will update the current world geometry and the
      * curent world plane geometry.
      */
     virtual void SetTimeStep(unsigned int timeStep);
 
     itkGetConstMacro(TimeStep, unsigned int);
 
     /**
      * \brief Get the timestep of a BaseData object which
      *        exists at the time of the currently displayed content.
      *
      * Returns -1 if there is no data at the current time.
      */
     TimeStepType GetTimeStep(const BaseData* data) const;
 
     /**
      * \brief Get the time in ms of the currently display content (geometry).
      */
     ScalarType GetTime() const;
 
     /**
      * \brief Set the world time geometry using the geometry of the given event.
      *
      * The function is triggered by a SliceNavigationController::GeometrySendEvent.
      */
     virtual void SetGeometry(const itk::EventObject& geometrySliceEvent);
 
     /**
      * \brief Set the current world plane geometry using the existing current world geometry.
      *
      * The function is triggered by a SliceNavigationController::GeometryUpdateEvent.
      */
     virtual void UpdateGeometry(const itk::EventObject& geometrySliceEvent);
 
     /**
      * \brief Set the current slice using "SetSlice" and update the current world geometry
      *        and the current world plane geometry.
      *
      * The function is triggered by a SliceNavigationController::GeometrySliceEvent.
      */
     virtual void SetGeometrySlice(const itk::EventObject& geometrySliceEvent);
 
     /**
      * \brief Set the current time using "SetTimeStep" and update the current world geometry
      *        and the current world plane geometry.
      *
      * The function is triggered by a TimeNavigationController::TimeEvent.
      */
     virtual void SetGeometryTime(const itk::EventObject& geometryTimeEvent);
 
     itkGetObjectMacro(CurrentWorldPlaneGeometryNode, DataNode);
 
     /**
      * \brief Modify the update time of the current world plane geometry and force reslicing.
      */
     void SendUpdateSlice();
 
     /**
      * \brief Get timestamp of the update time of the current world plane geometry.
      */
     itkGetMacro(CurrentWorldPlaneGeometryUpdateTime, unsigned long);
 
     /**
      * \brief Get timestamp of the update time of the current timestep.
      */
     itkGetMacro(TimeStepUpdateTime, unsigned long);
 
     /**
      * \brief Pick a world coordinate (x,y,z) given a display coordinate (x,y).
      *
      * \warning Not implemented; has to be overwritten in subclasses.
      */
     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;
     }
 
     /**
      * \brief Get the currently used mapperID.
      */
     itkGetMacro(MapperID, MapperSlotId);
     itkGetConstMacro(MapperID, MapperSlotId);
 
     /**
      * \brief Set the used mapperID.
      */
     virtual void SetMapperID(MapperSlotId id);
 
     virtual int* GetSize() const;
     virtual int* GetViewportSize() const;
 
     void SetSliceNavigationController(SliceNavigationController* SlicenavigationController);
     itkGetObjectMacro(CameraController, CameraController);
     itkGetObjectMacro(SliceNavigationController, SliceNavigationController);
     itkGetObjectMacro(CameraRotationController, CameraRotationController);
     itkGetMacro(EmptyWorldGeometry, bool);
 
     /**
      * \brief Getter/Setter for defining if the displayed region should be shifted
      *        or rescaled if the render window is resized.
      */
     itkGetMacro(KeepDisplayedRegion, bool);
     itkSetMacro(KeepDisplayedRegion, bool);
 
     /**
      * \brief Return the name of the base renderer
      */
     const char* GetName() const
     {
       return m_Name.c_str();
     }
 
     /**
      * \brief Return the size in x-direction of the base renderer.
      */
     int GetSizeX() const
     {
       return this->GetSize()[0];
     }
 
     /**
      * \brief Return the size in y-direction of the base renderer.
      */
     int GetSizeY() const
     {
       return this->GetSize()[1];
     }
 
     /**
      * \brief Return the bounds of the bounding box of the
      *        current world geometry (time-extracted 3D-geometry).
      *
      * If the geometry is empty, the bounds are set to zero.
      */
     const double* GetBounds() const;
 
     void RequestUpdate();
     void ForceImmediateUpdate();
 
     /**
      * \brief Return the number of mappers which are visible and have
      *        level-of-detail rendering enabled.
      */
     unsigned int GetNumberOfVisibleLODEnabledMappers() const;
 
     /**
      * \brief Convert a display point to the 3D world index
      *        using the geometry of the renderWindow.
      */
     void DisplayToWorld(const Point2D& displayPoint, Point3D& worldIndex) const;
 
     /**
      * \brief Convert 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;
 
     /**
      * \brief Convert a 3D world index to the display point
      *        using the geometry of the renderWindow.
      */
     void WorldToDisplay(const Point3D& worldIndex, Point2D& displayPoint) const;
 
     /**
      * \brief Convert a 3D world index to the point on the viewport
      *        using the geometry of the renderWindow.
      */
     void WorldToView(const Point3D& worldIndex, Point2D& viewPoint) const;
 
     /**
      * \brief Convert a 2D plane coordinate to the display point
      *        using the geometry of the renderWindow.
      */
     void PlaneToDisplay(const Point2D& planePointInMM, Point2D& displayPoint) const;
 
     /**
      * \brief Convert 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);
 
   protected:
 
     ~BaseRenderer() override;
 
     virtual void Update() = 0;
 
     vtkRenderWindow* m_RenderWindow;
     vtkRenderer* m_VtkRenderer;
 
     MapperSlotId m_MapperID;
     DataStorage::Pointer m_DataStorage;
     unsigned long m_LastUpdateTime;
 
     CameraController::Pointer m_CameraController;
     CameraRotationController::Pointer m_CameraRotationController;
     SliceNavigationController::Pointer m_SliceNavigationController;
 
     void UpdateCurrentGeometries();
     virtual void SetCurrentWorldPlaneGeometry(const PlaneGeometry* geometry2d);
     virtual void SetCurrentWorldGeometry(const BaseGeometry *geometry);
 
   private:
 
     /**
      * \brief Pointer to the current TimeGeometry.
      *
      * This WorldTimeGeometry is used to extract a SlicedGeometry3D,
      * using the current timestep (set via SetTimeStep).
      * The time-extracted 3D-geometry is used as the "CurrentWorldgeometry".
      * It will be set using the "SetCurrentWorldGeometry"-function.
      * A PlaneGeometry can further be extracted using the current slice (set via SetSlice).
      * The slice-extracted 2D-geometry is used as the "CurrentWorldPlaneGeometry".
      * It will be set using the "SetCurrentWorldPlaneGeometry"-function.
      */
     TimeGeometry::ConstPointer m_WorldTimeGeometry;
 
     /**
      * \brief Pointer to the current time-extracted 3D-geometry.
      *
      * This CurrentWorldGeometry is used to define the bounds for this
      * BaseRenderer.
      * It will be set using the "SetCurrentWorldGeometry"-function.
      */
     BaseGeometry::ConstPointer m_CurrentWorldGeometry;
 
     /**
      * \brief Pointer to the current slice-extracted 2D-geometry.
      *
      * This CurrentWorldPlaneGeometry is used to define the maximal
      * area (2D manifold) to be rendered in case we are doing 2D-rendering.
      * It will be set using the "SetCurrentWorldPlaneGeometry"-function.
      */
     PlaneGeometry::Pointer m_CurrentWorldPlaneGeometry;
 
     unsigned int m_Slice;
     unsigned int m_TimeStep;
 
     itk::TimeStamp m_CurrentWorldPlaneGeometryUpdateTime;
     itk::TimeStamp m_TimeStepUpdateTime;
 
     BindDispatcherInteractor* m_BindDispatcherInteractor;
 
     bool m_KeepDisplayedRegion;
 
   protected:
 
     void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
     PlaneGeometryData::Pointer m_CurrentWorldPlaneGeometryData;
     DataNode::Pointer m_CurrentWorldPlaneGeometryNode;
     unsigned long m_CurrentWorldPlaneGeometryTransformTime;
 
     std::string m_Name;
 
     double m_Bounds[6];
 
     bool m_EmptyWorldGeometry;
 
     typedef std::set<Mapper*> LODEnabledMappersType;
 
     unsigned int m_NumberOfVisibleLODEnabledMappers;
 
     std::list<BaseLocalStorageHandler*> m_RegisteredLocalStorageHandlers;
 
     bool m_ConstrainZoomingAndPanning;
   };
 } // namespace mitk
 
 #endif // MITKBASERENDERER_H
diff --git a/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h b/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
index 419d27c275..f67e9a53ff 100644
--- a/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
@@ -1,182 +1,181 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKABSTRACTMULTIWIDGET_H
 #define QMITKABSTRACTMULTIWIDGET_H
 
 // mitk qt widgets module
 #include "MitkQtWidgetsExports.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDisplayActionEventHandler.h>
 #include <mitkInteractionSchemeSwitcher.h>
 #include <mitkPoint.h>
 
 // qt
 #include <QWidget>
 
 // c++
 #include <map>
 #include <memory>
 
 class QmitkMultiWidgetLayoutManager;
 class QmitkRenderWindow;
 class QmitkRenderWindowWidget;
 
 namespace mitk
 {
   class DataStorage;
   class InteractionEventHandler;
 }
 
 /**
 * @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,
                            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) { };
   virtual void SetInteractionScheme(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
 
   mitk::InteractionEventHandler* GetInteractionEventHandler();
   void SetDisplayActionEventHandler(std::unique_ptr<mitk::DisplayActionEventHandler> displayActionEventHandler);
   mitk::DisplayActionEventHandler* GetDisplayActionEventHandler();
 
   RenderWindowWidgetMap GetRenderWindowWidgets() const;
   RenderWindowWidgetMap Get2DRenderWindowWidgets() const;
   RenderWindowWidgetMap Get3DRenderWindowWidgets() const;
   RenderWindowWidgetPointer GetRenderWindowWidget(int row, int column) const;
   RenderWindowWidgetPointer GetRenderWindowWidget(const QString& widgetName) const;
   RenderWindowWidgetPointer GetRenderWindowWidget(const QmitkRenderWindow* renderWindow) const;
   RenderWindowHash GetRenderWindows() const;
   QmitkRenderWindow* GetRenderWindow(int row, int column) const;
   virtual QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const;
-  virtual QmitkRenderWindow* GetRenderWindow(const ViewDirection& viewDirection) const = 0;
+  virtual QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) 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();
 
   /**
    * @brief Set the reference geometry for interaction inside the render windows of the render window part.
    *
    * The concrete implementation is subclass-specific, no default implementation is provided here.
    *
    * @param referenceGeometry   The reference geometry which is used for updating the
    *                            time geometry inside the render windows.
    * @param resetCamera         If true, the camera and crosshair will be reset to the default view (centered, no zoom).
    *                            If false, the current crosshair position and the camera zoom will be stored and reset
    *                            after the reference geometry has been updated.
    */
   virtual void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) = 0;
 
   /**
   * @brief Returns true if the render windows are coupled; false if not.
   *
   * Render windows are coupled if the slice navigation controller of the render windows
   * are connected which means that always the same geometry is used for the render windows.
   */
   virtual bool HasCoupledRenderWindows() const = 0;
 
   virtual void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) = 0;
   virtual const mitk::Point3D GetSelectedPosition(const QString& widgetName) const = 0;
 
   virtual void SetCrosshairVisibility(bool visible) = 0;
   virtual bool GetCrosshairVisibility() const = 0;
   virtual void SetCrosshairGap(unsigned int gapSize) = 0;
 
   virtual void ResetCrosshair() = 0;
 
   virtual void SetWidgetPlaneMode(int mode) = 0;
 
   virtual void ActivateMenuWidget(bool state);
   virtual bool IsMenuWidgetEnabled() const;
 
   QmitkMultiWidgetLayoutManager* GetMultiWidgetLayoutManager() const;
 
 signals:
 
   void ActiveRenderWindowChanged();
 
 private slots:
 
   void OnFocusChanged(itk::Object*, const itk::EventObject& event);
 
 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 '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 42505725a6..83134b4d79 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,109 +1,109 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKMXNMULTIWIDGET_H
 #define QMITKMXNMULTIWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkAbstractMultiWidget.h"
 
 /**
 * @brief The 'QmitkMxNMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
 *        Render windows can dynamically be added and removed to change the layout of the multi widget. This
 *        is done by using the 'SetLayout'-function to define a layout. This will automatically add or remove
 *        the appropriate number of render window widgets.
 */
 class MITKQTWIDGETS_EXPORT QmitkMxNMultiWidget : public QmitkAbstractMultiWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkMxNMultiWidget(QWidget* parent = nullptr,
                       Qt::WindowFlags f = 0,
                       const QString& multiWidgetName = "mxnmulti");
 
   ~QmitkMxNMultiWidget();
 
   void InitializeMultiWidget() override;
 
   void Synchronize(bool synchronized) override;
 
   QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
-  QmitkRenderWindow* GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const override;
+  QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
 
   void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget) override;
   /**
    * @brief Set the reference geometry for interaction inside the active render windows of the MxNMultiWidget.
    *
    * @param referenceGeometry   The reference geometry which is used for updating the
    *                            time geometry inside the active render window.
    * @param resetCamera         If true, the camera and crosshair will be reset to the default view (centered, no zoom).
    *                            If false, the current crosshair position and the camera zoom will be stored and reset
    *                            after the reference geometry has been updated.
    */
   void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) override;
 
   /**
   * @brief Returns true if the render windows are coupled; false if not.
   *
   * For the MxNMultiWidget the render windows are typically decoupled.
   */
   bool HasCoupledRenderWindows() const override;
 
   void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
   const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
 
   void SetCrosshairVisibility(bool visible) override;
   bool GetCrosshairVisibility() const override;
   void SetCrosshairGap(unsigned int gapSize) override;
 
   void ResetCrosshair() override;
 
   void SetWidgetPlaneMode(int userMode) override;
 
   mitk::SliceNavigationController* GetTimeNavigationController();
 
   void AddPlanesToDataStorage();
   void RemovePlanesFromDataStorage();
 
 public Q_SLOTS:
 
   // mouse events
   void wheelEvent(QWheelEvent* e) override;
   void mousePressEvent(QMouseEvent* e) override;
   void moveEvent(QMoveEvent* e) override;
 
 Q_SIGNALS:
 
   void WheelMoved(QWheelEvent *);
   void Moved();
 
 protected:
 
   void RemoveRenderWindowWidget() override;
 
 private:
 
   void SetLayoutImpl() override;
   void SetInteractionSchemeImpl() override { }
 
   void CreateRenderWindowWidget();
 
   mitk::SliceNavigationController* m_TimeNavigationController;
 
   bool m_CrosshairVisibility;
 
 };
 
 #endif // QMITKMXNMULTIWIDGET_H
diff --git a/Modules/QtWidgets/include/QmitkRenderWindowMenu.h b/Modules/QtWidgets/include/QmitkRenderWindowMenu.h
index f0f96cb4db..3adde91d39 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindowMenu.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindowMenu.h
@@ -1,194 +1,194 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKRENDERWINDOWMENU_H
 #define QMITKRENDERWINDOWMENU_H
 
 // mitk qtwidgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkMultiWidgetLayoutManager.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 
 // qt
 #include <QAction>
 #include <QEvent>
 #include <QLabel>
 #include <QMenuBar>
 #include <QPushButton>
 #include <QTimer>
 #include <QToolButton>
 #include <QWidget>
 
 /**
  * \ingroup QmitkModule
  * \brief The QmitkRenderWindowMenu is a popup Widget which shows
  * up when the mouse cursor enter a QmitkRenderWindow.
  * The Menu Widget is located in the right top corner of each
  * RenderWindow. It includes different settings. For example
  * the layout design can be changed with the setting button. Switching
  * between full-screen mode and layout design can be done
  * with the full-screen button.
  * The popup Widget can be deactivated with ActivateMenuWidget(false) in
  * QmitkRenderWindow.
  *
  * \sa QmitkRenderWindow
  *
  */
 class MITKQTWIDGETS_EXPORT QmitkRenderWindowMenu : public QWidget
 {
   Q_OBJECT
 
 public:
 
-  using LayoutIndex = mitk::BaseRenderer::ViewDirection;
+  using LayoutIndex = mitk::AnatomicalPlane;
   using LayoutDesign = QmitkMultiWidgetLayoutManager::LayoutDesign;
 
   QmitkRenderWindowMenu(QWidget *parent = nullptr,
                         Qt::WindowFlags f = nullptr,
                         mitk::BaseRenderer *b = nullptr);
   ~QmitkRenderWindowMenu() override;
 
   /*! Return visibility of settings menu. The menu is connected with m_SettingsButton and includes
   layout direction (axial, coronal .. ) and layout design (standard layout, 2D images top,
   3D bottom ... ). */
   bool GetSettingsMenuVisibilty()
   {
     if (m_LayoutActionsMenu == nullptr)
       return false;
     else
       return m_LayoutActionsMenu->isVisible();
   }
 
   /*! Set layout index. Defines layout direction (axial, coronal, sagittal or threeD) of the parent. */
   void SetLayoutIndex(LayoutIndex layoutIndex);
 
   /*! Return layout direction of parent (axial, coronal, sagittal or threeD) */
   LayoutIndex GetLayoutIndex() { return m_Layout; }
   /*! Update list of layout design (standard layout, 2D images top, 3D bottom ..). Set action of current layout design
   to disable and all other to enable. */
   void UpdateLayoutDesignList(LayoutDesign layoutDesign);
 
   void UpdateCrosshairVisibility(bool visible);
 
   void UpdateCrosshairRotationMode(int mode);
 
 /*! Move menu widget to correct position (right upper corner). E.g. it is necessary when the full-screen mode
 is activated.*/
   void MoveWidgetToCorrectPos();
 
   void ShowMenu();
   void HideMenu();
 
 protected:
 
   /*! Reimplemented from QWidget. The paint event is a request to repaint all or part of a widget.*/
   void paintEvent(QPaintEvent *event) override;
 
   void CreateMenuWidget();
 
   /*! Create settings menu which contains layout direction and the different layout designs. */
   void CreateSettingsWidget();
 
   /*! Change Icon of full-screen button depending on full-screen mode. */
   void ChangeFullScreenIcon();
 
 Q_SIGNALS:
 
   void ResetView(); // == "global reinit"
 
   void CrosshairVisibilityChanged(bool);
 
   // \brief int parameters are enum from QmitkStdMultiWidget
   void CrosshairRotationModeChanged(int);
 
   /*! emit signal, when layout design changed by the setting menu.*/
   void LayoutDesignChanged(LayoutDesign layoutDesign);
 
 protected Q_SLOTS:
 
   /// this function is continuously called by a timer
   /// to do the auto rotation
   void AutoRotateNextStep();
 
   /// this function is invoked when the auto-rotate action
   /// is clicked
   void OnAutoRotationActionTriggered();
 
   void OnTSNumChanged(int);
 
   void OnCrosshairMenuAboutToShow();
   void OnCrosshairVisibilityChanged(bool);
   void OnCrosshairRotationModeSelected(QAction *);
 
   /*! slot for activating/deactivating the full-screen mode. The slot is connected to the clicked() event of
   m_FullScreenButton.
   Activating the full-screen maximize the current widget, deactivating restore If layout design changed by the settings
   menu, the full-Screen mode is automatically switched to false. */
   void OnFullScreenButton(bool checked);
 
   /*! Slot for opening setting menu. The slot is connected to the clicked() event of m_SettingsButton.
   The settings menu includes different layout directions (axial, coronal, sagittal and 3D) as well all layout design
   (standard layout, 2D images top, 3D bottom ..)*/
   void OnLayoutDesignButton(bool checked);
 
   void OnSetLayout(LayoutDesign layoutDesign);
 
 protected:
 
   QToolButton* m_CrosshairModeButton;
 
   QToolButton* m_FullScreenButton;
 
   QToolButton* m_LayoutDesignButton;
   QMenu* m_LayoutActionsMenu;
   QAction* m_DefaultLayoutAction;
   QAction* m_All2DTop3DBottomLayoutAction;
   QAction* m_All2DLeft3DRightLayoutAction;
   QAction* m_OneBigLayoutAction;
   QAction* m_Only2DHorizontalLayoutAction;
   QAction* m_Only2DVerticalLayoutAction;
   QAction* m_OneTop3DBottomLayoutAction;
   QAction* m_OneLeft3DRightLayoutAction;
   QAction* m_AllHorizontalLayoutAction;
   QAction* m_AllVerticalLayoutAction;
   QAction* m_RemoveOneLayoutAction;
 
   QLabel *m_TSLabel;
 
   QMenu *m_CrosshairMenu;
 
   /*! Flag if full-screen mode is activated or deactivated. */
   bool m_FullScreenMode;
 
 private:
 
   mitk::BaseRenderer::Pointer m_Renderer;
 
   QTimer* m_AutoRotationTimer;
 
   QWidget *m_Parent;
 
   //memory because mode is set to default for slice num = 1
   static unsigned int m_DefaultThickMode;
 
   int m_CrosshairRotationMode;
   bool m_CrosshairVisibility;
 
   LayoutIndex m_Layout;
   LayoutDesign m_LayoutDesign;
   LayoutDesign m_OldLayoutDesign;
 
 };
 
 #endif // QMITKRENDERWINDOWMENU_H
diff --git a/Modules/QtWidgets/include/QmitkStdMultiWidget.h b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
index c9b4e1dceb..505e38c9e4 100644
--- a/Modules/QtWidgets/include/QmitkStdMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
@@ -1,169 +1,169 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKSTDMULTIWIDGET_H
 #define QMITKSTDMULTIWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkAbstractMultiWidget.h"
 
 /**
 * @brief The 'QmitkStdMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
 *        Render windows are predefined in a 2x2 design with 3 different 2D view planes and a 3D render window.
 */
 class MITKQTWIDGETS_EXPORT QmitkStdMultiWidget : public QmitkAbstractMultiWidget
 {
   Q_OBJECT
 
 public:
   QmitkStdMultiWidget(
     QWidget *parent = nullptr,
     Qt::WindowFlags f = nullptr,
     const QString &name = "stdmulti");
 
   ~QmitkStdMultiWidget() override;
 
   virtual void InitializeMultiWidget() override;
 
   virtual QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
-  virtual QmitkRenderWindow* GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const override;
+  virtual QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
 
   /**
    * @brief Set the reference geometry for interaction inside all render windows of the StdMultiWidget.
    *
    * @param referenceGeometry   The reference geometry which is used for updating the
    *                            time geometry inside all four render windows.
    * @param resetCamera         If true, the camera and crosshair will be reset to the default view (centered, no zoom).
    *                            If false, the current crosshair position and the camera zoom will be stored and reset
    *                            after the reference geometry has been updated.
    */
   void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) override;
 
   /**
   * @brief Returns true if the render windows are coupled; false if not.
   *
   * For the StdMultiWidget the render windows are typically coupled.
   */
   bool HasCoupledRenderWindows() const override;
 
   virtual void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
   virtual const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
 
   virtual void SetCrosshairVisibility(bool) override;
   virtual bool GetCrosshairVisibility() const override;
   void SetCrosshairGap(unsigned int gapSize) override;
 
   virtual void ResetCrosshair() override;
 
   virtual void SetWidgetPlaneMode(int mode) override;
 
   mitk::SliceNavigationController* GetTimeNavigationController();
 
   void AddPlanesToDataStorage();
   void RemovePlanesFromDataStorage();
 
   /**
    * @brief Convenience method to get a render window widget.
    * @param   number of the widget (0-3)
    * @return  The render window widget
    */
   QmitkRenderWindow* GetRenderWindow(unsigned int number) const;
   QmitkRenderWindow* GetRenderWindow1() const;
   QmitkRenderWindow* GetRenderWindow2() const;
   QmitkRenderWindow* GetRenderWindow3() const;
   QmitkRenderWindow* GetRenderWindow4() const;
 
   /**
   * @brief Convenience method to get a widget plane.
   * @param   number of the widget plane (1-3)
   * @return  The widget plane as data node
   */
   mitk::DataNode::Pointer GetWidgetPlane(unsigned int number) const;
   mitk::DataNode::Pointer GetWidgetPlane1() const;
   mitk::DataNode::Pointer GetWidgetPlane2() const;
   mitk::DataNode::Pointer GetWidgetPlane3() const;
 
   /**
   * @brief SetDecorationColor Set the color of the decoration of the 4 widgets.
   *
   * This is used to color the frame of the renderwindow and the corner annatation.
   * For the first 3 widgets, this color is a property of the helper object nodes
   * which contain the respective plane geometry. For widget 4, this is a member,
   * since there is no data node for this widget.
   */
   void SetDecorationColor(unsigned int widgetNumber, mitk::Color color);
   /**
    * @brief GetDecorationColorForWidget Get the color for annotation, crosshair and rectangle.
    * @param widgetNumber Number of the renderwindow (0-3).
    * @return Color in mitk format.
    */
   mitk::Color GetDecorationColor(unsigned int widgetNumber);
 
 public Q_SLOTS:
 
   // mouse events
   virtual void mousePressEvent(QMouseEvent*) override;
   virtual void moveEvent(QMoveEvent* e) override;
   virtual void wheelEvent(QWheelEvent* e) override;
 
   void Fit();
 
   void AddDisplayPlaneSubTree();
 
   void EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p);
 
   void SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer = nullptr);
 
   void SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer = nullptr);
 
 Q_SIGNALS:
 
   void NotifyCrosshairVisibilityChanged(bool visible);
   void NotifyCrosshairRotationModeChanged(int mode);
 
   void WheelMoved(QWheelEvent *);
   void Moved();
 
 private:
 
   virtual void SetLayoutImpl() override;
   virtual void SetInteractionSchemeImpl() override { }
 
   void CreateRenderWindowWidgets();
 
   mitk::SliceNavigationController* m_TimeNavigationController;
 
   /**
   * @brief The 3 helper objects which contain the plane geometry.
   */
   mitk::DataNode::Pointer m_PlaneNode1;
   mitk::DataNode::Pointer m_PlaneNode2;
   mitk::DataNode::Pointer m_PlaneNode3;
 
   /**
    * @brief m_ParentNodeForGeometryPlanes This helper object is added to the datastorage
    * and contains the 3 planes for displaying the image geometry (crosshair and 3D planes).
    */
   mitk::DataNode::Pointer m_ParentNodeForGeometryPlanes;
 
   /**
    * @brief m_DecorationColorWidget4 color for annotation and rectangle of widget 4.
    *
    * For other widgets1-3, the color is a property of the respective data node.
    * There is no node for widget 4, hence, we need an extra member.
    */
   mitk::Color m_DecorationColorWidget4;
 
 };
 
 #endif // QMITKSTDMULTIWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index cdb9bce6f6..b0eafd2806 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,381 +1,381 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkMxNMultiWidget.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkDisplayActionEventFunctions.h>
 #include <mitkDisplayActionEventHandlerDesynchronized.h>
 #include <mitkDisplayActionEventHandlerSynchronized.h>
 
 // qt
 #include <QGridLayout>
 #include <QMessageBox>
 
 QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          const QString& multiWidgetName/* = "mxnmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, multiWidgetName)
   , m_TimeNavigationController(nullptr)
   , m_CrosshairVisibility(false)
 {
   m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
 }
 
 QmitkMxNMultiWidget::~QmitkMxNMultiWidget()
 {
   auto allRenderWindows = this->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     m_TimeNavigationController->Disconnect(renderWindow->GetSliceNavigationController());
   }
 }
 
 void QmitkMxNMultiWidget::InitializeMultiWidget()
 {
   SetLayout(1, 1);
   SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
   auto displayActionEventHandler = GetDisplayActionEventHandler();
   if (nullptr != displayActionEventHandler)
   {
     displayActionEventHandler->InitActions();
   }
 }
 
 void QmitkMxNMultiWidget::Synchronize(bool synchronized)
 {
   if (synchronized)
   {
     SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerSynchronized>());
   }
   else
   {
     SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
   }
 
   auto displayActionEventHandler = GetDisplayActionEventHandler();
   if (nullptr != displayActionEventHandler)
   {
     displayActionEventHandler->InitActions();
   }
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   if ("axial" == widgetName || "sagittal" == widgetName || "coronal" == widgetName || "3d" == widgetName)
   {
     return GetActiveRenderWindowWidget()->GetRenderWindow();
   }
 
   return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
 }
 
-QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& /*viewDirection*/) const
+QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const mitk::AnatomicalPlane& /*orientation*/) const
 {
-  // currently no mapping between view directions and render windows
+  // currently no mapping between plane orientation and render windows
   // simply return the currently active render window
   return GetActiveRenderWindowWidget()->GetRenderWindow();
 }
 
 void QmitkMxNMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
 {
   auto currentActiveRenderWindowWidget = GetActiveRenderWindowWidget();
   if (currentActiveRenderWindowWidget == activeRenderWindowWidget)
   {
     return;
   }
 
   // reset the decoration color of the previously active render window widget
   if (nullptr != currentActiveRenderWindowWidget)
   {
     auto decorationColor = currentActiveRenderWindowWidget->GetDecorationColor();
     QColor hexColor(decorationColor[0] * 255, decorationColor[1] * 255, decorationColor[2] * 255);
     currentActiveRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid " +
                                                    hexColor.name(QColor::HexRgb) + "; }");
   }
 
   // set the new decoration color of the currently active render window widget
   if (nullptr != activeRenderWindowWidget)
   {
     activeRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid #FF6464; }");
   }
 
   QmitkAbstractMultiWidget::SetActiveRenderWindowWidget(activeRenderWindowWidget);
 }
 
 void QmitkMxNMultiWidget::SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera)
 {
   auto* renderingManager = mitk::RenderingManager::GetInstance();
   mitk::Point3D currentPosition = mitk::Point3D();
   unsigned int imageTimeStep = 0;
   if (!resetCamera)
   {
     // store the current position to set it again later, if the camera should not be reset
     currentPosition = this->GetSelectedPosition("");
 
     // store the current time step to set it again later, if the camera should not be reset
     const auto currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
     if (referenceGeometry->IsValidTimePoint(currentTimePoint))
     {
       imageTimeStep = referenceGeometry->TimePointToTimeStep(currentTimePoint);
     }
   }
 
   // initialize active render window
   renderingManager->InitializeView(
     this->GetActiveRenderWindowWidget()->GetRenderWindow()->GetVtkRenderWindow(), referenceGeometry, resetCamera);
 
   if (!resetCamera)
   {
     this->SetSelectedPosition(currentPosition, "");
     renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
   }
 }
 
 bool QmitkMxNMultiWidget::HasCoupledRenderWindows() const
 {
   return false;
 }
 
 void QmitkMxNMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget;
   if (widgetName.isNull() || widgetName.isEmpty())
   {
     renderWindowWidget = GetActiveRenderWindowWidget();
   }
   else
   {
     renderWindowWidget = GetRenderWindowWidget(widgetName);
   }
 
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
     return;
   }
 
   MITK_ERROR << "Position can not be set for an unknown render window widget.";
 }
 
 const mitk::Point3D QmitkMxNMultiWidget::GetSelectedPosition(const QString& widgetName) const
 {
   RenderWindowWidgetPointer renderWindowWidget;
   if (widgetName.isNull() || widgetName.isEmpty())
   {
     renderWindowWidget = GetActiveRenderWindowWidget();
   }
   else
   {
     renderWindowWidget = GetRenderWindowWidget(widgetName);
   }
 
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->GetCrosshairPosition();
   }
 
   MITK_ERROR << "Crosshair position can not be retrieved.";
   return mitk::Point3D(0.0);
 }
 
 void QmitkMxNMultiWidget::SetCrosshairVisibility(bool visible)
 {
   // get the specific render window that sent the signal
   QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
   if (nullptr == renderWindow)
   {
     return;
   }
 
   auto renderWindowWidget = this->GetRenderWindowWidget(renderWindow);
   renderWindowWidget->SetCrosshairVisibility(visible);
 }
 
 bool QmitkMxNMultiWidget::GetCrosshairVisibility() const
 {
   // get the specific render window that sent the signal
   QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
   if (nullptr == renderWindow)
   {
     return false;
   }
 
   auto renderWindowWidget = this->GetRenderWindowWidget(renderWindow);
   return renderWindowWidget->GetCrosshairVisibility();
 }
 
 void QmitkMxNMultiWidget::SetCrosshairGap(unsigned int gapSize)
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->SetCrosshairGap(gapSize);
   }
 }
 
 void QmitkMxNMultiWidget::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   // get the specific render window that sent the signal
   QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
   if (nullptr == renderWindow)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->InitializeViewByBoundingObjects(renderWindow->GetRenderWindow(), dataStorage);
 
   SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
 }
 
 void QmitkMxNMultiWidget::SetWidgetPlaneMode(int userMode)
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   switch (userMode)
   {
     case 0:
       SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKStandard);
       break;
     case 1:
       SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationUncoupled);
       break;
     case 2:
       SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationCoupled);
       break;
     case 3:
       SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKSwivel);
       break;
   }
 }
 
 mitk::SliceNavigationController* QmitkMxNMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 void QmitkMxNMultiWidget::AddPlanesToDataStorage()
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->AddPlanesToDataStorage();
   }
 }
 
 void QmitkMxNMultiWidget::RemovePlanesFromDataStorage()
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->RemovePlanesFromDataStorage();
   }
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PUBLIC SLOTS
 // MOUSE EVENTS
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkMxNMultiWidget::mousePressEvent(QMouseEvent*)
 {
   // nothing here, but necessary for mouse interactions (.xml-configuration files)
 }
 
 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();
 }
 
 void QmitkMxNMultiWidget::RemoveRenderWindowWidget()
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   auto iterator = renderWindowWidgets.find(this->GetNameFromIndex(this->GetNumberOfRenderWindowWidgets() - 1));
   if (iterator == renderWindowWidgets.end())
   {
     return;
   }
 
   // disconnect each signal of this render window widget
   RenderWindowWidgetPointer renderWindowWidgetToRemove = iterator->second;
   m_TimeNavigationController->Disconnect(renderWindowWidgetToRemove->GetSliceNavigationController());
 
   QmitkAbstractMultiWidget::RemoveRenderWindowWidget();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::SetLayoutImpl()
 {
   int requiredRenderWindowWidgets = GetRowCount() * GetColumnCount();
   int existingRenderWindowWidgets = GetRenderWindowWidgets().size();
 
   int difference = requiredRenderWindowWidgets - existingRenderWindowWidgets;
   while (0 < difference)
   {
     // more render window widgets needed
     CreateRenderWindowWidget();
     --difference;
   }
 
   while (0 > difference)
   {
     // less render window widgets needed
     RemoveRenderWindowWidget();
     ++difference;
   }
 
   auto firstRenderWindowWidget = GetFirstRenderWindowWidget();
   if (nullptr != firstRenderWindowWidget)
   {
     SetActiveRenderWindowWidget(firstRenderWindowWidget);
   }
 
   GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
 }
 
 void QmitkMxNMultiWidget::CreateRenderWindowWidget()
 {
   // create the render window widget and connect signal / slot
   QString renderWindowWidgetName = GetNameFromIndex(GetNumberOfRenderWindowWidgets());
   RenderWindowWidgetPointer renderWindowWidget = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), true);
   renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget);
 
   auto renderWindow = renderWindowWidget->GetRenderWindow();
   auto layoutManager = GetMultiWidgetLayoutManager();
   connect(renderWindow, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(renderWindow, &QmitkRenderWindow::ResetView, this, &QmitkMxNMultiWidget::ResetCrosshair);
   connect(renderWindow, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkMxNMultiWidget::SetCrosshairVisibility);
   connect(renderWindow, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkMxNMultiWidget::SetWidgetPlaneMode);
 
   // connect time navigation controller to react on geometry time events with the render window's slice naviation controller
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow->GetSliceNavigationController());
   // reverse connection between the render window's slice navigation controller and the time navigation controller
   renderWindow->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
 }
diff --git a/Modules/QtWidgets/src/QmitkRenderWindow.cpp b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
index 29244be83f..be434f645b 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindow.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
@@ -1,505 +1,505 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkRenderWindow.h"
 
 #include "mitkInteractionKeyEvent.h"
 #include "mitkInternalEvent.h"
 #include "mitkMouseDoubleClickEvent.h"
 #include "mitkMouseMoveEvent.h"
 #include "mitkMousePressEvent.h"
 #include "mitkMouseReleaseEvent.h"
 #include "mitkMouseWheelEvent.h"
 #include <mitkStatusBar.h>
 
 #include <QCursor>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QKeyEvent>
 #include <QMouseEvent>
 #include <QResizeEvent>
 #include <QSurfaceFormat>
 #include <QTimer>
 #include <QWheelEvent>
 #include <QWindow>
 
 #include "QmitkMimeTypes.h"
 #include "QmitkRenderWindowMenu.h"
 
 QmitkRenderWindow::QmitkRenderWindow(QWidget *parent, const QString &name, mitk::VtkPropRenderer *)
   : QVTKOpenGLNativeWidget(parent)
   , m_ResendQtEvents(true)
   , m_MenuWidget(nullptr)
   , m_MenuWidgetActivated(false)
-  , m_LayoutIndex(QmitkRenderWindowMenu::LayoutIndex::AXIAL)
+  , m_LayoutIndex(QmitkRenderWindowMenu::LayoutIndex::Axial)
   , m_GeometryViolationWarningOverlay(nullptr)
 {
   m_InternalRenderWindow = vtkSmartPointer<vtkGenericOpenGLRenderWindow>::New();
   m_InternalRenderWindow->SetMultiSamples(0);
   m_InternalRenderWindow->SetAlphaBitPlanes(0);
 
   setRenderWindow(m_InternalRenderWindow);
 
   Initialize(name.toStdString().c_str());
 
   setFocusPolicy(Qt::StrongFocus);
   setMouseTracking(true);
   QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   setSizePolicy(sizePolicy);
 
   // setup overlay widget to show a warning message
   m_GeometryViolationWarningOverlay = new QmitkSimpleTextOverlayWidget(this);
   m_GeometryViolationWarningOverlay->setVisible(false);
   m_GeometryViolationWarningOverlay->SetOverlayText(
     QStringLiteral("<font class=\"warning\"><p style=\"text-align:center\">Interaction is not possible because the "
                    "render window is not aligned.</p></center></font>"));
 }
 
 QmitkRenderWindow::~QmitkRenderWindow()
 {
   Destroy(); // Destroy mitkRenderWindowBase
 }
 
 void QmitkRenderWindow::SetResendQtEvents(bool resend)
 {
   m_ResendQtEvents = resend;
 }
 
 void QmitkRenderWindow::SetLayoutIndex(QmitkRenderWindowMenu::LayoutIndex layoutIndex)
 {
   m_LayoutIndex = layoutIndex;
   if (nullptr != m_MenuWidget)
   {
     m_MenuWidget->SetLayoutIndex(layoutIndex);
   }
 }
 
 QmitkRenderWindowMenu::LayoutIndex QmitkRenderWindow::GetLayoutIndex()
 {
   if (nullptr != m_MenuWidget)
   {
     return m_MenuWidget->GetLayoutIndex();
   }
   else
   {
-    return QmitkRenderWindowMenu::LayoutIndex::AXIAL;
+    return QmitkRenderWindowMenu::LayoutIndex::Axial;
   }
 }
 
 void QmitkRenderWindow::UpdateLayoutDesignList(QmitkRenderWindowMenu::LayoutDesign layoutDesign)
 {
   if (nullptr != m_MenuWidget)
   {
     m_MenuWidget->UpdateLayoutDesignList(layoutDesign);
   }
 }
 
 void QmitkRenderWindow::UpdateCrosshairVisibility(bool visible)
 {
   m_MenuWidget->UpdateCrosshairVisibility(visible);
 }
 
 void QmitkRenderWindow::UpdateCrosshairRotationMode(int mode)
 {
   m_MenuWidget->UpdateCrosshairRotationMode(mode);
 }
 
 void QmitkRenderWindow::ActivateMenuWidget(bool state)
 {
   if (nullptr == m_MenuWidget)
   {
     m_MenuWidget = new QmitkRenderWindowMenu(this, nullptr, m_Renderer);
     m_MenuWidget->SetLayoutIndex(m_LayoutIndex);
   }
 
   m_MenuWidgetActivated = state;
 
   if (m_MenuWidgetActivated)
   {
     connect(m_MenuWidget, &QmitkRenderWindowMenu::LayoutDesignChanged, this, &QmitkRenderWindow::LayoutDesignChanged);
     connect(m_MenuWidget, &QmitkRenderWindowMenu::ResetView, this, &QmitkRenderWindow::ResetView);
     connect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairVisibilityChanged, this, &QmitkRenderWindow::CrosshairVisibilityChanged);
     connect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairRotationModeChanged, this, &QmitkRenderWindow::CrosshairRotationModeChanged);
   }
   else
   {
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::LayoutDesignChanged, this, &QmitkRenderWindow::LayoutDesignChanged);
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::ResetView, this, &QmitkRenderWindow::ResetView);
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairVisibilityChanged, this, &QmitkRenderWindow::CrosshairVisibilityChanged);
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairRotationModeChanged, this, &QmitkRenderWindow::CrosshairRotationModeChanged);
 
     m_MenuWidget->hide();
   }
 }
 
 void QmitkRenderWindow::ShowOverlayMessage(bool show)
 {
   m_GeometryViolationWarningOverlay->setVisible(show);
 }
 
 void QmitkRenderWindow::moveEvent(QMoveEvent *event)
 {
   QVTKOpenGLNativeWidget::moveEvent(event);
 
   // after a move the overlays need to be positioned
   emit moved();
 }
 
 void QmitkRenderWindow::showEvent(QShowEvent *event)
 {
   QVTKOpenGLNativeWidget::showEvent(event);
 
   // this singleshot is necessary to have the overlays positioned correctly after initial show
   // simple call of moved() is no use here!!
   QTimer::singleShot(0, this, SIGNAL(moved()));
 }
 
 bool QmitkRenderWindow::event(QEvent* e)
 {
   mitk::InteractionEvent::Pointer mitkEvent = nullptr;
   mitk::Point2D mousePosition;
   bool updateStatusBar = false;
   switch (e->type())
   {
     case QEvent::MouseMove:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mousePosition = this->GetMousePosition(me);
       mitkEvent = mitk::MouseMoveEvent::New(m_Renderer, mousePosition, GetButtonState(me), GetModifiers(me));
       updateStatusBar = true;
       break;
     }
     case QEvent::MouseButtonPress:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mitkEvent = mitk::MousePressEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
       break;
     }
     case QEvent::MouseButtonRelease:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mitkEvent = mitk::MouseReleaseEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
       break;
     }
     case QEvent::MouseButtonDblClick:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mitkEvent = mitk::MouseDoubleClickEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
       break;
     }
     case QEvent::Wheel:
     {
       auto we = static_cast<QWheelEvent *>(e);
       mousePosition = this->GetMousePosition(we);
       mitkEvent = mitk::MouseWheelEvent::New(m_Renderer, mousePosition, GetButtonState(we), GetModifiers(we), GetDelta(we));
       updateStatusBar = true;
       break;
     }
     case QEvent::KeyPress:
     {
       auto ke = static_cast<QKeyEvent*>(e);
       mitkEvent = mitk::InteractionKeyEvent::New(m_Renderer, GetKeyLetter(ke), GetModifiers(ke));
       break;
     }
     case QEvent::Resize:
     {
       if (nullptr != m_MenuWidget)
         m_MenuWidget->MoveWidgetToCorrectPos();
     }
     default:
     {
       break;
     }
   }
 
   if (mitkEvent != nullptr)
   {
     if (this->HandleEvent(mitkEvent.GetPointer())) {
       return m_ResendQtEvents ? false : true;
     }
   }
 
   if (updateStatusBar)
   {
     this->UpdateStatusBar(mousePosition);
   }
 
   return QVTKOpenGLNativeWidget::event(e);
 }
 
 void QmitkRenderWindow::enterEvent(QEvent *e)
 {
   mitk::InternalEvent::Pointer internalEvent = mitk::InternalEvent::New(m_Renderer, nullptr, "EnterRenderWindow");
 
   this->HandleEvent(internalEvent.GetPointer());
 
   if (nullptr != m_MenuWidget)
     m_MenuWidget->ShowMenu();
 
   QVTKOpenGLNativeWidget::enterEvent(e);
 }
 
 void QmitkRenderWindow::leaveEvent(QEvent *e)
 {
   auto statusBar = mitk::StatusBar::GetInstance();
   statusBar->DisplayGreyValueText("");
 
   mitk::InternalEvent::Pointer internalEvent = mitk::InternalEvent::New(m_Renderer, nullptr, "LeaveRenderWindow");
 
   this->HandleEvent(internalEvent.GetPointer());
 
   if (nullptr != m_MenuWidget)
     m_MenuWidget->HideMenu();
 
   QVTKOpenGLNativeWidget::leaveEvent(e);
 }
 
 void QmitkRenderWindow::resizeGL(int w, int h)
 {
   QVTKOpenGLNativeWidget::resizeGL(w, h);
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(renderWindow());
 }
 
 void QmitkRenderWindow::dragEnterEvent(QDragEnterEvent *event)
 {
   if (event->mimeData()->hasFormat("application/x-mitk-datanodes"))
   {
     event->accept();
   }
 }
 
 void QmitkRenderWindow::dropEvent(QDropEvent *event)
 {
   QList<mitk::DataNode *> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(event->mimeData());
   if (!dataNodeList.empty())
   {
     emit NodesDropped(this, dataNodeList.toVector().toStdVector());
   }
 }
 
 void QmitkRenderWindow::DeferredHideMenu()
 {
   MITK_DEBUG << "QmitkRenderWindow::DeferredHideMenu";
 
   if (nullptr != m_MenuWidget)
   {
     m_MenuWidget->HideMenu();
   }
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QMouseEvent *me) const
 {
   mitk::Point2D point;
   point[0] = me->x();
   // We need to convert the y component, as the display and vtk have other definitions for the y direction
   point[1] = m_Renderer->GetSizeY() - me->y();
   return point;
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QWheelEvent *we) const
 {
   mitk::Point2D point;
   point[0] = we->x();
   // We need to convert the y component, as the display and vtk have other definitions for the y direction
   point[1] = m_Renderer->GetSizeY() - we->y();
   return point;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetEventButton(QMouseEvent *me) const
 {
   mitk::InteractionEvent::MouseButtons eventButton;
   switch (me->button())
   {
   case Qt::LeftButton:
     eventButton = mitk::InteractionEvent::LeftMouseButton;
     break;
   case Qt::RightButton:
     eventButton = mitk::InteractionEvent::RightMouseButton;
     break;
   case Qt::MidButton:
     eventButton = mitk::InteractionEvent::MiddleMouseButton;
     break;
   default:
     eventButton = mitk::InteractionEvent::NoButton;
     break;
   }
   return eventButton;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QMouseEvent *me) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (me->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (me->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (me->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 mitk::InteractionEvent::ModifierKeys QmitkRenderWindow::GetModifiers(QInputEvent *me) const
 {
   mitk::InteractionEvent::ModifierKeys modifiers = mitk::InteractionEvent::NoKey;
 
   if (me->modifiers() & Qt::ALT)
   {
     modifiers = modifiers | mitk::InteractionEvent::AltKey;
   }
   if (me->modifiers() & Qt::CTRL)
   {
     modifiers = modifiers | mitk::InteractionEvent::ControlKey;
   }
   if (me->modifiers() & Qt::SHIFT)
   {
     modifiers = modifiers | mitk::InteractionEvent::ShiftKey;
   }
   return modifiers;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QWheelEvent *we) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (we->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (we->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (we->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 std::string QmitkRenderWindow::GetKeyLetter(QKeyEvent *ke) const
 {
   // Converting Qt Key Event to string element.
   std::string key = "";
   int tkey = ke->key();
   if (tkey < 128)
   { // standard ascii letter
     key = (char)toupper(tkey);
   }
   else
   { // special keys
     switch (tkey)
     {
     case Qt::Key_Return:
       key = mitk::InteractionEvent::KeyReturn;
       break;
     case Qt::Key_Enter:
       key = mitk::InteractionEvent::KeyEnter;
       break;
     case Qt::Key_Escape:
       key = mitk::InteractionEvent::KeyEsc;
       break;
     case Qt::Key_Delete:
       key = mitk::InteractionEvent::KeyDelete;
       break;
     case Qt::Key_Up:
       key = mitk::InteractionEvent::KeyArrowUp;
       break;
     case Qt::Key_Down:
       key = mitk::InteractionEvent::KeyArrowDown;
       break;
     case Qt::Key_Left:
       key = mitk::InteractionEvent::KeyArrowLeft;
       break;
     case Qt::Key_Right:
       key = mitk::InteractionEvent::KeyArrowRight;
       break;
 
     case Qt::Key_F1:
       key = mitk::InteractionEvent::KeyF1;
       break;
     case Qt::Key_F2:
       key = mitk::InteractionEvent::KeyF2;
       break;
     case Qt::Key_F3:
       key = mitk::InteractionEvent::KeyF3;
       break;
     case Qt::Key_F4:
       key = mitk::InteractionEvent::KeyF4;
       break;
     case Qt::Key_F5:
       key = mitk::InteractionEvent::KeyF5;
       break;
     case Qt::Key_F6:
       key = mitk::InteractionEvent::KeyF6;
       break;
     case Qt::Key_F7:
       key = mitk::InteractionEvent::KeyF7;
       break;
     case Qt::Key_F8:
       key = mitk::InteractionEvent::KeyF8;
       break;
     case Qt::Key_F9:
       key = mitk::InteractionEvent::KeyF9;
       break;
     case Qt::Key_F10:
       key = mitk::InteractionEvent::KeyF10;
       break;
     case Qt::Key_F11:
       key = mitk::InteractionEvent::KeyF11;
       break;
     case Qt::Key_F12:
       key = mitk::InteractionEvent::KeyF12;
       break;
 
     case Qt::Key_End:
       key = mitk::InteractionEvent::KeyEnd;
       break;
     case Qt::Key_Home:
       key = mitk::InteractionEvent::KeyPos1;
       break;
     case Qt::Key_Insert:
       key = mitk::InteractionEvent::KeyInsert;
       break;
     case Qt::Key_PageDown:
       key = mitk::InteractionEvent::KeyPageDown;
       break;
     case Qt::Key_PageUp:
       key = mitk::InteractionEvent::KeyPageUp;
       break;
     case Qt::Key_Space:
       key = mitk::InteractionEvent::KeySpace;
       break;
     }
   }
   return key;
 }
 
 int QmitkRenderWindow::GetDelta(QWheelEvent *we) const
 {
   return we->delta();
 }
 
 void QmitkRenderWindow::UpdateStatusBar(mitk::Point2D pointerPositionOnScreen)
 {
   mitk::Point3D worldPosition;
   m_Renderer->ForceImmediateUpdate();
   m_Renderer->DisplayToWorld(pointerPositionOnScreen, worldPosition);
   auto statusBar = mitk::StatusBar::GetInstance();
   statusBar->DisplayRendererInfo(worldPosition, m_Renderer->GetTime());
 }
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowMenu.cpp b/Modules/QtWidgets/src/QmitkRenderWindowMenu.cpp
index b75f46182c..ece6a28e45 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowMenu.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowMenu.cpp
@@ -1,578 +1,578 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkRenderWindowMenu.h"
 
 // mitk core
 #include "mitkProperties.h"
 #include "mitkResliceMethodProperty.h"
 
 // qt
 #include <QHBoxLayout>
 #include <QPainter>
 #include <QSize>
 #include <QSpacerItem>
 #include <QSlider>
 #include <QGroupBox>
 #include <QLine>
 #include <QRadioButton>
 #include <QWidgetAction>
 
 //#include"iconClose.xpm"
 #include "iconCrosshairMode.xpm"
 #include "iconFullScreen.xpm"
 //#include"iconHoriSplit.xpm"
 #include "iconSettings.xpm"
 //#include"iconVertiSplit.xpm"
 #include "iconLeaveFullScreen.xpm"
 
 // c++
 #include <cmath>
 
 unsigned int QmitkRenderWindowMenu::m_DefaultThickMode(1);
 
 QmitkRenderWindowMenu::QmitkRenderWindowMenu(QWidget* parent,
                                              Qt::WindowFlags flags,
                                              mitk::BaseRenderer* baseRenderer)
   : QWidget(parent, flags)
   , m_LayoutActionsMenu(nullptr)
   , m_CrosshairMenu(nullptr)
   , m_FullScreenMode(false)
   , m_Renderer(baseRenderer)
   , m_Parent(parent)
   , m_CrosshairRotationMode(0)
   , m_CrosshairVisibility(true)
-  , m_Layout(LayoutIndex::AXIAL)
+  , m_Layout(LayoutIndex::Axial)
   , m_LayoutDesign(LayoutDesign::DEFAULT)
   , m_OldLayoutDesign(LayoutDesign::DEFAULT)
 {
   CreateMenuWidget();
   setMinimumWidth(61); // DIRTY.. If you add or remove a button, you need to change the size.
   setMaximumWidth(61);
   setAutoFillBackground(true);
 
   this->hide();
 
   m_AutoRotationTimer = new QTimer(this);
   m_AutoRotationTimer->setInterval(75);
 
   connect(m_AutoRotationTimer, &QTimer::timeout, this, &QmitkRenderWindowMenu::AutoRotateNextStep);
   connect(m_Parent, &QObject::destroyed, this, &QmitkRenderWindowMenu::deleteLater);
 }
 
 QmitkRenderWindowMenu::~QmitkRenderWindowMenu()
 {
   if (m_AutoRotationTimer->isActive())
   {
     m_AutoRotationTimer->stop();
   }
 }
 
 void QmitkRenderWindowMenu::SetLayoutIndex(LayoutIndex layoutIndex)
 {
   m_Layout = layoutIndex;
 }
 
 void QmitkRenderWindowMenu::UpdateLayoutDesignList(LayoutDesign layoutDesign)
 {
   m_LayoutDesign = layoutDesign;
 
   if (nullptr == m_LayoutActionsMenu)
   {
     CreateSettingsWidget();
   }
 
   m_DefaultLayoutAction->setEnabled(true);
   m_All2DTop3DBottomLayoutAction->setEnabled(true);
   m_All2DLeft3DRightLayoutAction->setEnabled(true);
   m_OneBigLayoutAction->setEnabled(true);
   m_Only2DHorizontalLayoutAction->setEnabled(true);
   m_Only2DVerticalLayoutAction->setEnabled(true);
   m_OneTop3DBottomLayoutAction->setEnabled(true);
   m_OneLeft3DRightLayoutAction->setEnabled(true);
   m_AllHorizontalLayoutAction->setEnabled(true);
   m_AllVerticalLayoutAction->setEnabled(true);
   m_RemoveOneLayoutAction->setEnabled(true);
 
   switch (m_LayoutDesign)
   {
   case LayoutDesign::DEFAULT:
   {
     m_DefaultLayoutAction->setEnabled(false);
     break;
   }
   case LayoutDesign::ALL_2D_TOP_3D_BOTTOM:
   {
     m_All2DTop3DBottomLayoutAction->setEnabled(false);
     break;
   }
   case LayoutDesign::ALL_2D_LEFT_3D_RIGHT:
   {
     m_All2DLeft3DRightLayoutAction->setEnabled(false);
     break;
   }
   case LayoutDesign::ONE_BIG:
   {
     m_OneBigLayoutAction->setEnabled(false);
     break;
   }
   case LayoutDesign::ONLY_2D_HORIZONTAL:
   {
     m_Only2DHorizontalLayoutAction->setEnabled(false);
     break;
   }
   case LayoutDesign::ONLY_2D_VERTICAL:
   {
     m_Only2DVerticalLayoutAction->setEnabled(false);
     break;
   }
   case LayoutDesign::ONE_TOP_3D_BOTTOM:
   {
     m_OneTop3DBottomLayoutAction->setEnabled(false);
     break;
   }
   case LayoutDesign::ONE_LEFT_3D_RIGHT:
   {
     m_OneLeft3DRightLayoutAction->setEnabled(false);
     break;
   }
   case LayoutDesign::ALL_HORIZONTAL:
   {
     m_AllHorizontalLayoutAction->setEnabled(false);
     break;
   }
   case LayoutDesign::ALL_VERTICAL:
   {
     m_AllVerticalLayoutAction->setEnabled(false);
     break;
   }
   case LayoutDesign::REMOVE_ONE:
   {
     m_RemoveOneLayoutAction->setEnabled(false);
     break;
   }
     case LayoutDesign::NONE:
   {
     break;
   }
   }
 }
 
 void QmitkRenderWindowMenu::UpdateCrosshairVisibility(bool visible)
 {
   m_CrosshairVisibility = visible;
 }
 
 void QmitkRenderWindowMenu::UpdateCrosshairRotationMode(int mode)
 {
   m_CrosshairRotationMode = mode;
 }
 
 void QmitkRenderWindowMenu::MoveWidgetToCorrectPos()
 {
   int moveX = floor(static_cast<double>(this->m_Parent->width()) - static_cast<double>(this->width()) - 4.0);
   this->move(moveX, 3);
 
   auto cursorPos = this->mapFromGlobal(QCursor::pos());
 
   if (cursorPos.x() < 0 || cursorPos.x() >= this->width() ||
       cursorPos.y() < 0 || cursorPos.y() >= this->height())
   {
     this->HideMenu();
   }
   else
   {
     this->ShowMenu();
   }
 }
 
 void QmitkRenderWindowMenu::ShowMenu()
 {
   MITK_DEBUG << "menu showMenu";
   this->show();
   this->raise();
 }
 
 void QmitkRenderWindowMenu::HideMenu()
 {
   MITK_DEBUG << "menu hideEvent";
   this->hide();
 }
 
 void QmitkRenderWindowMenu::paintEvent(QPaintEvent * /*e*/)
 {
   QPainter painter(this);
   QColor semiTransparentColor = Qt::black;
   semiTransparentColor.setAlpha(255);
   painter.fillRect(rect(), semiTransparentColor);
 }
 
 void QmitkRenderWindowMenu::CreateMenuWidget()
 {
   QHBoxLayout *layout = new QHBoxLayout(this);
   layout->setAlignment(Qt::AlignRight);
   layout->setContentsMargins(1, 1, 1, 1);
 
   QSize size(13, 13);
 
   m_CrosshairMenu = new QMenu(this);
   connect(m_CrosshairMenu, &QMenu::aboutToShow, this, &QmitkRenderWindowMenu::OnCrosshairMenuAboutToShow);
 
   m_CrosshairModeButton = new QToolButton(this);
   m_CrosshairModeButton->setMaximumSize(15, 15);
   m_CrosshairModeButton->setIconSize(size);
   m_CrosshairModeButton->setMenu(m_CrosshairMenu);
   m_CrosshairModeButton->setIcon(QIcon(QPixmap(iconCrosshairMode_xpm)));
   m_CrosshairModeButton->setPopupMode(QToolButton::InstantPopup);
   m_CrosshairModeButton->setStyleSheet("QToolButton::menu-indicator { image: none; }");
   m_CrosshairModeButton->setAutoRaise(true);
   layout->addWidget(m_CrosshairModeButton);
 
   m_FullScreenButton = new QToolButton(this);
   m_FullScreenButton->setMaximumSize(15, 15);
   m_FullScreenButton->setIconSize(size);
   m_FullScreenButton->setIcon(QIcon(QPixmap(iconFullScreen_xpm)));
   m_FullScreenButton->setAutoRaise(true);
   layout->addWidget(m_FullScreenButton);
 
   m_LayoutDesignButton = new QToolButton(this);
   m_LayoutDesignButton->setMaximumSize(15, 15);
   m_LayoutDesignButton->setIconSize(size);
   m_LayoutDesignButton->setIcon(QIcon(QPixmap(iconSettings_xpm)));
   m_LayoutDesignButton->setAutoRaise(true);
   layout->addWidget(m_LayoutDesignButton);
 
   connect(m_FullScreenButton, &QToolButton::clicked, this, &QmitkRenderWindowMenu::OnFullScreenButton);
   connect(m_LayoutDesignButton, &QToolButton::clicked, this, &QmitkRenderWindowMenu::OnLayoutDesignButton);
 }
 
 void QmitkRenderWindowMenu::CreateSettingsWidget()
 {
   m_LayoutActionsMenu = new QMenu(this);
 
   m_DefaultLayoutAction = new QAction("Standard layout", m_LayoutActionsMenu);
   m_DefaultLayoutAction->setDisabled(true);
 
   m_All2DTop3DBottomLayoutAction = new QAction("All 2D top, 3D bottom", m_LayoutActionsMenu);
   m_All2DTop3DBottomLayoutAction->setDisabled(false);
 
   m_All2DLeft3DRightLayoutAction = new QAction("All 2D left, 3D right", m_LayoutActionsMenu);
   m_All2DLeft3DRightLayoutAction->setDisabled(false);
 
   m_OneBigLayoutAction = new QAction("This big", m_LayoutActionsMenu);
   m_OneBigLayoutAction->setDisabled(false);
 
   m_Only2DHorizontalLayoutAction = new QAction("Only 2D horizontal", m_LayoutActionsMenu);
   m_Only2DHorizontalLayoutAction->setDisabled(false);
 
   m_Only2DVerticalLayoutAction = new QAction("Only 2D vertical", m_LayoutActionsMenu);
   m_Only2DVerticalLayoutAction->setDisabled(false);
 
   m_OneTop3DBottomLayoutAction = new QAction("This top, 3D bottom", m_LayoutActionsMenu);
   m_OneTop3DBottomLayoutAction->setDisabled(false);
 
   m_OneLeft3DRightLayoutAction = new QAction("This left, 3D right", m_LayoutActionsMenu);
   m_OneLeft3DRightLayoutAction->setDisabled(false);
 
   m_AllHorizontalLayoutAction = new QAction("All horizontal", m_LayoutActionsMenu);
   m_AllHorizontalLayoutAction->setDisabled(false);
 
   m_AllVerticalLayoutAction = new QAction("All vertical", m_LayoutActionsMenu);
   m_AllVerticalLayoutAction->setDisabled(false);
 
   m_RemoveOneLayoutAction = new QAction("Remove this", m_LayoutActionsMenu);
   m_RemoveOneLayoutAction->setDisabled(false);
 
   m_LayoutActionsMenu->addAction(m_DefaultLayoutAction);
   m_LayoutActionsMenu->addAction(m_All2DTop3DBottomLayoutAction);
   m_LayoutActionsMenu->addAction(m_All2DLeft3DRightLayoutAction);
   m_LayoutActionsMenu->addAction(m_OneBigLayoutAction);
   m_LayoutActionsMenu->addAction(m_Only2DHorizontalLayoutAction);
   m_LayoutActionsMenu->addAction(m_Only2DVerticalLayoutAction);
   m_LayoutActionsMenu->addAction(m_OneTop3DBottomLayoutAction);
   m_LayoutActionsMenu->addAction(m_OneLeft3DRightLayoutAction);
   m_LayoutActionsMenu->addAction(m_AllHorizontalLayoutAction);
   m_LayoutActionsMenu->addAction(m_AllVerticalLayoutAction);
   m_LayoutActionsMenu->addAction(m_RemoveOneLayoutAction);
 
   m_LayoutActionsMenu->setVisible(false);
 
   connect(m_DefaultLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::DEFAULT); });
   connect(m_All2DTop3DBottomLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ALL_2D_TOP_3D_BOTTOM); });
   connect(m_All2DLeft3DRightLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ALL_2D_LEFT_3D_RIGHT); });
   connect(m_OneBigLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ONE_BIG); });
   connect(m_Only2DHorizontalLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ONLY_2D_HORIZONTAL); });
   connect(m_Only2DVerticalLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ONLY_2D_VERTICAL); });
   connect(m_OneTop3DBottomLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ONE_TOP_3D_BOTTOM); });
   connect(m_OneLeft3DRightLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ONE_LEFT_3D_RIGHT); });
   connect(m_AllHorizontalLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ALL_HORIZONTAL); });
   connect(m_AllVerticalLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ALL_VERTICAL); });
   connect(m_RemoveOneLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::REMOVE_ONE); });
 }
 
 void QmitkRenderWindowMenu::ChangeFullScreenIcon()
 {
   m_FullScreenButton->setIcon(m_FullScreenMode ? QPixmap(iconLeaveFullScreen_xpm) : QPixmap(iconFullScreen_xpm));
 }
 
 void QmitkRenderWindowMenu::AutoRotateNextStep()
 {
   if (m_Renderer->GetCameraRotationController())
   {
     m_Renderer->GetCameraRotationController()->GetSlice()->Next();
   }
 }
 
 void QmitkRenderWindowMenu::OnAutoRotationActionTriggered()
 {
   if (m_AutoRotationTimer->isActive())
   {
     m_AutoRotationTimer->stop();
     m_Renderer->GetCameraRotationController()->GetSlice()->PingPongOff();
   }
   else
   {
     m_Renderer->GetCameraRotationController()->GetSlice()->PingPongOn();
     m_AutoRotationTimer->start();
   }
 }
 
 void QmitkRenderWindowMenu::OnTSNumChanged(int num)
 {
   MITK_DEBUG << "Thickslices num: " << num << " on renderer " << m_Renderer.GetPointer();
 
   if (m_Renderer.IsNotNull())
   {
     unsigned int thickSlicesMode = 0;
     // determine the state of the thick-slice mode
     mitk::ResliceMethodProperty *resliceMethodEnumProperty = nullptr;
 
     if(m_Renderer->GetCurrentWorldPlaneGeometryNode()->GetProperty(resliceMethodEnumProperty, "reslice.thickslices") && resliceMethodEnumProperty)
     {
       thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
       if(thickSlicesMode!=0)
         m_DefaultThickMode = thickSlicesMode;
     }
 
     if(thickSlicesMode==0 && num>0) //default mode only for single slices
     {
       thickSlicesMode = m_DefaultThickMode; //mip default
       m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty("reslice.thickslices.showarea",
                                                                   mitk::BoolProperty::New(true));
     }
     if(num<1)
     {
       thickSlicesMode = 0;
       m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty("reslice.thickslices.showarea",
                                                                   mitk::BoolProperty::New(false));
     }
 
     m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty("reslice.thickslices",
                                                                 mitk::ResliceMethodProperty::New(thickSlicesMode));
     m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty("reslice.thickslices.num",
                                                                 mitk::IntProperty::New(num));
 
     m_TSLabel->setText(QString::number(num * 2 + 1));
     m_Renderer->SendUpdateSlice();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkRenderWindowMenu::OnCrosshairMenuAboutToShow()
 {
   QMenu *crosshairModesMenu = m_CrosshairMenu;
 
   crosshairModesMenu->clear();
 
   QAction *resetViewAction = new QAction(crosshairModesMenu);
   resetViewAction->setText("Reset view");
   crosshairModesMenu->addAction(resetViewAction);
   connect(resetViewAction, &QAction::triggered, this, &QmitkRenderWindowMenu::ResetView);
 
   // Show hide crosshairs
   {
     QAction *showHideCrosshairVisibilityAction = new QAction(crosshairModesMenu);
     showHideCrosshairVisibilityAction->setText("Show crosshair");
     showHideCrosshairVisibilityAction->setCheckable(true);
     showHideCrosshairVisibilityAction->setChecked(m_CrosshairVisibility);
     crosshairModesMenu->addAction(showHideCrosshairVisibilityAction);
     connect(showHideCrosshairVisibilityAction, &QAction::toggled, this, &QmitkRenderWindowMenu::OnCrosshairVisibilityChanged);
   }
 
   // Rotation mode
   {
     QAction *rotationGroupSeparator = new QAction(crosshairModesMenu);
     rotationGroupSeparator->setSeparator(true);
     rotationGroupSeparator->setText("Rotation mode");
     crosshairModesMenu->addAction(rotationGroupSeparator);
 
     QActionGroup *rotationModeActionGroup = new QActionGroup(crosshairModesMenu);
     rotationModeActionGroup->setExclusive(true);
 
     QAction *noCrosshairRotation = new QAction(crosshairModesMenu);
     noCrosshairRotation->setActionGroup(rotationModeActionGroup);
     noCrosshairRotation->setText("No crosshair rotation");
     noCrosshairRotation->setCheckable(true);
     noCrosshairRotation->setChecked(m_CrosshairRotationMode == 0);
     noCrosshairRotation->setData(0);
     crosshairModesMenu->addAction(noCrosshairRotation);
 
     QAction *singleCrosshairRotation = new QAction(crosshairModesMenu);
     singleCrosshairRotation->setActionGroup(rotationModeActionGroup);
     singleCrosshairRotation->setText("Crosshair rotation");
     singleCrosshairRotation->setCheckable(true);
     singleCrosshairRotation->setChecked(m_CrosshairRotationMode == 1);
     singleCrosshairRotation->setData(1);
     crosshairModesMenu->addAction(singleCrosshairRotation);
 
     QAction *coupledCrosshairRotation = new QAction(crosshairModesMenu);
     coupledCrosshairRotation->setActionGroup(rotationModeActionGroup);
     coupledCrosshairRotation->setText("Coupled crosshair rotation");
     coupledCrosshairRotation->setCheckable(true);
     coupledCrosshairRotation->setChecked(m_CrosshairRotationMode == 2);
     coupledCrosshairRotation->setData(2);
     crosshairModesMenu->addAction(coupledCrosshairRotation);
 
     QAction *swivelMode = new QAction(crosshairModesMenu);
     swivelMode->setActionGroup(rotationModeActionGroup);
     swivelMode->setText("Swivel mode");
     swivelMode->setCheckable(true);
     swivelMode->setChecked(m_CrosshairRotationMode == 3);
     swivelMode->setData(3);
     crosshairModesMenu->addAction(swivelMode);
 
     connect(rotationModeActionGroup, &QActionGroup::triggered, this, &QmitkRenderWindowMenu::OnCrosshairRotationModeSelected);
   }
 
   // auto rotation support
   if (m_Renderer.IsNotNull() && m_Renderer->GetMapperID() == mitk::BaseRenderer::Standard3D)
   {
     QAction *autoRotationGroupSeparator = new QAction(crosshairModesMenu);
     autoRotationGroupSeparator->setSeparator(true);
     crosshairModesMenu->addAction(autoRotationGroupSeparator);
 
     QAction *autoRotationAction = crosshairModesMenu->addAction("Auto Rotation");
     autoRotationAction->setCheckable(true);
     autoRotationAction->setChecked(m_AutoRotationTimer->isActive());
     connect(autoRotationAction, &QAction::triggered, this, &QmitkRenderWindowMenu::OnAutoRotationActionTriggered);
   }
 
   // Thickslices support
   if (m_Renderer.IsNotNull() && m_Renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
   {
     QAction *thickSlicesGroupSeparator = new QAction(crosshairModesMenu);
     thickSlicesGroupSeparator->setSeparator(true);
     thickSlicesGroupSeparator->setText("ThickSlices mode");
     crosshairModesMenu->addAction(thickSlicesGroupSeparator);
 
     QActionGroup *thickSlicesActionGroup = new QActionGroup(crosshairModesMenu);
     thickSlicesActionGroup->setExclusive(true);
 
     int currentMode = 0;
     {
       mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty *>(
         m_Renderer->GetCurrentWorldPlaneGeometryNode()->GetProperty("reslice.thickslices"));
       if (m.IsNotNull())
         currentMode = m->GetValueAsId();
     }
 
     int currentNum = 1;
     {
       mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty *>(
         m_Renderer->GetCurrentWorldPlaneGeometryNode()->GetProperty("reslice.thickslices.num"));
       if (m.IsNotNull())
       {
         currentNum = m->GetValue();
       }
     }
 
     if (currentMode == 0)
       currentNum = 0;
 
     QSlider *m_TSSlider = new QSlider(crosshairModesMenu);
     m_TSSlider->setMinimum(0);
     m_TSSlider->setMaximum(50);
     m_TSSlider->setValue(currentNum);
 
     m_TSSlider->setOrientation(Qt::Horizontal);
 
     connect(m_TSSlider, &QSlider::valueChanged, this, &QmitkRenderWindowMenu::OnTSNumChanged);
 
     QHBoxLayout *tsLayout = new QHBoxLayout;
     tsLayout->setContentsMargins(4, 4, 4, 4);
     tsLayout->addWidget(new QLabel("TS: "));
     tsLayout->addWidget(m_TSSlider);
     tsLayout->addWidget(m_TSLabel = new QLabel(QString::number(currentNum * 2 + 1), this));
 
     QWidget *tsWidget = new QWidget;
     tsWidget->setLayout(tsLayout);
 
     QWidgetAction *m_TSSliderAction = new QWidgetAction(crosshairModesMenu);
     m_TSSliderAction->setDefaultWidget(tsWidget);
     crosshairModesMenu->addAction(m_TSSliderAction);
   }
 }
 
 void QmitkRenderWindowMenu::OnCrosshairVisibilityChanged(bool visible)
 {
   UpdateCrosshairVisibility(visible);
   emit CrosshairVisibilityChanged(m_CrosshairVisibility);
 }
 
 void QmitkRenderWindowMenu::OnCrosshairRotationModeSelected(QAction *action)
 {
   UpdateCrosshairRotationMode(action->data().toInt());
   emit CrosshairRotationModeChanged(m_CrosshairRotationMode);
 }
 
 void QmitkRenderWindowMenu::OnFullScreenButton(bool /*checked*/)
 {
   if (!m_FullScreenMode)
   {
     m_FullScreenMode = true;
     m_OldLayoutDesign = m_LayoutDesign;
 
     emit LayoutDesignChanged(LayoutDesign::ONE_BIG);
   }
   else
   {
     m_FullScreenMode = false;
     emit LayoutDesignChanged(m_OldLayoutDesign);
   }
 
   MoveWidgetToCorrectPos();
   ChangeFullScreenIcon();
   ShowMenu();
 }
 
 void QmitkRenderWindowMenu::OnLayoutDesignButton(bool /*checked*/)
 {
   if (nullptr == m_LayoutActionsMenu)
   {
     CreateSettingsWidget();
   }
 
   QPoint point = mapToGlobal(m_LayoutDesignButton->geometry().topLeft());
   m_LayoutActionsMenu->setVisible(true);
   m_LayoutActionsMenu->exec(point);
 }
 
 void QmitkRenderWindowMenu::OnSetLayout(LayoutDesign layoutDesign)
 {
   m_FullScreenMode = false;
   ChangeFullScreenIcon();
 
   m_LayoutDesign = layoutDesign;
   emit LayoutDesignChanged(m_LayoutDesign);
 
   ShowMenu();
 }
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
index 11585a05e9..9679e85137 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
@@ -1,424 +1,424 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkRenderWindowWidget.h"
 
 #include <mitkImage.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 // itk
 #include <itkSpatialOrientationAdapter.h>
 
 // vtk
 #include <vtkCornerAnnotation.h>
 #include <vtkTextProperty.h>
 
 QmitkRenderWindowWidget::QmitkRenderWindowWidget(QWidget* parent/* = nullptr*/,
                                                  const QString& widgetName/* = ""*/,
                                                  mitk::DataStorage* dataStorage/* = nullptr*/,
                                                  bool windowControls/* = false */)
   : QFrame(parent)
   , m_WidgetName(widgetName)
   , m_DataStorage(dataStorage)
   , m_RenderWindow(nullptr)
   , m_CrosshairManager(nullptr)
   , m_UtilityWidget(nullptr)
   , m_WindowControls(windowControls)
 {
   this->InitializeGUI();
 }
 
 QmitkRenderWindowWidget::~QmitkRenderWindowWidget()
 {
   auto sliceNavigationController = this->GetSliceNavigationController();
   if (nullptr != sliceNavigationController)
   {
     sliceNavigationController->SetCrosshairEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkRenderWindowWidget, const mitk::Point3D &>(
         this, &QmitkRenderWindowWidget::SetCrosshairPosition));
   }
 }
 
 void QmitkRenderWindowWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (dataStorage == m_DataStorage)
   {
     return;
   }
 
   m_DataStorage = dataStorage;
   if (nullptr != m_RenderWindow)
   {
     mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow())->SetDataStorage(dataStorage);
   }
 
   m_CrosshairManager->SetDataStorage(m_DataStorage);
 }
 
 mitk::SliceNavigationController* QmitkRenderWindowWidget::GetSliceNavigationController() const
 {
   return m_RenderWindow->GetSliceNavigationController();
 }
 
 void QmitkRenderWindowWidget::RequestUpdate()
 {
   mitk::RenderingManager::GetInstance()->RequestUpdate(m_RenderWindow->renderWindow());
 }
 
 void QmitkRenderWindowWidget::ForceImmediateUpdate()
 {
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(m_RenderWindow->renderWindow());
 }
 
 void QmitkRenderWindowWidget::SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower)
 {
   vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
   if (nullptr == vtkRenderer)
   {
     return;
   }
 
   m_GradientBackgroundColors.first = upper;
   m_GradientBackgroundColors.second = lower;
   vtkRenderer->SetBackground(lower[0], lower[1], lower[2]);
   vtkRenderer->SetBackground2(upper[0], upper[1], upper[2]);
 
   ShowGradientBackground(true);
 }
 
 void QmitkRenderWindowWidget::ShowGradientBackground(bool show)
 {
   m_RenderWindow->GetRenderer()->GetVtkRenderer()->SetGradientBackground(show);
 }
 
 bool QmitkRenderWindowWidget::IsGradientBackgroundOn() const
 {
   return m_RenderWindow->GetRenderer()->GetVtkRenderer()->GetGradientBackground();
 }
 
 void QmitkRenderWindowWidget::SetDecorationColor(const mitk::Color& color)
 {
   m_DecorationColor = color;
   m_CornerAnnotation->GetTextProperty()->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
 
   QColor hexColor(m_DecorationColor[0] * 255, m_DecorationColor[1] * 255, m_DecorationColor[2] * 255);
   setStyleSheet("QmitkRenderWindowWidget { border: 2px solid " + hexColor.name(QColor::HexRgb) + "; }");
 }
 
 void QmitkRenderWindowWidget::ShowColoredRectangle(bool show)
 {
   if (show)
   {
     setFrameStyle(QFrame::Box | QFrame::Plain);
   }
   else
   {
     setFrameStyle(NoFrame);
   }
 }
 
 bool QmitkRenderWindowWidget::IsColoredRectangleVisible() const
 {
   return frameStyle() > 0;
 }
 
 void QmitkRenderWindowWidget::ShowCornerAnnotation(bool show)
 {
   m_CornerAnnotation->SetVisibility(show);
 }
 
 bool QmitkRenderWindowWidget::IsCornerAnnotationVisible() const
 {
   return m_CornerAnnotation->GetVisibility() > 0;
 }
 
 void QmitkRenderWindowWidget::SetCornerAnnotationText(const std::string& cornerAnnotation)
 {
   m_CornerAnnotation->SetText(0, cornerAnnotation.c_str());
 }
 
 std::string QmitkRenderWindowWidget::GetCornerAnnotationText() const
 {
   return std::string(m_CornerAnnotation->GetText(0));
 }
 
 bool QmitkRenderWindowWidget::IsRenderWindowMenuActivated() const
 {
   return m_RenderWindow->GetActivateMenuWidgetFlag();
 }
 
 void QmitkRenderWindowWidget::SetCrosshairVisibility(bool visible)
 {
   m_CrosshairManager->SetCrosshairVisibility(visible);
   this->RequestUpdate();
 }
 
 bool QmitkRenderWindowWidget::GetCrosshairVisibility()
 {
   return m_CrosshairManager->GetCrosshairVisibility();
 }
 
 void QmitkRenderWindowWidget::SetCrosshairGap(unsigned int gapSize)
 {
   m_CrosshairManager->SetCrosshairGap(gapSize);
 }
 
 void QmitkRenderWindowWidget::AddPlanesToDataStorage()
 {
   m_CrosshairManager->AddPlanesToDataStorage();
 }
 
 void QmitkRenderWindowWidget::RemovePlanesFromDataStorage()
 {
   m_CrosshairManager->RemovePlanesFromDataStorage();
 }
 
 void QmitkRenderWindowWidget::InitializeGUI()
 {
   m_Layout = new QVBoxLayout(this);
   m_Layout->setMargin(0);
   setLayout(m_Layout);
   setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   setContentsMargins(0, 0, 0, 0);
 
   if (nullptr == m_DataStorage)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->SetDataStorage(m_DataStorage);
 
   // create render window for this render window widget
   m_RenderWindow = new QmitkRenderWindow(this, m_WidgetName, nullptr);
-  m_RenderWindow->SetLayoutIndex(mitk::BaseRenderer::ViewDirection::SAGITTAL);
+  m_RenderWindow->SetLayoutIndex(mitk::AnatomicalPlane::Sagittal);
 
   auto sliceNavigationController = this->GetSliceNavigationController();
   sliceNavigationController->SetDefaultViewDirection(mitk::AnatomicalPlane::Sagittal);
 
   if (m_WindowControls)
   {
     m_UtilityWidget = new QmitkRenderWindowUtilityWidget(this, m_RenderWindow, m_DataStorage);
     m_Layout->addWidget(m_UtilityWidget);
     connect(m_UtilityWidget, &QmitkRenderWindowUtilityWidget::ReinitAction,
       this, &QmitkRenderWindowWidget::OnReinitAction);
     connect(m_UtilityWidget, &QmitkRenderWindowUtilityWidget::ResetAction,
       this, &QmitkRenderWindowWidget::OnResetAction);
   }
 
   m_Layout->addWidget(m_RenderWindow);
 
   // set colors and corner annotation
   InitializeDecorations();
 
   // use crosshair manager
   m_CrosshairManager = mitk::CrosshairManager::New(m_DataStorage, m_RenderWindow->GetRenderer());
   sliceNavigationController->SetCrosshairEvent.AddListener(
     mitk::MessageDelegate1<QmitkRenderWindowWidget, const mitk::Point3D &>(
       this, &QmitkRenderWindowWidget::SetCrosshairPosition));
 
   // finally add observer, after all relevant objects have been created / initialized
   sliceNavigationController->ConnectGeometrySendEvent(this);
   sliceNavigationController->ConnectGeometrySliceEvent(this);
 
   mitk::TimeGeometry::ConstPointer timeGeometry = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeView(m_RenderWindow->GetVtkRenderWindow(), timeGeometry);
 }
 
 void QmitkRenderWindowWidget::InitializeDecorations()
 {
   vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
   if (nullptr == vtkRenderer)
   {
     return;
   }
 
   // initialize background color gradients
   float black[3] = { 0.0f, 0.0f, 0.0f };
   SetGradientBackgroundColors(black, black);
 
   // initialize annotation text and decoration color
   setFrameStyle(QFrame::Box | QFrame::Plain);
 
   m_CornerAnnotation = vtkSmartPointer<vtkCornerAnnotation>::New();
   m_CornerAnnotation->SetText(0, "Sagittal");
   m_CornerAnnotation->SetMaximumFontSize(12);
   if (0 == vtkRenderer->HasViewProp(m_CornerAnnotation))
   {
     vtkRenderer->AddViewProp(m_CornerAnnotation);
   }
 
   float white[3] = { 1.0f, 1.0f, 1.0f };
   SetDecorationColor(mitk::Color(white));
 }
 
 void QmitkRenderWindowWidget::SetCrosshairPosition(const mitk::Point3D& newPosition)
 {
   m_CrosshairManager->SetCrosshairPosition(newPosition);
   this->RequestUpdate();
 }
 
 mitk::Point3D QmitkRenderWindowWidget::GetCrosshairPosition() const
 {
   return m_CrosshairManager->GetCrosshairPosition();
 }
 
 void QmitkRenderWindowWidget::SetGeometry(const itk::EventObject& event)
 {
   if (!mitk::SliceNavigationController::GeometrySendEvent(nullptr, 0).CheckEvent(&event))
   {
     return;
   }
 
   auto sliceNavigationController = this->GetSliceNavigationController();
   const auto* inputTimeGeometry = sliceNavigationController->GetInputWorldTimeGeometry();
   m_CrosshairManager->ComputeOrientedTimeGeometries(inputTimeGeometry);
 
   if (m_WindowControls)
   {
     this->ComputeInvertedSliceNavigation();
   }
 }
 
 void QmitkRenderWindowWidget::SetGeometrySlice(const itk::EventObject& event)
 {
   if (!mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0).CheckEvent(&event))
   {
     return;
   }
 
   auto sliceNavigationController = this->GetSliceNavigationController();
   m_CrosshairManager->UpdateSlice(sliceNavigationController);
 }
 
 void QmitkRenderWindowWidget::ComputeInvertedSliceNavigation()
 {
   auto sliceNavigationController = this->GetSliceNavigationController();
   auto viewDirection = sliceNavigationController->GetViewDirection();
   unsigned int axis = 0;
   switch (viewDirection)
   {
     case mitk::AnatomicalPlane::Original:
       return;
     case mitk::AnatomicalPlane::Axial:
     {
       axis = 2;
       break;
     }
     case mitk::AnatomicalPlane::Coronal:
     {
       axis = 1;
       break;
     }
     case mitk::AnatomicalPlane::Sagittal:
     {
       axis = 0;
       break;
     }
   }
 
   const auto* inputTimeGeometry = sliceNavigationController->GetInputWorldTimeGeometry();
   const mitk::BaseGeometry* rendererGeometry = m_RenderWindow->GetRenderer()->GetCurrentWorldGeometry();
 
   // todo: check timepoint / timestep
   mitk::TimeStepType timeStep = sliceNavigationController->GetTime()->GetPos();
   mitk::BaseGeometry::ConstPointer geometry = inputTimeGeometry->GetGeometryForTimeStep(timeStep);
 
   mitk::AffineTransform3D::MatrixType matrix = geometry->GetIndexToWorldTransform()->GetMatrix();
   matrix.GetVnlMatrix().normalize_columns();
   mitk::AffineTransform3D::MatrixType::InternalMatrixType inverseMatrix = matrix.GetInverse();
 
   int dominantAxis = itk::Function::Max3(inverseMatrix[0][axis], inverseMatrix[1][axis], inverseMatrix[2][axis]);
 
   bool referenceGeometryAxisInverted = inverseMatrix[dominantAxis][axis] < 0;
   bool rendererZAxisInverted = rendererGeometry->GetAxisVector(2)[axis] < 0;
 
   m_UtilityWidget->SetInvertedSliceNavigation(referenceGeometryAxisInverted != rendererZAxisInverted);
 }
 
 void QmitkRenderWindowWidget::OnReinitAction(QList<mitk::DataNode::Pointer> selectedNodes)
 {
   if (selectedNodes.empty())
   {
     return;
   }
 
   auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow());
   auto boundingBoxPredicate = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false), baseRenderer));
   mitk::DataStorage::SetOfObjects::Pointer nodes = mitk::DataStorage::SetOfObjects::New();
   for (const auto& dataNode : selectedNodes)
   {
     if (boundingBoxPredicate->CheckNode(dataNode))
     {
       nodes->InsertElement(nodes->Size(), dataNode);
     }
   }
 
   if (nodes->empty())
   {
     return;
   }
 
   if (1 == nodes->Size())
   {
     auto selectedImage = dynamic_cast<mitk::Image*>(nodes->ElementAt(0)->GetData());
 
     if (nullptr != selectedImage)
     {
       mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), selectedImage->GetTimeGeometry());
       return;
     }
   }
 
   auto boundingGeometry = m_DataStorage->ComputeBoundingGeometry3D(nodes, "visible", baseRenderer);
   mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), boundingGeometry);
 }
 
 void QmitkRenderWindowWidget::OnResetAction(QList<mitk::DataNode::Pointer> selectedNodes)
 {
   if (selectedNodes.empty())
   {
     return;
   }
 
   auto selectedImage = dynamic_cast<mitk::Image*>(selectedNodes.front()->GetData());
   if (nullptr == selectedImage)
   {
     return;
   }
 
   const mitk::TimeGeometry* referenceGeometry = selectedImage->GetTimeGeometry();
   if (nullptr == referenceGeometry)
   {
     return;
   }
 
   mitk::TimeStepType imageTimeStep = 0;
 
   // store the current position to set it again later, if the camera should not be reset
   mitk::Point3D currentPosition = this->GetCrosshairPosition();
 
   // store the current time step to set it again later, if the camera should not be reset
   auto* renderingManager = mitk::RenderingManager::GetInstance();
   const auto currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
   if (referenceGeometry->IsValidTimePoint(currentTimePoint))
   {
     imageTimeStep = referenceGeometry->TimePointToTimeStep(currentTimePoint);
   }
 
   auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow());
   renderingManager->InitializeView(baseRenderer->GetRenderWindow(), referenceGeometry, false);
 
   // reset position and time step
   this->GetSliceNavigationController()->SelectSliceByPoint(currentPosition);
   renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
 }
diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index dee10d29de..3a82a7778e 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,737 +1,737 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #define SMW_INFO MITK_INFO("widget.stdmulti")
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkCameraController.h>
 #include <mitkImage.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkInteractionConst.h>
 #include <mitkLine.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkPlaneGeometryDataMapper2D.h>
 #include <mitkPointSet.h>
 #include <mitkProperties.h>
 #include <mitkStatusBar.h>
 #include <mitkDisplayActionEventHandlerStd.h>
 #include <mitkVtkLayerController.h>
 
 // qt
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 
 // vtk
 #include <vtkSmartPointer.h>
 
 // c++
 #include <iomanip>
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          const QString &name/* = "stdmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, name)
   , m_TimeNavigationController(nullptr)
 {
   m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
 }
 
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   auto allRenderWindows = this->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     m_TimeNavigationController->Disconnect(renderWindow->GetSliceNavigationController());
   }
 }
 
 void QmitkStdMultiWidget::InitializeMultiWidget()
 {
   // yellow is default color for widget4
   m_DecorationColorWidget4[0] = 1.0f;
   m_DecorationColorWidget4[1] = 1.0f;
   m_DecorationColorWidget4[2] = 0.0f;
 
   SetLayout(2, 2);
 
   // transfer colors in WorldGeometry-Nodes of the associated Renderer
   // of widget 1
   m_PlaneNode1 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetColor(GetDecorationColor(0));
 
   // of widget 2
   m_PlaneNode2 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetColor(GetDecorationColor(1));
 
   // of widget 3
   m_PlaneNode3 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetColor(GetDecorationColor(2));
 
   // the parent node
   m_ParentNodeForGeometryPlanes =
     mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
 
   AddDisplayPlaneSubTree();
 
   SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerStd>());
 
   auto displayActionEventHandler = GetDisplayActionEventHandler();
   if (nullptr != displayActionEventHandler)
   {
     displayActionEventHandler->InitActions();
   }
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   if ("axial" == widgetName)
   {
     return GetRenderWindow1();
   }
 
   if ("sagittal" == widgetName)
   {
     return GetRenderWindow2();
   }
 
   if ("coronal" == widgetName)
   {
     return GetRenderWindow3();
   }
 
   if ("3d" == widgetName)
   {
     return GetRenderWindow4();
   }
 
 
   return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
 }
 
-QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const
+QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const mitk::AnatomicalPlane& orientation) const
 {
-  return GetRenderWindow(static_cast<unsigned int>(viewDirection));
+  return GetRenderWindow(static_cast<unsigned int>(orientation));
 }
 
 void QmitkStdMultiWidget::SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera)
 {
   auto* renderingManager = mitk::RenderingManager::GetInstance();
   mitk::Point3D currentPosition = mitk::Point3D();
   unsigned int imageTimeStep = 0;
   if (!resetCamera)
   {
     // store the current position to set it again later, if the camera should not be reset
     currentPosition = this->GetSelectedPosition("");
 
     // store the current time step to set it again later, if the camera should not be reset
     const auto currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
     if (referenceGeometry->IsValidTimePoint(currentTimePoint))
     {
       imageTimeStep = referenceGeometry->TimePointToTimeStep(currentTimePoint);
     }
   }
 
   // initialize render windows
   renderingManager->InitializeViews(referenceGeometry, mitk::RenderingManager::REQUEST_UPDATE_ALL, resetCamera);
 
   if (!resetCamera)
   {
     this->SetSelectedPosition(currentPosition, "");
     renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
   }
 }
 
 bool QmitkStdMultiWidget::HasCoupledRenderWindows() const
 {
   return true;
 }
 
 void QmitkStdMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& /*widgetName*/)
 {
   GetRenderWindow1()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   GetRenderWindow2()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   GetRenderWindow3()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
 
   RequestUpdateAll();
 }
 
 const mitk::Point3D QmitkStdMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
 {
   const mitk::PlaneGeometry* plane1 = GetRenderWindow1()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry* plane2 = GetRenderWindow2()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry* plane3 = GetRenderWindow3()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ((plane1 != nullptr) && (plane2 != nullptr)
    && (plane1->IntersectionLine(plane2, line)))
   {
     mitk::Point3D point;
     if ((plane3 != nullptr) && (plane3->IntersectionPoint(line, point)))
     {
       return point;
     }
   }
 
   return mitk::Point3D();
 }
 
 void QmitkStdMultiWidget::SetCrosshairVisibility(bool visible)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible);
   }
 
   emit NotifyCrosshairVisibilityChanged(visible);
 
   RequestUpdateAll();
 }
 
 bool QmitkStdMultiWidget::GetCrosshairVisibility() const
 {
   bool crosshairVisibility = true;
 
   if (m_PlaneNode1.IsNotNull())
   {
     bool visibilityProperty = false;
     m_PlaneNode1->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   if (m_PlaneNode2.IsNotNull())
   {
     bool visibilityProperty = false;
     crosshairVisibility &= m_PlaneNode2->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   if (m_PlaneNode3.IsNotNull())
   {
     bool visibilityProperty = false;
     crosshairVisibility &= m_PlaneNode3->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   return crosshairVisibility;
 }
 
 void QmitkStdMultiWidget::SetCrosshairGap(unsigned int gapSize)
 {
   m_PlaneNode1->SetIntProperty("Crosshair.Gap Size", gapSize);
   m_PlaneNode2->SetIntProperty("Crosshair.Gap Size", gapSize);
   m_PlaneNode3->SetIntProperty("Crosshair.Gap Size", gapSize);
 }
 
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
 
   SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   switch (userMode)
   {
   case 0:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKStandard);
     break;
   case 1:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationUncoupled);
     break;
   case 2:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationCoupled);
     break;
   case 3:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKSwivel);
     break;
   }
 
   emit NotifyCrosshairRotationModeChanged(userMode);
 }
 
 mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 void QmitkStdMultiWidget::AddPlanesToDataStorage()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
    && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     dataStorage->Add(m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
   }
 }
 
 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
    && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     dataStorage->Remove(m_PlaneNode1);
     dataStorage->Remove(m_PlaneNode2);
     dataStorage->Remove(m_PlaneNode3);
     dataStorage->Remove(m_ParentNodeForGeometryPlanes);
   }
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(unsigned int number) const
 {
   switch (number)
   {
   case 0:
     return GetRenderWindow1();
   case 1:
     return GetRenderWindow2();
   case 2:
     return GetRenderWindow3();
   case 3:
     return GetRenderWindow4();
   default:
     MITK_ERROR << "Requested unknown render window";
     break;
   }
 
   return nullptr;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 0));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 1));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 0));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 1));
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1() const
 {
   return m_PlaneNode1;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2() const
 {
   return m_PlaneNode2;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3() const
 {
   return m_PlaneNode3;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(unsigned number) const
 {
   switch (number)
   {
   case 1:
     return m_PlaneNode1;
   case 2:
     return m_PlaneNode2;
   case 3:
     return m_PlaneNode3;
   default:
     MITK_ERROR << "Requested unknown render window";
     break;
   }
 
   return nullptr;
 }
 
 void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
 {
   switch (widgetNumber)
   {
   case 0:
     if (m_PlaneNode1.IsNotNull())
     {
       m_PlaneNode1->SetColor(color);
     }
     break;
   case 1:
     if (m_PlaneNode2.IsNotNull())
     {
       m_PlaneNode2->SetColor(color);
     }
     break;
   case 2:
     if (m_PlaneNode3.IsNotNull())
     {
       m_PlaneNode3->SetColor(color);
     }
     break;
   case 3:
     m_DecorationColorWidget4 = color;
     break;
   default:
     MITK_ERROR << "Decoration color for unknown widget!";
     break;
   }
 }
 
 mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber)
 {
   // The implementation looks a bit messy here, but it avoids
   // synchronization of the color of the geometry nodes and an
   // internal member here.
   // Default colors were chosen for decent visibility.
   // Feel free to change your preferences in the workbench.
   float tmp[3] = { 0.0f, 0.0f, 0.0f };
   switch (widgetNumber)
   {
   case 0:
   {
     if (m_PlaneNode1.IsNotNull())
     {
       if (m_PlaneNode1->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode1->GetProperty("color"))->GetColor();
       }
     }
     float red[3] = { 0.753f, 0.0f, 0.0f }; // This is #C00000 in hex
     return mitk::Color(red);
   }
   case 1:
   {
     if (m_PlaneNode2.IsNotNull())
     {
       if (m_PlaneNode2->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode2->GetProperty("color"))->GetColor();
       }
     }
     float green[3] = { 0.0f, 0.69f, 0.0f }; // This is #00B000 in hex
     return mitk::Color(green);
   }
   case 2:
   {
     if (m_PlaneNode3.IsNotNull())
     {
       if (m_PlaneNode3->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode3->GetProperty("color"))->GetColor();
       }
     }
     float blue[3] = { 0.0, 0.502f, 1.0f }; // This is #0080FF in hex
     return mitk::Color(blue);
   }
   case 3:
   {
     return m_DecorationColorWidget4;
   }
   default:
     MITK_ERROR << "Decoration color for unknown widget!";
     float black[3] = { 0.0f, 0.0f, 0.0f };
     return mitk::Color(black);
   }
 }
 
 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent*)
 {
   // nothing here, but necessary for mouse interactions (.xml-configuration files)
 }
 
 void QmitkStdMultiWidget::moveEvent(QMoveEvent* e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the Annotation as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 void QmitkStdMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkStdMultiWidget::Fit()
 {
   vtkSmartPointer<vtkRenderer> vtkrenderer;
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetCameraController()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
 {
   // add the displayed planes of the multiwidget to a node to which the subtree
   // @a planesSubTree points ...
 
   mitk::PlaneGeometryDataMapper2D::Pointer mapper;
 
   // ... of widget 1
   mitk::BaseRenderer* renderer1 = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow());
   m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane"));
   m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   mitk::BaseRenderer* renderer2 = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow());
   m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane"));
   m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow());
   m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane"));
   m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   m_ParentNodeForGeometryPlanes = mitk::DataNode::New();
   m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets"));
   m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true));
 }
 
 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
 {
   mitk::Point2D pointOnDisplay;
   renderer->WorldToDisplay(p, pointOnDisplay);
 
   if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] ||
     pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] ||
     pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] ||
     pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1])
   {
     mitk::Point2D pointOnPlane;
     renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane);
     renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane);
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
 {
   auto dataStorage = GetDataStorage();
   if (nullptr != dataStorage)
   {
     mitk::DataNode* dataNode = dataStorage->GetNamedNode(widgetName);
     if (dataNode != nullptr)
     {
       dataNode->SetVisibility(visible, renderer);
     }
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible, renderer);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkStdMultiWidget::SetLayoutImpl()
 {
   CreateRenderWindowWidgets();
   GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
 
   // Initialize views as axial, sagittal, coronal to all data objects in DataStorage
   auto geo = GetDataStorage()->ComputeBoundingGeometry3D(GetDataStorage()->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 }
 
 void QmitkStdMultiWidget::CreateRenderWindowWidgets()
 {
   // create axial render window (widget)
   QString renderWindowWidgetName = GetNameFromIndex(0, 0);
   RenderWindowWidgetPointer renderWindowWidget1 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow1 = renderWindowWidget1->GetRenderWindow();
   renderWindow1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::AnatomicalPlane::Axial);
   renderWindowWidget1->SetDecorationColor(GetDecorationColor(0));
   renderWindowWidget1->SetCornerAnnotationText("Axial");
-  renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(ViewDirection::AXIAL);
+  renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::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::AnatomicalPlane::Sagittal);
   renderWindowWidget2->SetDecorationColor(GetDecorationColor(1));
   renderWindowWidget2->setStyleSheet("border: 0px");
   renderWindowWidget2->SetCornerAnnotationText("Sagittal");
-  renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(ViewDirection::SAGITTAL);
+  renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::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::AnatomicalPlane::Coronal);
   renderWindowWidget3->SetDecorationColor(GetDecorationColor(2));
   renderWindowWidget3->SetCornerAnnotationText("Coronal");
-  renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(ViewDirection::CORONAL);
+  renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::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::AnatomicalPlane::Original);
   renderWindowWidget4->SetDecorationColor(GetDecorationColor(3));
   renderWindowWidget4->SetCornerAnnotationText("3D");
-  renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(ViewDirection::THREE_D);
+  renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::Original);
   mitk::BaseRenderer::GetInstance(renderWindowWidget4->GetRenderWindow()->renderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget4);
 
   SetActiveRenderWindowWidget(renderWindowWidget1);
 
   // connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow1->GetSliceNavigationController());
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow2->GetSliceNavigationController());
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow3->GetSliceNavigationController());
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow4->GetSliceNavigationController());
   renderWindow1->GetSliceNavigationController()->ConnectGeometrySendEvent(
     mitk::BaseRenderer::GetInstance(renderWindow4->renderWindow()));
 
   // reverse connection between sliceNavigationControllers and timeNavigationController
   renderWindow1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
   renderWindow2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
   renderWindow3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
   //renderWindow4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
 
   auto layoutManager = GetMultiWidgetLayoutManager();
   connect(renderWindow1, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow1, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow1, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow1, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow1, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow1, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow2, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow2, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow2, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow2, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow2, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow2, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow3, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow3, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow3, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow3, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow3, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow3, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow4, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow4, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow4, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow4, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow4, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow4, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 }
diff --git a/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h b/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
index 99ccfe8289..1673398ef5 100644
--- a/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
+++ b/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
@@ -1,218 +1,218 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef 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.
- * Additionally the defined values AXIAL, SAGITTAL, CORONAL, THREE_D from mitk::BaseRenderer
+ * Additionally the defined values Axial, Sagittal, Coronal and Original from mitk::AnatomicalPlane
  * 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.
+  * Get a render window with a specific plane orientation.
   *
-  * \param viewDirection The render window view direction.
-  * \return The QmitkRenderWindow instance for <code>viewDirection</code>
+  * \param orientation The render window plane orientation.
+  * \return The QmitkRenderWindow instance for <code>orientation</code>
   */
-  virtual QmitkRenderWindow* GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const = 0;
+  virtual QmitkRenderWindow* GetQmitkRenderWindow(const mitk::AnatomicalPlane& orientation) 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;
 
    /**
    * @brief Set the reference geometry for interaction inside the render windows of the render window part.
    *
    * @param referenceGeometry   The reference geometry which is used for updating the
    *                            time geometry inside the render windows.
    * @param resetCamera         If true, the camera and crosshair will be reset to the default view (centered, no zoom).
    *                            If false, the current crosshair position and the camera zoom will be stored and reset
    *                            after the reference geometry has been updated.
    */
   virtual void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) = 0;
 
   /**
   * @brief Returns true if the render windows are coupled; false if not.
   *
   * Render windows are coupled if the slice navigation controller of the render windows
   * are connected which means that always the same geometry is used for the render windows.
   */
   virtual bool HasCoupledRenderWindows() const = 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 an empty string.
    *
    * \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;
 
   /**
    * Get the time point selected in the render window with id <code>id</code>
    * or in the active render window if <code>id</code> is an empty string.
    *
    * \param id The render window id.
    * \return The currently selected position in world coordinates.
    */
   virtual TimePointType GetSelectedTimePoint(const QString& id = QString()) const = 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 55390c7ad5..916ffd34a6 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
@@ -1,241 +1,241 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "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
+QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindow(const mitk::AnatomicalPlane& orientation) const
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return nullptr;
   }
 
-  return multiWidget->GetRenderWindow(viewDirection);
+  return multiWidget->GetRenderWindow(orientation);
 }
 
 void QmitkAbstractMultiWidgetEditor::SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera)
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return;
   }
 
   multiWidget->SetReferenceGeometry(referenceGeometry, resetCamera);
 }
 
 bool QmitkAbstractMultiWidgetEditor::HasCoupledRenderWindows() const
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return false;
   }
 
   return multiWidget->HasCoupledRenderWindows();
 }
 
 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();
 }
 
 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 c053a419c6..ac66afd25e 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
@@ -1,135 +1,135 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef 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;
+  virtual QmitkRenderWindow* GetQmitkRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   bool HasCoupledRenderWindows() 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 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