diff --git a/Modules/Core/include/mitkBaseRenderer.h b/Modules/Core/include/mitkBaseRenderer.h
index a1a924a309..9a702a84d6 100644
--- a/Modules/Core/include/mitkBaseRenderer.h
+++ b/Modules/Core/include/mitkBaseRenderer.h
@@ -1,558 +1,557 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4
 #define BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4
 
 #include "mitkCameraRotationController.h"
 #include "mitkDataStorage.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlaneGeometryData.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkTimeGeometry.h"
 
 #include "mitkBindDispatcherInteractor.h"
 #include "mitkDispatcher.h"
 
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
 
 #include <map>
 #include <set>
 
 // DEPRECATED
 #include <mitkTimeSlicedGeometry.h>
 
 namespace mitk
 {
   class NavigationController;
   class SliceNavigationController;
   class CameraRotationController;
   class CameraController;
   class DataStorage;
   class Mapper;
   class BaseLocalStorageHandler;
   class KeyEvent;
 
   //##Documentation
   //## @brief Organizes the rendering process
   //##
   //## Organizes the rendering process. A Renderer contains a reference to a
   //## DataStorage and asks the mappers of the data objects to render
   //## the data into the renderwindow it is associated to.
   //##
   //## \#Render() checks if rendering is currently allowed by calling
   //## RenderWindow::PrepareRendering(). Initialization of a rendering context
   //## can also be performed in this method.
   //##
   //## The actual rendering code has been moved to \#Repaint()
   //## Both \#Repaint() and \#Update() are declared protected now.
   //##
   //## Note: Separation of the Repaint and Update processes (rendering vs
   //## creating a vtk prop tree) still needs to be worked on. The whole
   //## rendering process also should be reworked to use VTK based classes for
   //## both 2D and 3D rendering.
   //## @ingroup Renderer
   class MITKCORE_EXPORT BaseRenderer : public itk::Object
   {
   public:
     /** \brief This rendering mode enumeration is specified at various constructors
     *  of the Renderer and RenderWindow classes, which autoconfigures the
     *  respective VTK objects. This has to be done at construction time because later
     *  configuring turns out to be not working on most platforms.
     */
     struct RenderingMode
     {
       enum Type
       {
         Standard = 0,  // no multi-sampling, no depth-peeling
-        MultiSampling, // multi-sampling (antialiasing), no depth-peeling
         DepthPeeling   // no multi-sampling, depth-peeling is on (order-independant transparency)
       };
     };
 
     typedef std::map<vtkRenderWindow *, BaseRenderer *> BaseRendererMapType;
     static BaseRendererMapType baseRendererMap;
 
     static BaseRenderer *GetInstance(vtkRenderWindow *renWin);
     static void AddInstance(vtkRenderWindow *renWin, BaseRenderer *baseRenderer);
     static void RemoveInstance(vtkRenderWindow *renWin);
 
     static BaseRenderer *GetByName(const std::string &name);
     static vtkRenderWindow *GetRenderWindowByName(const std::string &name);
 
 #pragma GCC visibility push(default)
     itkEventMacro(RendererResetEvent, itk::AnyEvent);
 #pragma GCC visibility pop
 
     /** Standard class typedefs. */
     mitkClassMacroItkParent(BaseRenderer, itk::Object);
 
     BaseRenderer(const char *name = nullptr,
                  vtkRenderWindow *renWin = nullptr,
                  mitk::RenderingManager *rm = nullptr,
                  RenderingMode::Type mode = RenderingMode::Standard);
 
     //##Documentation
     //## @brief MapperSlotId defines which kind of mapper (e.g., 2D or 3D) shoud be used.
     typedef int MapperSlotId;
 
     enum StandardMapperSlot
     {
       Standard2D = 1,
       Standard3D = 2
     };
 
     virtual void SetDataStorage(DataStorage *storage); ///< set the datastorage that will be used for rendering
 
     //##Documentation
     //## return the DataStorage that is used for rendering
     virtual DataStorage::Pointer GetDataStorage() const { return m_DataStorage.GetPointer(); }
     //##Documentation
     //## @brief Access the RenderWindow into which this renderer renders.
     vtkRenderWindow *GetRenderWindow() const { return m_RenderWindow; }
     vtkRenderer *GetVtkRenderer() const { return m_VtkRenderer; }
     //##Documentation
     //## @brief Returns the Dispatcher which handles Events for this BaseRenderer
     Dispatcher::Pointer GetDispatcher() const;
 
     //##Documentation
     //## @brief Default mapper id to use.
     static const MapperSlotId defaultMapper;
 
     //##Documentation
     //## @brief Do the rendering and flush the result.
     virtual void Paint();
 
     //##Documentation
     //## @brief Initialize the RenderWindow. Should only be called from RenderWindow.
     virtual void Initialize();
 
     //##Documentation
     //## @brief Called to inform the renderer that the RenderWindow has been resized.
     virtual void Resize(int w, int h);
 
     //##Documentation
     //## @brief Initialize the renderer with a RenderWindow (@a renderwindow).
     virtual void InitRenderer(vtkRenderWindow *renderwindow);
 
     //##Documentation
     //## @brief Set the initial size. Called by RenderWindow after it has become
     //## visible for the first time.
     virtual void InitSize(int w, int h);
 
     //##Documentation
     //## @brief Draws a point on the widget.
     //## Should be used during conferences to show the position of the remote mouse
     virtual void DrawOverlayMouse(Point2D &p2d);
 
     //##Documentation
     //## @brief Set/Get the WorldGeometry (m_WorldGeometry) for 3D and 2D rendering, that describing the
     //## (maximal) area to be rendered.
     //##
     //## Depending of the type of the passed BaseGeometry more or less information can be extracted:
     //## \li if it is a PlaneGeometry (which is a sub-class of BaseGeometry), m_CurrentWorldPlaneGeometry is
     //## also set to point to it. m_WorldTimeGeometry is set to nullptr.
     //## \li if it is a TimeGeometry, m_WorldTimeGeometry is also set to point to it.
     //## If m_WorldTimeGeometry contains instances of SlicedGeometry3D, m_CurrentWorldPlaneGeometry is set to
     //## one of geometries stored in the SlicedGeometry3D according to the value of m_Slice;  otherwise
     //## a PlaneGeometry describing the top of the bounding-box of the BaseGeometry is set as the
     //## m_CurrentWorldPlaneGeometry.
     //## \li otherwise a PlaneGeometry describing the top of the bounding-box of the BaseGeometry
     //## is set as the m_CurrentWorldPlaneGeometry. m_WorldTimeGeometry is set to nullptr.
     //## @todo add calculation of PlaneGeometry describing the top of the bounding-box of the BaseGeometry
     //## when the passed BaseGeometry is not sliced.
     //## \sa m_WorldGeometry
     //## \sa m_WorldTimeGeometry
     //## \sa m_CurrentWorldPlaneGeometry
     virtual void SetWorldGeometry3D(BaseGeometry *geometry);
     virtual void SetWorldTimeGeometry(mitk::TimeGeometry *geometry);
 
     /**
     * \deprecatedSince{2013_09} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see
     * http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
     */
     DEPRECATED(void SetWorldGeometry3D(TimeSlicedGeometry *geometry));
 
     itkGetConstObjectMacro(WorldTimeGeometry, TimeGeometry) itkGetObjectMacro(WorldTimeGeometry, TimeGeometry)
 
       //##Documentation
       //## @brief Get the current 3D-worldgeometry (m_CurrentWorldGeometry) used for 3D-rendering
       itkGetConstObjectMacro(CurrentWorldGeometry, BaseGeometry)
 
       //##Documentation
       //## @brief Get the current 2D-worldgeometry (m_CurrentWorldPlaneGeometry) used for 2D-rendering
       itkGetConstObjectMacro(CurrentWorldPlaneGeometry, PlaneGeometry)
       /**
       * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometry
       */
       DEPRECATED(const PlaneGeometry *GetCurrentWorldGeometry2D())
     {
       return GetCurrentWorldPlaneGeometry();
     };
 
     //##Documentation
     //## Calculates the bounds of the DataStorage (if it contains any valid data),
     //## creates a geometry from these bounds and sets it as world geometry of the renderer.
     //##
     //## Call this method to re-initialize the renderer to the current DataStorage
     //## (e.g. after loading an additional dataset), to ensure that the view is
     //## aligned correctly.
     //## \warn This is not implemented yet.
     virtual bool SetWorldGeometryToDataStorageBounds() { return false; }
     //##Documentation
     //## @brief Set/Get m_Slice which defines together with m_TimeStep the 2D geometry
     //## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
     //##
     //## \sa m_Slice
     virtual void SetSlice(unsigned int slice);
 
     itkGetConstMacro(Slice, unsigned int)
 
       //##Documentation
       //## @brief Set/Get m_TimeStep which defines together with m_Slice the 2D geometry
       //## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
       //##
       //## \sa m_TimeStep
       virtual void SetTimeStep(unsigned int timeStep);
 
     itkGetConstMacro(TimeStep, unsigned int)
 
       //##Documentation
       //## @brief Get the time-step of a BaseData object which
       //## exists at the time of the currently displayed content
       //##
       //## Returns -1 or mitk::BaseData::m_TimeSteps if there
       //## is no data at the current time.
       //## \sa GetTimeStep, m_TimeStep
       int GetTimeStep(const BaseData *data) const;
 
     //##Documentation
     //## @brief Get the time in ms of the currently displayed content
     //##
     //## \sa GetTimeStep, m_TimeStep
     ScalarType GetTime() const;
 
     //##Documentation
     //## @brief SetWorldGeometry is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometrySendEvent
     virtual void SetGeometry(const itk::EventObject &geometrySliceEvent);
 
     //##Documentation
     //## @brief UpdateWorldGeometry is called to re-read the 2D geometry from the
     //## slice navigation controller
     virtual void UpdateGeometry(const itk::EventObject &geometrySliceEvent);
 
     //##Documentation
     //## @brief SetSlice is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometrySliceEvent
     virtual void SetGeometrySlice(const itk::EventObject &geometrySliceEvent);
 
     //##Documentation
     //## @brief SetTimeStep is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometryTimeEvent
     virtual void SetGeometryTime(const itk::EventObject &geometryTimeEvent);
 
     //##Documentation
     //## @brief Get a DataNode pointing to a data object containing the current 2D-worldgeometry
     // m_CurrentWorldPlaneGeometry (for 2D rendering)
     itkGetObjectMacro(CurrentWorldPlaneGeometryNode, DataNode)
       /**
       * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometryNode
       */
       DEPRECATED(DataNode *GetCurrentWorldGeometry2DNode())
     {
       return GetCurrentWorldPlaneGeometryNode();
     };
 
     //##Documentation
     //## @brief Sets timestamp of CurrentWorldPlaneGeometry and forces so reslicing in that renderwindow
     void SendUpdateSlice();
 
     //##Documentation
     //## @brief Get timestamp of last call of SetCurrentWorldPlaneGeometry
     unsigned long GetCurrentWorldPlaneGeometryUpdateTime() { return m_CurrentWorldPlaneGeometryUpdateTime; }
     /**
     * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometryUpdateTime
     */
     DEPRECATED(unsigned long GetCurrentWorldGeometry2DUpdateTime())
     {
       return GetCurrentWorldPlaneGeometryUpdateTime();
     };
     //##Documentation
     //## @brief Get timestamp of last change of current TimeStep
     unsigned long GetTimeStepUpdateTime() { return m_TimeStepUpdateTime; }
     //##Documentation
     //## @brief Perform a picking: find the x,y,z world coordinate of a
     //## display x,y coordinate.
     //## @warning Has to be overwritten in subclasses for the 3D-case.
     //##
     //## Implemented here only for 2D-rendering
     virtual void PickWorldPoint(const Point2D &diplayPosition, Point3D &worldPosition) const = 0;
 
     /** \brief Determines the object (mitk::DataNode) closest to the current
     * position by means of picking
     *
     * \warning Implementation currently empty for 2D rendering; intended to be
     * implemented for 3D renderers */
     virtual DataNode *PickObject(const Point2D & /*displayPosition*/, Point3D & /*worldPosition*/) const
     {
       return nullptr;
     }
 
     //##Documentation
     //## @brief Get the MapperSlotId to use.
     itkGetMacro(MapperID, MapperSlotId) itkGetConstMacro(MapperID, MapperSlotId)
 
       //##Documentation
       //## @brief Set the MapperSlotId to use.
       itkSetMacro(MapperID, MapperSlotId)
 
         virtual int *GetSize() const;
     virtual int *GetViewportSize() const;
 
     void SetSliceNavigationController(SliceNavigationController *SlicenavigationController);
     itkGetObjectMacro(CameraController, CameraController)
       itkGetObjectMacro(SliceNavigationController, SliceNavigationController)
         itkGetObjectMacro(CameraRotationController, CameraRotationController)
 
           itkGetMacro(EmptyWorldGeometry, bool)
 
       //##Documentation
       //## @brief Tells if the displayed region is shifted and rescaled if the render window is resized.
       itkGetMacro(KeepDisplayedRegion, bool)
       //##Documentation
       //## @brief Tells if the displayed region should be shifted and rescaled if the render window is resized.
       itkSetMacro(KeepDisplayedRegion, bool)
 
       //##Documentation
       //## @brief get the name of the Renderer
       //## @note
       const char *GetName() const
     {
       return m_Name.c_str();
     }
 
     //##Documentation
     //## @brief get the x_size of the RendererWindow
     //## @note
     int GetSizeX() const { return GetSize()[0]; }
     //##Documentation
     //## @brief get the y_size of the RendererWindow
     //## @note
     int GetSizeY() const { return GetSize()[1]; }
     const double *GetBounds() const;
 
     void RequestUpdate();
     void ForceImmediateUpdate();
 
     /** Returns number of mappers which are visible and have level-of-detail
     * rendering enabled */
     unsigned int GetNumberOfVisibleLODEnabledMappers() const;
 
     ///**
     //* \brief Setter for the RenderingManager that handles this instance of BaseRenderer
     //*/
     // void SetRenderingManager( mitk::RenderingManager* );
 
     /**
     * \brief Getter for the RenderingManager that handles this instance of BaseRenderer
     */
     virtual mitk::RenderingManager *GetRenderingManager() const;
 
     //##Documentation
     //## @brief This method converts a display point to the 3D world index
     //## using the geometry of the renderWindow.
     void DisplayToWorld(const Point2D &displayPoint, Point3D &worldIndex) const;
 
     //##Documentation
     //## @brief This method converts a display point to the 2D world index, mapped onto the display plane
     //## using the geometry of the renderWindow.
     void DisplayToPlane(const Point2D &displayPoint, Point2D &planePointInMM) const;
 
     //##Documentation
     //## @brief This method converts a 3D world index to the display point
     //## using the geometry of the renderWindow.
     void WorldToDisplay(const Point3D &worldIndex, Point2D &displayPoint) const;
 
     //##Documentation
     //## @brief This method converts a 3D world index to the point on the viewport
     //## using the geometry of the renderWindow.
     void WorldToView(const Point3D &worldIndex, Point2D &viewPoint) const;
 
     //##Documentation
     //## @brief This method converts a 2D plane coordinate to the display point
     //## using the geometry of the renderWindow.
     void PlaneToDisplay(const Point2D &planePointInMM, Point2D &displayPoint) const;
 
     //##Documentation
     //## @brief This method converts a 2D plane coordinate to the point on the viewport
     //## using the geometry of the renderWindow.
     void PlaneToView(const Point2D &planePointInMM, Point2D &viewPoint) const;
 
 
     double GetScaleFactorMMPerDisplayUnit() const;
 
     Point2D GetDisplaySizeInMM() const;
     Point2D GetViewportSizeInMM() const;
 
     Point2D GetOriginInMM() const;
 
     itkGetConstMacro(ConstrainZoomingAndPanning, bool) virtual void SetConstrainZoomingAndPanning(bool constrain);
 
     /**
     * \brief Provides (1) world coordinates for a given mouse position and (2)
     * translates mousePosition to Display coordinates
     * \deprecated Map2DRendererPositionTo3DWorldPosition is deprecated. Please use DisplayToWorld instead.
     */
     DEPRECATED(virtual Point3D Map2DRendererPositionTo3DWorldPosition(const Point2D &mousePosition) const);
 
   protected:
     ~BaseRenderer() override;
 
     //##Documentation
     //## @brief Call update of all mappers. To be implemented in subclasses.
     virtual void Update() = 0;
 
     vtkRenderWindow *m_RenderWindow;
     vtkRenderer *m_VtkRenderer;
 
     //##Documentation
     //## @brief MapperSlotId to use. Defines which kind of mapper (e.g., 2D or 3D) shoud be used.
     MapperSlotId m_MapperID;
 
     //##Documentation
     //## @brief The DataStorage that is used for rendering.
     DataStorage::Pointer m_DataStorage;
 
     //##Documentation
     //## @brief The RenderingManager that manages this instance
     RenderingManager::Pointer m_RenderingManager;
 
     //##Documentation
     //## @brief Timestamp of last call of Update().
     unsigned long m_LastUpdateTime;
 
     //##Documentation
     //## @brief CameraController for 3D rendering
     //## @note preliminary.
     itk::SmartPointer<CameraController> m_CameraController;
     SliceNavigationController::Pointer m_SliceNavigationController;
     CameraRotationController::Pointer m_CameraRotationController;
 
     //##Documentation
     //## @brief Sets m_CurrentWorldPlaneGeometry
     virtual void SetCurrentWorldPlaneGeometry(PlaneGeometry *geometry2d);
     /**
     * \deprecatedSince{2014_10} Please use SetCurrentWorldPlaneGeometry
     */
     DEPRECATED(void SetCurrentWorldGeometry2D(PlaneGeometry *geometry2d)) { SetCurrentWorldPlaneGeometry(geometry2d); };
     //##Documentation
     //## @brief Sets m_CurrentWorldGeometry
     virtual void SetCurrentWorldGeometry(BaseGeometry *geometry);
 
   private:
     //##Documentation
     //## m_WorldTimeGeometry is set by SetWorldGeometry if the passed BaseGeometry is a
     //## TimeGeometry (or a sub-class of it). If it contains instances of SlicedGeometry3D,
     //## m_Slice and m_TimeStep (set via SetSlice and SetTimeStep, respectively) define
     //## which 2D geometry stored in m_WorldTimeGeometry (if available)
     //## is used as m_CurrentWorldPlaneGeometry.
     //## \sa m_CurrentWorldPlaneGeometry
     TimeGeometry::Pointer m_WorldTimeGeometry;
 
     //##Documentation
     //## Pointer to the current 3D-worldgeometry.
     BaseGeometry::Pointer m_CurrentWorldGeometry;
 
     //##Documentation
     //## Pointer to the current 2D-worldgeometry. The 2D-worldgeometry
     //## describes the maximal area (2D manifold) to be rendered in case we
     //## are doing 2D-rendering.
     //## It is const, since we are not allowed to change it (it may be taken
     //## directly from the geometry of an image-slice and thus it would be
     //## very strange when suddenly the image-slice changes its geometry).
     PlaneGeometry::Pointer m_CurrentWorldPlaneGeometry;
 
     //##Documentation
     //## Defines together with m_Slice which 2D geometry stored in m_WorldTimeGeometry
     //## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
     //## \sa m_WorldTimeGeometry
     unsigned int m_Slice;
     //##Documentation
     //## Defines together with m_TimeStep which 2D geometry stored in m_WorldTimeGeometry
     //## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
     //## \sa m_WorldTimeGeometry
     unsigned int m_TimeStep;
 
     //##Documentation
     //## @brief timestamp of last call of SetWorldGeometry
     itk::TimeStamp m_CurrentWorldPlaneGeometryUpdateTime;
 
     //##Documentation
     //## @brief timestamp of last change of the current time step
     itk::TimeStamp m_TimeStepUpdateTime;
 
     //##Documentation
     //## @brief Helper class which establishes connection between Interactors and Dispatcher via a common DataStorage.
     BindDispatcherInteractor *m_BindDispatcherInteractor;
 
     //##Documentation
     //## @brief Tells if the displayed region should be shifted or rescaled if the render window is resized.
     bool m_KeepDisplayedRegion;
 
   protected:
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
     //##Documentation
     //## Data object containing the m_CurrentWorldPlaneGeometry defined above.
     PlaneGeometryData::Pointer m_CurrentWorldPlaneGeometryData;
 
     //##Documentation
     //## DataNode objects containing the m_CurrentWorldPlaneGeometryData defined above.
     DataNode::Pointer m_CurrentWorldPlaneGeometryNode;
 
     //##Documentation
     //## @brief test only
     unsigned long m_CurrentWorldPlaneGeometryTransformTime;
 
     std::string m_Name;
 
     double m_Bounds[6];
 
     bool m_EmptyWorldGeometry;
 
     typedef std::set<Mapper *> LODEnabledMappersType;
 
     /** Number of mappers which are visible and have level-of-detail
     * rendering enabled */
     unsigned int m_NumberOfVisibleLODEnabledMappers;
 
     // Local Storage Handling for mappers
 
   protected:
     std::list<mitk::BaseLocalStorageHandler *> m_RegisteredLocalStorageHandlers;
 
     bool m_ConstrainZoomingAndPanning;
 
   public:
     void RemoveAllLocalStorages();
     void RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
     void UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
   };
 } // namespace mitk
 
 #endif /* BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4 */
diff --git a/Modules/Core/src/Rendering/mitkRenderWindow.cpp b/Modules/Core/src/Rendering/mitkRenderWindow.cpp
index 3507b08084..4a53f2640b 100644
--- a/Modules/Core/src/Rendering/mitkRenderWindow.cpp
+++ b/Modules/Core/src/Rendering/mitkRenderWindow.cpp
@@ -1,97 +1,85 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkRenderWindow.h"
 
 #include "mitkRenderingManager.h"
 #include "mitkVtkEventProvider.h"
 #include "mitkVtkLayerController.h"
 #include "vtkRenderWindowInteractor.h"
 #include "vtkRenderer.h"
 
 mitk::RenderWindow::RenderWindow(vtkRenderWindow *renWin,
                                  const char *name,
                                  mitk::RenderingManager *rm,
                                  mitk::BaseRenderer::RenderingMode::Type rmtype)
   : m_vtkRenderWindow(renWin), m_vtkRenderWindowInteractor(nullptr), m_vtkMitkEventProvider(nullptr)
 {
   if (m_vtkRenderWindow == nullptr)
   {
     m_vtkRenderWindow = vtkRenderWindow::New();
-
-    if (rmtype == mitk::BaseRenderer::RenderingMode::DepthPeeling)
-    {
-      m_vtkRenderWindow->SetMultiSamples(0);
-      m_vtkRenderWindow->SetAlphaBitPlanes(1);
-    }
-    else if (rmtype == mitk::BaseRenderer::RenderingMode::MultiSampling)
-    {
-      m_vtkRenderWindow->SetMultiSamples(8);
-    }
-    else if (rmtype == mitk::BaseRenderer::RenderingMode::Standard)
-    {
-      m_vtkRenderWindow->SetMultiSamples(0);
-    }
+    m_vtkRenderWindow->SetMultiSamples(0);
+    m_vtkRenderWindow->SetAlphaBitPlanes(rmtype == BaseRenderer::RenderingMode::DepthPeeling ? 1 : 0);
   }
 
   if (m_vtkRenderWindow->GetSize()[0] <= 10)
   {
     m_vtkRenderWindow->SetSize(100, 100);
   }
 
   m_vtkRenderWindowInteractor = vtkRenderWindowInteractor::New();
   m_vtkRenderWindowInteractor->SetRenderWindow(m_vtkRenderWindow);
   m_vtkRenderWindowInteractor->Initialize();
 
   // initialize from RenderWindowBase
   Initialize(rm, name, rmtype);
 
   m_vtkMitkEventProvider = vtkEventProvider::New();
   m_vtkMitkEventProvider->SetInteractor(this->GetVtkRenderWindowInteractor());
   m_vtkMitkEventProvider->SetMitkRenderWindow(this);
   m_vtkMitkEventProvider->SetEnabled(1);
 }
 
 mitk::RenderWindow::~RenderWindow()
 {
   Destroy();
   m_vtkRenderWindow->Delete();
   m_vtkRenderWindowInteractor->Delete();
   m_vtkMitkEventProvider->Delete();
 }
 
 vtkRenderWindow *mitk::RenderWindow::GetVtkRenderWindow()
 {
   return m_vtkRenderWindow;
 }
 
 vtkRenderWindowInteractor *mitk::RenderWindow::GetVtkRenderWindowInteractor()
 {
   return m_vtkRenderWindowInteractor;
 }
 
 void mitk::RenderWindow::SetSize(int width, int height)
 {
   this->GetVtkRenderWindow()->SetSize(width, height);
 }
 
 void mitk::RenderWindow::ReinitEventProvider()
 {
   m_vtkMitkEventProvider->SetEnabled(0);
   m_vtkMitkEventProvider->SetInteractor(this->GetVtkRenderWindowInteractor());
   m_vtkMitkEventProvider->SetMitkRenderWindow(this);
   m_vtkMitkEventProvider->SetEnabled(1);
 }
diff --git a/Modules/QtWidgets/include/QmitkRenderWindow.h b/Modules/QtWidgets/include/QmitkRenderWindow.h
index df07c15f69..fa8c988407 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindow.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindow.h
@@ -1,172 +1,172 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
 #ifndef QMITKRENDERWINDOW_H_HEADER_INCLUDED_C1C40D66
 #define QMITKRENDERWINDOW_H_HEADER_INCLUDED_C1C40D66
 
 #include "mitkRenderWindowBase.h"
 
 #include "QmitkRenderWindowMenu.h"
 #include <MitkQtWidgetsExports.h>
 
 #include <vtkGenericOpenGLRenderWindow.h>
 #include <QVTKOpenGLWidget.h>
 
 #include "mitkBaseRenderer.h"
 #include "mitkInteractionEventConst.h"
 
 class QmitkStdMultiWidget;
 class QDragEnterEvent;
 class QDropEvent;
 class QInputEvent;
 
 /**
  * \ingroup QmitkModule
  * \brief MITK implementation of the QVTKWidget
  */
 class MITKQTWIDGETS_EXPORT QmitkRenderWindow : public QVTKOpenGLWidget, public mitk::RenderWindowBase
 {
   Q_OBJECT
 
 public:
   QmitkRenderWindow(
     QWidget *parent = nullptr,
-    QString name = "unnamed renderwindow",
+    const QString &name = "unnamed renderwindow",
     mitk::VtkPropRenderer *renderer = nullptr,
     mitk::RenderingManager *renderingManager = nullptr,
     mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard);
   ~QmitkRenderWindow() override;
 
   /**
    * \brief Whether Qt events should be passed to parent (default: true)
    *
    * With introduction of the QVTKWidget the behaviour regarding Qt events changed.
    * QVTKWidget "accepts" Qt events like mouse clicks (i.e. set an "accepted" flag).
    * When this flag is set, Qt fininshed handling of this event -- otherwise it is
    * reached through to the widget's parent.
    *
    * This reaching through to the parent was implicitly required by QmitkMaterialWidget / QmitkMaterialShowCase.
    *QmitkStdMultiWidget
    * The default behaviour of QmitkRenderWindow is now to clear the "accepted" flag
    * of Qt events after they were handled by QVTKWidget. This way parents can also
    * handle events.
    *
    * If you don't want this behaviour, call SetResendQtEvents(true) on your render window.
    */
   virtual void SetResendQtEvents(bool resend);
 
   // Set Layout Index to define the Layout Type
   void SetLayoutIndex(unsigned int layoutIndex);
 
   // Get Layout Index to define the Layout Type
   unsigned int GetLayoutIndex();
 
   // MenuWidget need to update the Layout Design List when Layout had changed
   void LayoutDesignListChanged(int layoutDesignIndex);
 
   void HideRenderWindowMenu();
 
   // Activate or Deactivate MenuWidget.
   void ActivateMenuWidget(bool state, QmitkStdMultiWidget *stdMultiWidget = nullptr);
 
   bool GetActivateMenuWidgetFlag() { return m_MenuWidgetActivated; }
   // Get it from the QVTKWidget parent
   vtkRenderWindow *GetVtkRenderWindow() override { return GetRenderWindow(); }
   vtkRenderWindowInteractor *GetVtkRenderWindowInteractor() override { return nullptr; }
   void FullScreenMode(bool state);
 
 protected:
   // overloaded move handler
   void moveEvent(QMoveEvent *event) override;
   // overloaded show handler
   void showEvent(QShowEvent *event) override;
   // overloaded mouse press handler
   void mousePressEvent(QMouseEvent *event) override;
   // overloaded mouse double-click handler
   void mouseDoubleClickEvent(QMouseEvent *event) override;
   // overloaded mouse move handler
   void mouseMoveEvent(QMouseEvent *event) override;
   // overloaded mouse release handler
   void mouseReleaseEvent(QMouseEvent *event) override;
   // overloaded key press handler
   void keyPressEvent(QKeyEvent *event) override;
   // overloaded enter handler
   void enterEvent(QEvent *) override;
   // overloaded leave handler
   void leaveEvent(QEvent *) override;
 
   // Overloaded resize handler, see decs in QVTKOpenGLWidget.
   // Basically, we have to ensure the VTK rendering is updated for each change in window size.
   void resizeGL(int w, int h) Q_DECL_OVERRIDE;
 
   /// \brief Simply says we accept the event type.
   void dragEnterEvent(QDragEnterEvent *event) override;
 
   /// \brief If the dropped type is application/x-mitk-datanodes we process the request by converting to mitk::DataNode
   /// pointers and emitting the NodesDropped signal.
   void dropEvent(QDropEvent *event) override;
 
 #ifndef QT_NO_WHEELEVENT
   // overload wheel mouse event
   void wheelEvent(QWheelEvent *) override;
 #endif
 
   void AdjustRenderWindowMenuVisibility(const QPoint &pos);
 
 signals:
 
   void ResetView();
   // \brief int parameters are enum from QmitkStdMultiWidget
   void ChangeCrosshairRotationMode(int);
 
   void SignalLayoutDesignChanged(int layoutDesignIndex);
 
   void moved();
 
   /// \brief Emits a signal to say that this window has had the following nodes dropped on it.
   void NodesDropped(QmitkRenderWindow *thisWindow, std::vector<mitk::DataNode *> nodes);
 
 protected slots:
 
   void OnChangeLayoutDesign(int layoutDesignIndex);
 
   void OnWidgetPlaneModeChanged(int);
 
   void DeferredHideMenu();
 
 private:
   // Helper Functions to Convert Qt-Events to Mitk-Events
 
   mitk::Point2D GetMousePosition(QMouseEvent *me) const;
   mitk::Point2D GetMousePosition(QWheelEvent *we) const;
   mitk::InteractionEvent::MouseButtons GetEventButton(QMouseEvent *me) const;
   mitk::InteractionEvent::MouseButtons GetButtonState(QMouseEvent *me) const;
   mitk::InteractionEvent::ModifierKeys GetModifiers(QInputEvent *me) const;
   mitk::InteractionEvent::MouseButtons GetButtonState(QWheelEvent *we) const;
   std::string GetKeyLetter(QKeyEvent *ke) const;
   int GetDelta(QWheelEvent *we) const;
   bool m_ResendQtEvents;
 
   QmitkRenderWindowMenu *m_MenuWidget;
 
   bool m_MenuWidgetActivated;
 
   unsigned int m_LayoutIndex;
 
   vtkSmartPointer<vtkGenericOpenGLRenderWindow> m_InternalRenderWindow;
 };
 
 #endif
diff --git a/Modules/QtWidgets/src/QmitkRenderWindow.cpp b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
index 6ab8bb595b..107a4bdf69 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindow.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
@@ -1,515 +1,504 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
 #include "QmitkRenderWindow.h"
 
 #include "mitkInteractionKeyEvent.h"
 #include "mitkInternalEvent.h"
 #include "mitkMouseDoubleClickEvent.h"
 #include "mitkMouseMoveEvent.h"
 #include "mitkMousePressEvent.h"
 #include "mitkMouseReleaseEvent.h"
 #include "mitkMouseWheelEvent.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,
-                                     QString name,
-                                     mitk::VtkPropRenderer * /*renderer*/,
-                                     mitk::RenderingManager *renderingManager,
-                                     mitk::BaseRenderer::RenderingMode::Type renderingMode)
-  : QVTKOpenGLWidget(parent), m_ResendQtEvents(true), m_MenuWidget(nullptr), m_MenuWidgetActivated(false), m_LayoutIndex(0)
+QmitkRenderWindow::QmitkRenderWindow(QWidget *parent, const QString &name, mitk::VtkPropRenderer *, mitk::RenderingManager *renderingManager, mitk::BaseRenderer::RenderingMode::Type renderingMode)
+  : QVTKOpenGLWidget(parent),
+    m_ResendQtEvents(true),
+    m_MenuWidget(nullptr),
+    m_MenuWidgetActivated(false),
+    m_LayoutIndex(0)
 {
   m_InternalRenderWindow = vtkSmartPointer<vtkGenericOpenGLRenderWindow>::New();
-  this->SetRenderWindow(m_InternalRenderWindow);
+  m_InternalRenderWindow->SetMultiSamples(0);
+  m_InternalRenderWindow->SetAlphaBitPlanes(mitk::BaseRenderer::RenderingMode::DepthPeeling == renderingMode ? 1 : 0);
 
-  if (renderingMode == mitk::BaseRenderer::RenderingMode::DepthPeeling)
-  {
-    GetRenderWindow()->SetMultiSamples(0);
-    GetRenderWindow()->SetAlphaBitPlanes(1);
-  }
-  else if (renderingMode == mitk::BaseRenderer::RenderingMode::MultiSampling)
-  {
-    GetRenderWindow()->SetMultiSamples(8);
-  }
-  else if (renderingMode == mitk::BaseRenderer::RenderingMode::Standard)
-  {
-    GetRenderWindow()->SetMultiSamples(0);
-  }
+  this->SetRenderWindow(m_InternalRenderWindow);
 
-  Initialize(renderingManager, name.toStdString().c_str(), renderingMode); // Initialize mitkRenderWindowBase
+  this->Initialize(renderingManager, name.toStdString().c_str(), renderingMode);
 
-  setFocusPolicy(Qt::StrongFocus);
-  setMouseTracking(true);
+  this->setFocusPolicy(Qt::StrongFocus);
+  this->setMouseTracking(true);
 }
 
 QmitkRenderWindow::~QmitkRenderWindow()
 {
   Destroy(); // Destroy mitkRenderWindowBase
 }
 
 void QmitkRenderWindow::SetResendQtEvents(bool resend)
 {
   m_ResendQtEvents = resend;
 }
 
 void QmitkRenderWindow::SetLayoutIndex(unsigned int layoutIndex)
 {
   m_LayoutIndex = layoutIndex;
   if (m_MenuWidget)
     m_MenuWidget->SetLayoutIndex(layoutIndex);
 }
 
 unsigned int QmitkRenderWindow::GetLayoutIndex()
 {
   if (m_MenuWidget)
     return m_MenuWidget->GetLayoutIndex();
   else
     return 0;
 }
 
 void QmitkRenderWindow::LayoutDesignListChanged(int layoutDesignIndex)
 {
   if (m_MenuWidget)
     m_MenuWidget->UpdateLayoutDesignList(layoutDesignIndex);
 }
 
 void QmitkRenderWindow::mousePressEvent(QMouseEvent *me)
 {
   // Get mouse position in vtk display coordinate system. me contains qt display infos...
   mitk::Point2D displayPos = GetMousePosition(me);
 
   mitk::MousePressEvent::Pointer mPressEvent =
     mitk::MousePressEvent::New(m_Renderer, displayPos, GetButtonState(me), GetModifiers(me), GetEventButton(me));
 
   if (!this->HandleEvent(mPressEvent.GetPointer()))
   {
     QVTKOpenGLWidget::mousePressEvent(me);
   }
 
   if (m_ResendQtEvents)
     me->ignore();
 }
 
 void QmitkRenderWindow::mouseDoubleClickEvent(QMouseEvent *me)
 {
   mitk::Point2D displayPos = GetMousePosition(me);
   mitk::MouseDoubleClickEvent::Pointer mPressEvent =
     mitk::MouseDoubleClickEvent::New(m_Renderer, displayPos, GetButtonState(me), GetModifiers(me), GetEventButton(me));
 
   if (!this->HandleEvent(mPressEvent.GetPointer()))
   {
     QVTKOpenGLWidget::mousePressEvent(me);
   }
 
   if (m_ResendQtEvents)
     me->ignore();
 }
 
 void QmitkRenderWindow::mouseReleaseEvent(QMouseEvent *me)
 {
   mitk::Point2D displayPos = GetMousePosition(me);
   mitk::MouseReleaseEvent::Pointer mReleaseEvent =
     mitk::MouseReleaseEvent::New(m_Renderer, displayPos, GetButtonState(me), GetModifiers(me), GetEventButton(me));
 
   if (!this->HandleEvent(mReleaseEvent.GetPointer()))
   {
     QVTKOpenGLWidget::mouseReleaseEvent(me);
   }
 
   if (m_ResendQtEvents)
     me->ignore();
 }
 
 void QmitkRenderWindow::mouseMoveEvent(QMouseEvent *me)
 {
   mitk::Point2D displayPos = GetMousePosition(me);
 
   this->AdjustRenderWindowMenuVisibility(me->pos());
 
   mitk::MouseMoveEvent::Pointer mMoveEvent =
     mitk::MouseMoveEvent::New(m_Renderer, displayPos, GetButtonState(me), GetModifiers(me));
 
   if (!this->HandleEvent(mMoveEvent.GetPointer()))
   {
     QVTKOpenGLWidget::mouseMoveEvent(me);
   }
 }
 
 void QmitkRenderWindow::wheelEvent(QWheelEvent *we)
 {
   mitk::Point2D displayPos = GetMousePosition(we);
   mitk::MouseWheelEvent::Pointer mWheelEvent =
     mitk::MouseWheelEvent::New(m_Renderer, displayPos, GetButtonState(we), GetModifiers(we), GetDelta(we));
 
   if (!this->HandleEvent(mWheelEvent.GetPointer()))
   {
     QVTKOpenGLWidget::wheelEvent(we);
   }
 
   if (m_ResendQtEvents)
     we->ignore();
 }
 
 void QmitkRenderWindow::keyPressEvent(QKeyEvent *ke)
 {
   mitk::InteractionEvent::ModifierKeys modifiers = GetModifiers(ke);
   std::string key = GetKeyLetter(ke);
 
   mitk::InteractionKeyEvent::Pointer keyEvent = mitk::InteractionKeyEvent::New(m_Renderer, key, modifiers);
   if (!this->HandleEvent(keyEvent.GetPointer()))
   {
     QVTKOpenGLWidget::keyPressEvent(ke);
   }
 
   if (m_ResendQtEvents)
     ke->ignore();
 }
 
 void QmitkRenderWindow::enterEvent(QEvent *e)
 {
   // TODO implement new event
   QVTKOpenGLWidget::enterEvent(e);
 }
 
 void QmitkRenderWindow::DeferredHideMenu()
 {
   MITK_DEBUG << "QmitkRenderWindow::DeferredHideMenu";
 
   if (m_MenuWidget)
     m_MenuWidget->HideMenu();
 }
 
 void QmitkRenderWindow::leaveEvent(QEvent *e)
 {
   mitk::InternalEvent::Pointer internalEvent = mitk::InternalEvent::New(this->m_Renderer, nullptr, "LeaveRenderWindow");
 
   this->HandleEvent(internalEvent.GetPointer());
 
   if (m_MenuWidget)
     m_MenuWidget->smoothHide();
 
   QVTKOpenGLWidget::leaveEvent(e);
 }
 
 //-----------------------------------------------------------------------------
 void QmitkRenderWindow::resizeGL(int w, int h)
 {
   this->GetRenderer()->GetRenderingManager()->ForceImmediateUpdate(GetRenderWindow());
   QVTKOpenGLWidget::resizeGL(w, h);
 }
 
 void QmitkRenderWindow::moveEvent(QMoveEvent *event)
 {
   QVTKOpenGLWidget::moveEvent(event);
 
   // after a move the overlays need to be positioned
   emit moved();
 }
 
 void QmitkRenderWindow::showEvent(QShowEvent *event)
 {
   QVTKOpenGLWidget::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()));
 }
 
 void QmitkRenderWindow::ActivateMenuWidget(bool state, QmitkStdMultiWidget *stdMultiWidget)
 {
   m_MenuWidgetActivated = state;
 
   if (!m_MenuWidgetActivated && m_MenuWidget)
   {
     // disconnect Signal/Slot Connection
     disconnect(m_MenuWidget, SIGNAL(SignalChangeLayoutDesign(int)), this, SLOT(OnChangeLayoutDesign(int)));
     disconnect(m_MenuWidget, SIGNAL(ResetView()), this, SIGNAL(ResetView()));
     disconnect(m_MenuWidget, SIGNAL(ChangeCrosshairRotationMode(int)), this, SIGNAL(ChangeCrosshairRotationMode(int)));
 
     delete m_MenuWidget;
     m_MenuWidget = nullptr;
   }
   else if (m_MenuWidgetActivated && !m_MenuWidget)
   {
     // create render window MenuBar for split, close Window or set new setting.
     m_MenuWidget = new QmitkRenderWindowMenu(this, nullptr, m_Renderer, stdMultiWidget);
     m_MenuWidget->SetLayoutIndex(m_LayoutIndex);
 
     // create Signal/Slot Connection
     connect(m_MenuWidget, SIGNAL(SignalChangeLayoutDesign(int)), this, SLOT(OnChangeLayoutDesign(int)));
     connect(m_MenuWidget, SIGNAL(ResetView()), this, SIGNAL(ResetView()));
     connect(m_MenuWidget, SIGNAL(ChangeCrosshairRotationMode(int)), this, SIGNAL(ChangeCrosshairRotationMode(int)));
   }
 }
 
 void QmitkRenderWindow::AdjustRenderWindowMenuVisibility(const QPoint & /*pos*/)
 {
   if (m_MenuWidget)
   {
     m_MenuWidget->ShowMenu();
     m_MenuWidget->MoveWidgetToCorrectPos(1.0f);
   }
 }
 
 void QmitkRenderWindow::HideRenderWindowMenu()
 {
   // DEPRECATED METHOD
 }
 
 void QmitkRenderWindow::OnChangeLayoutDesign(int layoutDesignIndex)
 {
   emit SignalLayoutDesignChanged(layoutDesignIndex);
 }
 
 void QmitkRenderWindow::OnWidgetPlaneModeChanged(int mode)
 {
   if (m_MenuWidget)
     m_MenuWidget->NotifyNewWidgetPlanesMode(mode);
 }
 
 void QmitkRenderWindow::FullScreenMode(bool state)
 {
   if (m_MenuWidget)
     m_MenuWidget->ChangeFullScreenMode(state);
 }
 
 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());
   }
 }
 
 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();
 }
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp
index fe288fbf78..2425ce73bd 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp
@@ -1,271 +1,267 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include <ui_QmitkStdMultiWidgetEditorPreferencePage.h>
 #include "QmitkStdMultiWidgetEditorPreferencePage.h"
 #include <QmitkStdMultiWidgetEditor.h>
 
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 #include <QColorDialog>
 
 QmitkStdMultiWidgetEditorPreferencePage::QmitkStdMultiWidgetEditorPreferencePage()
   : m_Preferences(nullptr),
     m_Ui(new Ui::QmitkStdMultiWidgetEditorPreferencePage),
     m_Control(nullptr)
 {
 }
 
 QmitkStdMultiWidgetEditorPreferencePage::~QmitkStdMultiWidgetEditorPreferencePage()
 {
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::CreateQtControl(QWidget* parent)
 {
   m_Control = new QWidget(parent);
 
   m_Ui->setupUi(m_Control);
 
   berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
   Q_ASSERT(prefService);
 
   m_Preferences = prefService->GetSystemPreferences()->Node(QmitkStdMultiWidgetEditor::EDITOR_ID);
 
   QObject::connect( m_Ui->m_ColorButton1, SIGNAL( clicked() )
                     , this, SLOT( ColorChooserButtonClicked() ) );
 
   QObject::connect( m_Ui->m_ColorButton2, SIGNAL( clicked() )
                     , this, SLOT( ColorChooserButtonClicked() ) );
 
   QObject::connect( m_Ui->m_ResetButton, SIGNAL( clicked() )
                     , this, SLOT( ResetPreferencesAndGUI() ) );
 
   QObject::connect( m_Ui->m_RenderingMode, SIGNAL(activated(int) )
                     , this, SLOT( ChangeRenderingMode(int) ) );
 
   QObject::connect( m_Ui->m_RenderWindowDecorationColor, SIGNAL( clicked() )
                     , this, SLOT( ColorChooserButtonClicked() ) );
 
   QObject::connect( m_Ui->m_RenderWindowChooser, SIGNAL(activated(int) )
                     , this, SLOT( OnWidgetComboBoxChanged(int) ) );
   QObject::connect( m_Ui->m_RenderWindowDecorationText, SIGNAL(textChanged(QString) )
                     , this, SLOT( AnnotationTextChanged(QString) ) );
 
   this->Update();
 }
 
 QWidget* QmitkStdMultiWidgetEditorPreferencePage::GetQtControl() const
 {
   return m_Control;
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::Init(berry::IWorkbench::Pointer)
 {
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::PerformCancel()
 {
 }
 
 bool QmitkStdMultiWidgetEditorPreferencePage::PerformOk()
 {
   m_Preferences->Put("widget1 corner annotation", m_WidgetAnnotation[0]);
   m_Preferences->Put("widget2 corner annotation", m_WidgetAnnotation[1]);
   m_Preferences->Put("widget3 corner annotation", m_WidgetAnnotation[2]);
   m_Preferences->Put("widget4 corner annotation", m_WidgetAnnotation[3]);
 
   m_Preferences->Put("widget1 decoration color", m_WidgetDecorationColor[0]);
   m_Preferences->Put("widget2 decoration color", m_WidgetDecorationColor[1]);
   m_Preferences->Put("widget3 decoration color", m_WidgetDecorationColor[2]);
   m_Preferences->Put("widget4 decoration color", m_WidgetDecorationColor[3]);
 
   m_Preferences->Put("widget1 first background color", m_WidgetBackgroundColor1[0]);
   m_Preferences->Put("widget2 first background color", m_WidgetBackgroundColor1[1]);
   m_Preferences->Put("widget3 first background color", m_WidgetBackgroundColor1[2]);
   m_Preferences->Put("widget4 first background color", m_WidgetBackgroundColor1[3]);
   m_Preferences->Put("widget1 second background color", m_WidgetBackgroundColor2[0]);
   m_Preferences->Put("widget2 second background color", m_WidgetBackgroundColor2[1]);
   m_Preferences->Put("widget3 second background color", m_WidgetBackgroundColor2[2]);
   m_Preferences->Put("widget4 second background color", m_WidgetBackgroundColor2[3]);
   m_Preferences->PutInt("crosshair gap size", m_Ui->m_CrosshairGapSize->value());
 
   m_Preferences->PutBool("Use constrained zooming and panning"
                          , m_Ui->m_EnableFlexibleZooming->isChecked());
   m_Preferences->PutBool("Show level/window widget", m_Ui->m_ShowLevelWindowWidget->isChecked());
   m_Preferences->PutBool("PACS like mouse interaction", m_Ui->m_PACSLikeMouseMode->isChecked());
   m_Preferences->PutInt("Rendering Mode", m_Ui->m_RenderingMode->currentIndex());
 
   return true;
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::Update()
 {
   //Note: there should be default preferences already defined in the
   //QmitkStdMultiWidgetEditor::InitializePreferences(). Therefore,
   //all default values here are not relevant.
   //gradient background colors
   m_WidgetBackgroundColor1[0] = m_Preferences->Get("widget1 first background color", "#1d1d1c");
   m_WidgetBackgroundColor2[0] = m_Preferences->Get("widget1 second background color", "#1d1d1c");
   m_WidgetBackgroundColor1[1] = m_Preferences->Get("widget2 first background color", "#1d1d1c");
   m_WidgetBackgroundColor2[1] = m_Preferences->Get("widget2 second background color", "#1d1d1c");
   m_WidgetBackgroundColor1[2] = m_Preferences->Get("widget3 first background color", "#1d1d1c");
   m_WidgetBackgroundColor2[2] = m_Preferences->Get("widget3 second background color", "#1d1d1c");
   m_WidgetBackgroundColor1[3] = m_Preferences->Get("widget4 first background color", "#1d1d1c");
   m_WidgetBackgroundColor2[3] = m_Preferences->Get("widget4 second background color", "#adb1b6");
 
   //decoration colors
   m_WidgetDecorationColor[0] = m_Preferences->Get("widget1 decoration color", "#c00000");
   m_WidgetDecorationColor[1] = m_Preferences->Get("widget2 decoration color", "#0fad00");
   m_WidgetDecorationColor[2] = m_Preferences->Get("widget3 decoration color", "#0080ff");
   m_WidgetDecorationColor[3] = m_Preferences->Get("widget4 decoration color", "#fec500");
 
   //annotation text
   m_WidgetAnnotation[0] = m_Preferences->Get("widget1 corner annotation", "Axial");
   m_WidgetAnnotation[1] = m_Preferences->Get("widget2 corner annotation", "Sagittal");
   m_WidgetAnnotation[2] = m_Preferences->Get("widget3 corner annotation", "Coronal");
   m_WidgetAnnotation[3] = m_Preferences->Get("widget4 corner annotation", "3D");
 
 
   //Ui stuff
   int index = m_Ui->m_RenderWindowChooser->currentIndex();
   QColor firstBackgroundColor(m_WidgetBackgroundColor1[index]);
   QColor secondBackgroundColor(m_WidgetBackgroundColor2[index]);
   QColor widgetColor(m_WidgetDecorationColor[index]);
 
   this->SetStyleSheetToColorChooserButton(firstBackgroundColor, m_Ui->m_ColorButton1);
   this->SetStyleSheetToColorChooserButton(secondBackgroundColor, m_Ui->m_ColorButton2);
   this->SetStyleSheetToColorChooserButton(widgetColor, m_Ui->m_RenderWindowDecorationColor);
 
   m_Ui->m_RenderWindowDecorationText->setText(m_WidgetAnnotation[index]);
 
   m_Ui->m_EnableFlexibleZooming->setChecked(m_Preferences->GetBool("Use constrained zooming and panning", true));
   m_Ui->m_ShowLevelWindowWidget->setChecked(m_Preferences->GetBool("Show level/window widget", true));
   m_Ui->m_PACSLikeMouseMode->setChecked(m_Preferences->GetBool("PACS like mouse interaction", false));
   int mode= m_Preferences->GetInt("Rendering Mode",0);
   m_Ui->m_RenderingMode->setCurrentIndex(mode);
   m_Ui->m_CrosshairGapSize->setValue(m_Preferences->GetInt("crosshair gap size", 32));
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::ColorChooserButtonClicked()
 {
   unsigned int widgetIndex = m_Ui->m_RenderWindowChooser->currentIndex();
   if(widgetIndex > 3)
   {
     MITK_ERROR << "Selected index for unknown.";
     return;
   }
   QObject *senderObj = sender(); // This will give Sender button
   //find out last used color and set it
   QColor initialColor;
   if( senderObj->objectName() == m_Ui->m_ColorButton1->objectName())
   {
     initialColor = QColor(m_WidgetBackgroundColor1[widgetIndex]);
   }else if( senderObj->objectName() == m_Ui->m_ColorButton2->objectName())
   {
     initialColor = QColor(m_WidgetBackgroundColor2[widgetIndex]);
   }else if( senderObj->objectName() == m_Ui->m_RenderWindowDecorationColor->objectName())
   {
     initialColor = QColor(m_WidgetDecorationColor[widgetIndex]);
   }
 
   //get the new color
   QColor newcolor = QColorDialog::getColor(initialColor);
   if(!newcolor.isValid())
   {
     newcolor = initialColor;
   }
   this->SetStyleSheetToColorChooserButton(newcolor, static_cast<QPushButton*>(senderObj));
 
   //convert it to std string and apply it
   if( senderObj->objectName() == m_Ui->m_ColorButton1->objectName())
   {
     m_WidgetBackgroundColor1[widgetIndex] = newcolor.name();
   }
   else if( senderObj->objectName() == m_Ui->m_ColorButton2->objectName())
   {
     m_WidgetBackgroundColor2[widgetIndex] = newcolor.name();
   }
   else if( senderObj->objectName() == m_Ui->m_RenderWindowDecorationColor->objectName())
   {
     m_WidgetDecorationColor[widgetIndex] = newcolor.name();
   }
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::SetStyleSheetToColorChooserButton(QColor backgroundcolor,
                                                                                 QPushButton* button)
 {
   button->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
 
   styleSheet.append(QString::number(backgroundcolor.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(backgroundcolor.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(backgroundcolor.blue()));
   styleSheet.append(")");
   button->setStyleSheet(styleSheet);
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::AnnotationTextChanged(QString text)
 {
   unsigned int widgetIndex = m_Ui->m_RenderWindowChooser->currentIndex();
   if( widgetIndex > 3)
   {
     MITK_INFO << "Selected index for unknown widget.";
     return;
   }
   m_WidgetAnnotation[widgetIndex] = text;
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::ResetPreferencesAndGUI()
 {
   m_Preferences->Clear();
   this->Update();
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::OnWidgetComboBoxChanged(int i)
 {
   if( i > 3)
   {
     MITK_ERROR << "Selected unknown widget.";
     return;
   }
   QColor widgetColor(m_WidgetDecorationColor[i]);
   QColor gradientBackground1(m_WidgetBackgroundColor1[i]);
   QColor gradientBackground2(m_WidgetBackgroundColor2[i]);
   this->SetStyleSheetToColorChooserButton(widgetColor, m_Ui->m_RenderWindowDecorationColor);
   this->SetStyleSheetToColorChooserButton(gradientBackground1, m_Ui->m_ColorButton1);
   this->SetStyleSheetToColorChooserButton(gradientBackground2, m_Ui->m_ColorButton2);
   m_Ui->m_RenderWindowDecorationText->setText(m_WidgetAnnotation[i]);
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::ChangeRenderingMode(int i)
 {
   if( i == 0 )
   {
     m_CurrentRenderingMode = "Standard";
   }
   else if( i == 1 )
-  {
-    m_CurrentRenderingMode = "Multisampling";
-  }
-  else if( i == 2 )
   {
     m_CurrentRenderingMode = "DepthPeeling";
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.ui b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.ui
index ba9242e500..437b580c38 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.ui
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.ui
@@ -1,225 +1,220 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkStdMultiWidgetEditorPreferencePage</class>
  <widget class="QWidget" name="QmitkStdMultiWidgetEditorPreferencePage">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>518</width>
     <height>431</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>External Programs</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="10" column="1">
     <widget class="QComboBox" name="m_RenderWindowChooser">
      <item>
       <property name="text">
        <string>stdmulti.widget1</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>stdmulti.widget2</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>stdmulti.widget3</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>stdmulti.widget4</string>
       </property>
      </item>
     </widget>
    </item>
    <item row="11" column="0">
     <widget class="QLabel" name="label_2">
      <property name="toolTip">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;If two colors are set, a gradient background is generated.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="text">
       <string>Background color</string>
      </property>
     </widget>
    </item>
    <item row="15" column="0">
     <widget class="QPushButton" name="m_ResetButton">
      <property name="text">
       <string>Reset preferences</string>
      </property>
     </widget>
    </item>
    <item row="6" column="1" colspan="2">
     <widget class="QComboBox" name="m_RenderingMode">
      <item>
       <property name="text">
        <string>Standard Rendering</string>
       </property>
      </item>
      <item>
       <property name="text">
-       <string>Enable Multisampling (Antialiasing)</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Enable Depth Peeling</string>
+       <string>Depth Peeling</string>
       </property>
      </item>
     </widget>
    </item>
    <item row="7" column="0" colspan="3">
     <widget class="QLabel" name="label">
      <property name="text">
       <string>* Changes require restart of MITK.
  Depth Peeling is only supported by Windows.
- For other OS, use Standard Rendering and enable
- the property 'Depth Sorting' in the property list of the surface data node.</string>
+ For other operating systems, use Standard Rendering and enable
+ the property 'Depth Sorting' in the property list of a surface data node.</string>
      </property>
     </widget>
    </item>
    <item row="9" column="1">
     <widget class="QSpinBox" name="m_CrosshairGapSize">
      <property name="value">
       <number>32</number>
      </property>
     </widget>
    </item>
    <item row="8" column="0" colspan="3">
     <widget class="Line" name="line_3">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item row="14" column="0">
     <widget class="QLabel" name="label_8">
      <property name="toolTip">
       <string>The small text on the button left of each renderwindow.</string>
      </property>
      <property name="text">
       <string>Corner annotation</string>
      </property>
     </widget>
    </item>
    <item row="9" column="0">
     <widget class="QLabel" name="label_9">
      <property name="toolTip">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The gap in the middle of the crosshair in pixels.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="text">
       <string>Crosshair gap size</string>
      </property>
     </widget>
    </item>
    <item row="13" column="0">
     <widget class="QLabel" name="label_7">
      <property name="toolTip">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The color is used for the following decorations (of each renderwindow):&lt;/p&gt;&lt;p&gt;Rectangle border&lt;/p&gt;&lt;p&gt;Corner annotation&lt;/p&gt;&lt;p&gt;Crosshair&lt;/p&gt;&lt;p&gt;Plane geometry helper objects (3D Planes)&lt;/p&gt;&lt;p&gt;Image navigator borders&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="text">
       <string>Decoration color</string>
      </property>
     </widget>
    </item>
    <item row="13" column="1">
     <widget class="QPushButton" name="m_RenderWindowDecorationColor">
      <property name="text">
       <string/>
      </property>
     </widget>
    </item>
    <item row="10" column="0">
     <widget class="QLabel" name="label_6">
      <property name="toolTip">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Choose the renderwindow from the multi widget.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="text">
       <string>Render windows</string>
      </property>
     </widget>
    </item>
    <item row="1" column="0" colspan="3">
     <widget class="QCheckBox" name="m_ShowLevelWindowWidget">
      <property name="layoutDirection">
       <enum>Qt::LeftToRight</enum>
      </property>
      <property name="text">
       <string>Show level/window widget</string>
      </property>
      <property name="checked">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item row="2" column="0" colspan="3">
     <widget class="QCheckBox" name="m_PACSLikeMouseMode">
      <property name="layoutDirection">
       <enum>Qt::LeftToRight</enum>
      </property>
      <property name="text">
       <string>Use PACS like mouse interaction (select left mouse button action)</string>
      </property>
      <property name="tristate">
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item row="11" column="2">
     <widget class="QPushButton" name="m_ColorButton2">
      <property name="text">
       <string/>
      </property>
     </widget>
    </item>
    <item row="3" column="0" colspan="3">
     <widget class="Line" name="line">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item row="6" column="0">
     <widget class="QLabel" name="label_5">
      <property name="text">
       <string>Rendering Mode*</string>
      </property>
     </widget>
    </item>
    <item row="14" column="1" colspan="2">
     <widget class="QLineEdit" name="m_RenderWindowDecorationText"/>
    </item>
    <item row="11" column="1">
     <widget class="QPushButton" name="m_ColorButton1">
      <property name="text">
       <string/>
      </property>
     </widget>
    </item>
    <item row="0" column="0" colspan="3">
     <widget class="QCheckBox" name="m_EnableFlexibleZooming">
      <property name="toolTip">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;If activated, zooming and panning is limited to a certain space arround each image.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="layoutDirection">
       <enum>Qt::LeftToRight</enum>
      </property>
      <property name="text">
       <string>Use constraint zooming and panning</string>
      </property>
      <property name="checked">
       <bool>true</bool>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>