diff --git a/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp b/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp
index 1c90cbb343..1dec42e65c 100644
--- a/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp
+++ b/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp
@@ -1,964 +1,965 @@
 /*============================================================================
 
 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 "mitkPlanarFigureMapper2D.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkColorProperty.h"
 #include "vtkContext2D.h"
 #include "vtkContextDevice2D.h"
 #include "vtkOpenGLContextDevice2D.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 #include "vtkTextProperty.h"
 
 #define _USE_MATH_DEFINES
 #include <cmath>
 
 #include <array>
 #include <vector>
 #include <regex>
 
 mitk::PlanarFigureMapper2D::PlanarFigureMapper2D()
   : m_NodeModified(true), m_NodeModifiedObserverTag(0), m_NodeModifiedObserverAdded(false), m_Initialized(false)
 {
 
   this->InitializeDefaultPlanarFigureProperties();
 }
 
 mitk::PlanarFigureMapper2D::~PlanarFigureMapper2D()
 {
   if (m_NodeModifiedObserverAdded && GetDataNode() != nullptr)
   {
     GetDataNode()->RemoveObserver(m_NodeModifiedObserverTag);
   }
 }
 
 void mitk::PlanarFigureMapper2D::ApplyColorAndOpacityProperties(mitk::BaseRenderer *renderer, vtkActor * /*actor*/)
 {
   float rgba[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
   // check for color prop and use it for rendering if it exists
   GetDataNode()->GetColor(rgba, renderer, "color");
   // check for opacity prop and use it for rendering if it exists
   GetDataNode()->GetOpacity(rgba[3], renderer, "opacity");
 
   this->m_Pen->SetColorF((double)rgba[0], (double)rgba[1], (double)rgba[2], (double)rgba[3]);
 }
 
 void mitk::PlanarFigureMapper2D::Initialize(mitk::BaseRenderer *)
 {
   this->m_Pen = vtkSmartPointer<vtkPen>::New();
   vtkOpenGLContextDevice2D *device = nullptr;
     device = vtkOpenGLContextDevice2D::New();
   if (device)
   {
     this->m_Context->Begin(device);
     device->Delete();
     this->m_Initialized = true;
     this->m_Context->ApplyPen(this->m_Pen);
   }
   else
   {
   }
 }
 
 void mitk::PlanarFigureMapper2D::MitkRender(mitk::BaseRenderer *renderer, mitk::VtkPropRenderer::RenderType type)
 {
   /* This is a temporary fix because the rendering of planar figures causes problems when two windows try to show the
    same figure, which can happen a lot when using the MxNMultiWidget. Therefore, rendering is completely
    disabled here if the renderer in question does not belong to the StdMultiWidget.
    See T29333 */
-  std::regex pattern("^stdmulti\\.widget[0-3]$");
-  if (!std::regex_match(renderer->GetName(), pattern))
+  std::regex pattern("^mxn\\.widget");
+  std::cmatch match;
+  if (std::regex_search(renderer->GetName(), match, pattern))
     return;
 
   if (type != mitk::VtkPropRenderer::Overlay) return;
   if (!this->m_Initialized)
   {
     this->Initialize(renderer);
   }
   vtkOpenGLContextDevice2D::SafeDownCast(
     this->m_Context->GetDevice())->Begin(renderer->GetVtkRenderer());
 
   bool visible = true;
 
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if (!visible)
     return;
 
   // Get PlanarFigure from input
   auto *planarFigure =
     const_cast<mitk::PlanarFigure *>(static_cast<const mitk::PlanarFigure *>(GetDataNode()->GetData()));
 
   // Check if PlanarFigure has already been placed; otherwise, do nothing
   if (!planarFigure->IsPlaced())
   {
     return;
   }
 
   // Get 2D geometry frame of PlanarFigure
   const mitk::PlaneGeometry *planarFigurePlaneGeometry = planarFigure->GetPlaneGeometry();
   if (planarFigurePlaneGeometry == nullptr)
   {
     MITK_ERROR << "PlanarFigure does not have valid PlaneGeometry!";
     return;
   }
 
   // Get current world 2D geometry from renderer
   const mitk::PlaneGeometry *rendererPlaneGeometry = renderer->GetCurrentWorldPlaneGeometry();
 
   // If the PlanarFigure geometry is a plane geometry, check if current
   // world plane is parallel to and within the planar figure geometry bounds
   // (otherwise, display nothing)
 
   if ((planarFigurePlaneGeometry != nullptr) && (rendererPlaneGeometry != nullptr))
   {
     double planeThickness = planarFigurePlaneGeometry->GetExtentInMM(2);
     if (!planarFigurePlaneGeometry->IsParallel(rendererPlaneGeometry) ||
         !(planarFigurePlaneGeometry->DistanceFromPlane(rendererPlaneGeometry) < planeThickness / 3.0))
     {
       // Planes are not parallel or renderer plane is not within PlanarFigure
       // geometry bounds --> exit
       return;
     }
   }
   else
   {
     // Plane is not valid (curved reformations are not possible yet)
     return;
   }
 
   // Apply visual appearance properties from the PropertyList
   ApplyColorAndOpacityProperties(renderer);
 
   // Get properties from node (if present)
   const mitk::DataNode *node = this->GetDataNode();
   this->InitializePlanarFigurePropertiesFromDataNode(node);
 
   PlanarFigureDisplayMode lineDisplayMode = PF_DEFAULT;
 
   if (m_IsSelected)
   {
     lineDisplayMode = PF_SELECTED;
   }
   else if (m_IsHovering)
   {
     lineDisplayMode = PF_HOVER;
   }
 
   mitk::Point2D anchorPoint;
   anchorPoint[0] = 0;
   anchorPoint[1] = 1;
 
   // render the actual lines of the PlanarFigure
   RenderLines(lineDisplayMode, planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
 
   // position-offset of the annotations, is set in RenderAnnotations() and
   // used in RenderQuantities()
   double annotationOffset = 0.0;
 
   // Get Global Opacity
   float globalOpacity = 1.0;
   node->GetFloatProperty("opacity", globalOpacity);
 
   if (m_DrawControlPoints)
   {
     // draw the control-points
     RenderControlPoints(planarFigure, lineDisplayMode, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
   }
 
   // draw name near the anchor point (point located on the right)
   const std::string name = node->GetName();
   if (m_DrawName && !name.empty())
   {
     RenderAnnotations(renderer, name, anchorPoint, globalOpacity, lineDisplayMode, annotationOffset);
   }
 
   // draw feature quantities (if requested) next to the anchor point,
   // but under the name (that is where 'annotationOffset' is used)
   if (m_DrawQuantities)
   {
     RenderQuantities(planarFigure, renderer, anchorPoint, annotationOffset, globalOpacity, lineDisplayMode);
   }
 
   this->m_Context->GetDevice()->End();
 }
 
 void mitk::PlanarFigureMapper2D::PaintPolyLine(const mitk::PlanarFigure::PolyLineType vertices,
                                                bool closed,
                                                Point2D &anchorPoint,
                                                const PlaneGeometry *planarFigurePlaneGeometry,
                                                const PlaneGeometry *rendererPlaneGeometry,
                                                const mitk::BaseRenderer *renderer)
 {
   mitk::Point2D rightMostPoint;
   rightMostPoint.Fill(itk::NumericTraits<float>::min());
 
   // transform all vertices into Point2Ds in display-Coordinates and store them in vector
   std::vector<mitk::Point2D> pointlist;
   for (auto iter = vertices.cbegin(); iter != vertices.cend(); ++iter)
   {
     // Draw this 2D point as OpenGL vertex
     mitk::Point2D displayPoint;
     this->TransformObjectToDisplay(*iter, displayPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
 
     pointlist.push_back(displayPoint);
 
     if (displayPoint[0] > rightMostPoint[0])
       rightMostPoint = displayPoint;
   }
 
   // If the planarfigure is closed, we add the first control point again.
   // Thus we can always use 'GL_LINE_STRIP' and get rid of strange flickering
   // effect when using the MESA OpenGL library.
   if (closed)
   {
     mitk::Point2D displayPoint;
     this->TransformObjectToDisplay(
       vertices.cbegin()[0], displayPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
 
     pointlist.push_back(displayPoint);
   }
 
   // now paint all the points in one run
 
   std::vector<float> points;
   points.reserve(pointlist.size() * 2);
 
   for (unsigned int i = 0 ; i < pointlist.size() ; ++i)
   {
     points.push_back(pointlist[i][0]);
     points.push_back(pointlist[i][1]);
   }
 
   if (2 <= pointlist.size())
     m_Context->DrawPoly(points.data(), pointlist.size());
 
   anchorPoint = rightMostPoint;
 }
 
 void mitk::PlanarFigureMapper2D::DrawMainLines(mitk::PlanarFigure *figure,
                                                Point2D &anchorPoint,
                                                const PlaneGeometry *planarFigurePlaneGeometry,
                                                const PlaneGeometry *rendererPlaneGeometry,
                                                const mitk::BaseRenderer *renderer)
 {
   const auto numberOfPolyLines = figure->GetPolyLinesSize();
   for (auto loop = 0; loop < numberOfPolyLines; ++loop)
   {
     const auto polyline = figure->GetPolyLine(loop);
 
     this->PaintPolyLine(
       polyline, figure->IsClosed(), anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
   }
 }
 
 void mitk::PlanarFigureMapper2D::DrawHelperLines(mitk::PlanarFigure *figure,
                                                  Point2D &anchorPoint,
                                                  const PlaneGeometry *planarFigurePlaneGeometry,
                                                  const PlaneGeometry *rendererPlaneGeometry,
                                                  const mitk::BaseRenderer *renderer)
 {
   const auto numberOfHelperPolyLines = figure->GetHelperPolyLinesSize();
 
   // Draw helper objects
   for (unsigned int loop = 0; loop < numberOfHelperPolyLines; ++loop)
   {
     const auto helperPolyLine =
       figure->GetHelperPolyLine(loop, renderer->GetScaleFactorMMPerDisplayUnit(), renderer->GetViewportSize()[1]);
 
     // Check if the current helper objects is to be painted
     if (!figure->IsHelperToBePainted(loop))
     {
       continue;
     }
 
     // ... and once normally above the shadow.
     this->PaintPolyLine(helperPolyLine, false, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
   }
 }
 
 void mitk::PlanarFigureMapper2D::TransformObjectToDisplay(const mitk::Point2D &point2D,
                                                           mitk::Point2D &displayPoint,
                                                           const mitk::PlaneGeometry *objectGeometry,
                                                           const mitk::PlaneGeometry * /*rendererGeometry*/,
                                                           const mitk::BaseRenderer *renderer)
 {
   mitk::Point3D point3D;
 
   // Map circle point from local 2D geometry into 3D world space
   objectGeometry->Map(point2D, point3D);
 
   // Project 3D world point onto display geometry
   renderer->WorldToView(point3D, displayPoint);
 }
 
 void mitk::PlanarFigureMapper2D::DrawMarker(const mitk::Point2D &point,
                                             float *lineColor,
                                             float lineOpacity,
                                             float *markerColor,
                                             float markerOpacity,
                                             float lineWidth,
                                             PlanarFigureControlPointStyleProperty::Shape shape,
                                             const mitk::PlaneGeometry *objectGeometry,
                                             const mitk::PlaneGeometry *rendererGeometry,
                                             const mitk::BaseRenderer *renderer)
 {
   if (this->GetDataNode() != nullptr && this->GetDataNode()->GetDataInteractor().IsNull())
     return;
 
   if (markerOpacity == 0 && lineOpacity == 0)
     return;
 
   mitk::Point2D displayPoint;
 
   this->TransformObjectToDisplay(point, displayPoint, objectGeometry, rendererGeometry, renderer);
 
   this->m_Context->GetPen()->SetColorF((double)markerColor[0], (double)markerColor[1], (double)markerColor[2], markerOpacity);
   this->m_Context->GetPen()->SetWidth(lineWidth);
 
   switch (shape)
   {
     case PlanarFigureControlPointStyleProperty::Square:
     default:
     {
       // Paint filled square
 
       if (markerOpacity > 0)
       {
         m_Context->DrawRect(displayPoint[0] - 4, displayPoint[1] - 4, 8, 8);
       }
 
       // Paint outline
       this->m_Context->GetPen()->SetColorF((double)lineColor[0], (double)lineColor[1], (double)lineColor[2], (double)lineOpacity);
 
       std::array<float, 8> outline = {{
         static_cast<float>(displayPoint[0] - 4),
         static_cast<float>(displayPoint[1] - 4),
         static_cast<float>(displayPoint[0] - 4),
         static_cast<float>(displayPoint[1] + 4),
         static_cast<float>(displayPoint[0] + 4),
         static_cast<float>(displayPoint[1] + 4),
         static_cast<float>(displayPoint[0] + 4),
         static_cast<float>(displayPoint[1] - 4)
       }};
 
       m_Context->DrawLines(outline.data(), 4);
       break;
     }
 
     case PlanarFigureControlPointStyleProperty::Circle:
     {
       // TODO: This code can not be reached using the properties provided in the GUI
 
       /*float radius = 4.0;
 
       if (markerOpacity > 0)
       {
         // Paint filled circle
         glBegin(GL_POLYGON);
         for (int angle = 0; angle < 8; ++angle)
         {
           float angleRad = angle * (float)3.14159 / 4.0;
           float x = displayPoint[0] + radius * (float)cos(angleRad);
           float y = displayPoint[1] + radius * (float)sin(angleRad);
           glVertex3f(x, y, PLANAR_OFFSET);
         }
         glEnd();
       }
 
       // Paint outline
       glColor4f(lineColor[0], lineColor[1], lineColor[2], lineOpacity);
       glBegin(GL_LINE_LOOP);
       for (int angle = 0; angle < 8; ++angle)
       {
         float angleRad = angle * (float)3.14159 / 4.0;
         float x = displayPoint[0] + radius * (float)cos(angleRad);
         float y = displayPoint[1] + radius * (float)sin(angleRad);
         glVertex3f(x, y, PLANAR_OFFSET);
       }
       glEnd();*/
       break;
     }
 
   } // end switch
 }
 
 void mitk::PlanarFigureMapper2D::InitializeDefaultPlanarFigureProperties()
 {
   m_IsSelected = false;
   m_IsHovering = false;
   m_DrawOutline = false;
   m_DrawQuantities = false;
   m_DrawShadow = false;
   m_DrawControlPoints = false;
   m_DrawName = true;
   m_DrawDashed = false;
   m_DrawHelperDashed = false;
   m_AnnotationsShadow = false;
 
   m_ShadowWidthFactor = 1.2;
   m_LineWidth = 1.0;
   m_OutlineWidth = 4.0;
   m_HelperlineWidth = 2.0;
 
   m_DevicePixelRatio = 1.0;
 
   m_ControlPointShape = PlanarFigureControlPointStyleProperty::Square;
 
   this->SetColorProperty(m_LineColor, PF_DEFAULT, 1.0, 1.0, 1.0);
   this->SetFloatProperty(m_LineOpacity, PF_DEFAULT, 1.0);
   this->SetColorProperty(m_OutlineColor, PF_DEFAULT, 0.0, 0.0, 1.0);
   this->SetFloatProperty(m_OutlineOpacity, PF_DEFAULT, 1.0);
   this->SetColorProperty(m_HelperlineColor, PF_DEFAULT, 0.4, 0.8, 0.2);
   this->SetFloatProperty(m_HelperlineOpacity, PF_DEFAULT, 0.4);
   this->SetColorProperty(m_MarkerlineColor, PF_DEFAULT, 1.0, 1.0, 1.0);
   this->SetFloatProperty(m_MarkerlineOpacity, PF_DEFAULT, 1.0);
   this->SetColorProperty(m_MarkerColor, PF_DEFAULT, 1.0, 1.0, 1.0);
   this->SetFloatProperty(m_MarkerOpacity, PF_DEFAULT, 0.0);
   this->SetColorProperty(m_AnnotationColor, PF_DEFAULT, 1.0, 1.0, 1.0);
 
   this->SetColorProperty(m_LineColor, PF_HOVER, 1.0, 0.7, 0.0);
   this->SetFloatProperty(m_LineOpacity, PF_HOVER, 1.0);
   this->SetColorProperty(m_OutlineColor, PF_HOVER, 0.0, 0.0, 1.0);
   this->SetFloatProperty(m_OutlineOpacity, PF_HOVER, 1.0);
   this->SetColorProperty(m_HelperlineColor, PF_HOVER, 0.4, 0.8, 0.2);
   this->SetFloatProperty(m_HelperlineOpacity, PF_HOVER, 0.4);
   this->SetColorProperty(m_MarkerlineColor, PF_HOVER, 1.0, 1.0, 1.0);
   this->SetFloatProperty(m_MarkerlineOpacity, PF_HOVER, 1.0);
   this->SetColorProperty(m_MarkerColor, PF_HOVER, 1.0, 0.6, 0.0);
   this->SetFloatProperty(m_MarkerOpacity, PF_HOVER, 0.2);
   this->SetColorProperty(m_AnnotationColor, PF_HOVER, 1.0, 0.7, 0.0);
 
   this->SetColorProperty(m_LineColor, PF_SELECTED, 1.0, 0.0, 0.0);
   this->SetFloatProperty(m_LineOpacity, PF_SELECTED, 1.0);
   this->SetColorProperty(m_OutlineColor, PF_SELECTED, 0.0, 0.0, 1.0);
   this->SetFloatProperty(m_OutlineOpacity, PF_SELECTED, 1.0);
   this->SetColorProperty(m_HelperlineColor, PF_SELECTED, 0.4, 0.8, 0.2);
   this->SetFloatProperty(m_HelperlineOpacity, PF_SELECTED, 0.4);
   this->SetColorProperty(m_MarkerlineColor, PF_SELECTED, 1.0, 1.0, 1.0);
   this->SetFloatProperty(m_MarkerlineOpacity, PF_SELECTED, 1.0);
   this->SetColorProperty(m_MarkerColor, PF_SELECTED, 1.0, 0.6, 0.0);
   this->SetFloatProperty(m_MarkerOpacity, PF_SELECTED, 1.0);
   this->SetColorProperty(m_AnnotationColor, PF_SELECTED, 1.0, 0.0, 0.0);
 }
 
 void mitk::PlanarFigureMapper2D::InitializePlanarFigurePropertiesFromDataNode(const mitk::DataNode *node)
 {
   if (node == nullptr)
   {
     return;
   }
 
   // if we have not added an observer for ModifiedEvents on the DataNode,
   // we add one now.
   if (!m_NodeModifiedObserverAdded)
   {
     itk::SimpleMemberCommand<mitk::PlanarFigureMapper2D>::Pointer nodeModifiedCommand =
       itk::SimpleMemberCommand<mitk::PlanarFigureMapper2D>::New();
     nodeModifiedCommand->SetCallbackFunction(this, &mitk::PlanarFigureMapper2D::OnNodeModified);
     m_NodeModifiedObserverTag = node->AddObserver(itk::ModifiedEvent(), nodeModifiedCommand);
     m_NodeModifiedObserverAdded = true;
   }
 
   // If the DataNode has not been modified since the last execution of
   // this method, we do not run it now.
   if (!m_NodeModified)
     return;
 
   // Mark the current properties as unmodified
   m_NodeModified = false;
 
   // Get Global Opacity
   float globalOpacity = 1.0;
   node->GetFloatProperty("opacity", globalOpacity);
 
   node->GetBoolProperty("selected", m_IsSelected);
   node->GetBoolProperty("planarfigure.ishovering", m_IsHovering);
   node->GetBoolProperty("planarfigure.drawoutline", m_DrawOutline);
   node->GetBoolProperty("planarfigure.drawshadow", m_DrawShadow);
   node->GetBoolProperty("planarfigure.drawquantities", m_DrawQuantities);
   node->GetBoolProperty("planarfigure.drawcontrolpoints", m_DrawControlPoints);
   node->GetBoolProperty("planarfigure.drawname", m_DrawName);
 
   node->GetBoolProperty("planarfigure.drawdashed", m_DrawDashed);
   node->GetBoolProperty("planarfigure.helperline.drawdashed", m_DrawHelperDashed);
 
   node->GetFloatProperty("planarfigure.line.width", m_LineWidth);
   node->GetFloatProperty("planarfigure.shadow.widthmodifier", m_ShadowWidthFactor);
   node->GetFloatProperty("planarfigure.outline.width", m_OutlineWidth);
   node->GetFloatProperty("planarfigure.helperline.width", m_HelperlineWidth);
 
   node->GetFloatProperty("planarfigure.devicepixelratio", m_DevicePixelRatio);
   node->GetStringProperty("planarfigure.annotations.font.family", m_AnnotationFontFamily);
   node->GetBoolProperty("planarfigure.annotations.font.bold", m_DrawAnnotationBold);
   node->GetBoolProperty("planarfigure.annotations.font.italic", m_DrawAnnotationItalic);
   node->GetIntProperty("planarfigure.annotations.font.size", m_AnnotationSize);
   if (!node->GetBoolProperty("planarfigure.annotations.shadow", m_AnnotationsShadow))
   {
     node->GetBoolProperty("planarfigure.drawshadow", m_AnnotationsShadow);
   }
 
   PlanarFigureControlPointStyleProperty::Pointer styleProperty =
     dynamic_cast<PlanarFigureControlPointStyleProperty *>(node->GetProperty("planarfigure.controlpointshape"));
   if (styleProperty.IsNotNull())
   {
     m_ControlPointShape = styleProperty->GetShape();
   }
 
   // Set default color and opacity
   // If property "planarfigure.default.*.color" exists, then use that color. Otherwise global "color" property is used.
   if (!node->GetColor(m_LineColor[PF_DEFAULT], nullptr, "planarfigure.default.line.color"))
   {
     node->GetColor(m_LineColor[PF_DEFAULT], nullptr, "color");
   }
   node->GetFloatProperty("planarfigure.default.line.opacity", m_LineOpacity[PF_DEFAULT]);
 
   if (!node->GetColor(m_OutlineColor[PF_DEFAULT], nullptr, "planarfigure.default.outline.color"))
   {
     node->GetColor(m_OutlineColor[PF_DEFAULT], nullptr, "color");
   }
   node->GetFloatProperty("planarfigure.default.outline.opacity", m_OutlineOpacity[PF_DEFAULT]);
 
   if (!node->GetColor(m_HelperlineColor[PF_DEFAULT], nullptr, "planarfigure.default.helperline.color"))
   {
     node->GetColor(m_HelperlineColor[PF_DEFAULT], nullptr, "color");
   }
   node->GetFloatProperty("planarfigure.default.helperline.opacity", m_HelperlineOpacity[PF_DEFAULT]);
 
   node->GetColor(m_MarkerlineColor[PF_DEFAULT], nullptr, "planarfigure.default.markerline.color");
   node->GetFloatProperty("planarfigure.default.markerline.opacity", m_MarkerlineOpacity[PF_DEFAULT]);
   node->GetColor(m_MarkerColor[PF_DEFAULT], nullptr, "planarfigure.default.marker.color");
   node->GetFloatProperty("planarfigure.default.marker.opacity", m_MarkerOpacity[PF_DEFAULT]);
   if (!node->GetColor(m_AnnotationColor[PF_DEFAULT], nullptr, "planarfigure.default.annotation.color"))
   {
     if (!node->GetColor(m_AnnotationColor[PF_DEFAULT], nullptr, "planarfigure.default.line.color"))
     {
       node->GetColor(m_AnnotationColor[PF_DEFAULT], nullptr, "color");
     }
   }
 
   // Set hover color and opacity
   node->GetColor(m_LineColor[PF_HOVER], nullptr, "planarfigure.hover.line.color");
   node->GetFloatProperty("planarfigure.hover.line.opacity", m_LineOpacity[PF_HOVER]);
   node->GetColor(m_OutlineColor[PF_HOVER], nullptr, "planarfigure.hover.outline.color");
   node->GetFloatProperty("planarfigure.hover.outline.opacity", m_OutlineOpacity[PF_HOVER]);
   node->GetColor(m_HelperlineColor[PF_HOVER], nullptr, "planarfigure.hover.helperline.color");
   node->GetFloatProperty("planarfigure.hover.helperline.opacity", m_HelperlineOpacity[PF_HOVER]);
   node->GetColor(m_MarkerlineColor[PF_HOVER], nullptr, "planarfigure.hover.markerline.color");
   node->GetFloatProperty("planarfigure.hover.markerline.opacity", m_MarkerlineOpacity[PF_HOVER]);
   node->GetColor(m_MarkerColor[PF_HOVER], nullptr, "planarfigure.hover.marker.color");
   node->GetFloatProperty("planarfigure.hover.marker.opacity", m_MarkerOpacity[PF_HOVER]);
   if (!node->GetColor(m_AnnotationColor[PF_HOVER], nullptr, "planarfigure.hover.annotation.color"))
   {
     if (!node->GetColor(m_AnnotationColor[PF_HOVER], nullptr, "planarfigure.hover.line.color"))
     {
       node->GetColor(m_AnnotationColor[PF_HOVER], nullptr, "color");
     }
   }
 
   // Set selected color and opacity
   node->GetColor(m_LineColor[PF_SELECTED], nullptr, "planarfigure.selected.line.color");
   node->GetFloatProperty("planarfigure.selected.line.opacity", m_LineOpacity[PF_SELECTED]);
   node->GetColor(m_OutlineColor[PF_SELECTED], nullptr, "planarfigure.selected.outline.color");
   node->GetFloatProperty("planarfigure.selected.outline.opacity", m_OutlineOpacity[PF_SELECTED]);
   node->GetColor(m_HelperlineColor[PF_SELECTED], nullptr, "planarfigure.selected.helperline.color");
   node->GetFloatProperty("planarfigure.selected.helperline.opacity", m_HelperlineOpacity[PF_SELECTED]);
   node->GetColor(m_MarkerlineColor[PF_SELECTED], nullptr, "planarfigure.selected.markerline.color");
   node->GetFloatProperty("planarfigure.selected.markerline.opacity", m_MarkerlineOpacity[PF_SELECTED]);
   node->GetColor(m_MarkerColor[PF_SELECTED], nullptr, "planarfigure.selected.marker.color");
   node->GetFloatProperty("planarfigure.selected.marker.opacity", m_MarkerOpacity[PF_SELECTED]);
   if (!node->GetColor(m_AnnotationColor[PF_SELECTED], nullptr, "planarfigure.selected.annotation.color"))
   {
     if (!node->GetColor(m_AnnotationColor[PF_SELECTED], nullptr, "planarfigure.selected.line.color"))
     {
       node->GetColor(m_AnnotationColor[PF_SELECTED], nullptr, "color");
     }
   }
 
   // adapt opacity values to global "opacity" property
   for (unsigned int i = 0; i < PF_COUNT; ++i)
   {
     m_LineOpacity[i] *= globalOpacity;
     m_OutlineOpacity[i] *= globalOpacity;
     m_HelperlineOpacity[i] *= globalOpacity;
     m_MarkerlineOpacity[i] *= globalOpacity;
     m_MarkerOpacity[i] *= globalOpacity;
   }
 }
 
 void mitk::PlanarFigureMapper2D::OnNodeModified()
 {
   m_NodeModified = true;
 }
 
 void mitk::PlanarFigureMapper2D::SetDefaultProperties(mitk::DataNode *node,
                                                       mitk::BaseRenderer *renderer,
                                                       bool overwrite)
 {
   node->AddProperty("visible", mitk::BoolProperty::New(true), renderer, overwrite);
 
   // node->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   node->AddProperty("planarfigure.isextendable", mitk::BoolProperty::New(false));
   // node->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
   node->AddProperty("planarfigure.drawoutline", mitk::BoolProperty::New(false));
   // node->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(true) );
   node->AddProperty("planarfigure.drawshadow", mitk::BoolProperty::New(true));
   node->AddProperty("planarfigure.drawcontrolpoints", mitk::BoolProperty::New(true));
   node->AddProperty("planarfigure.drawname", mitk::BoolProperty::New(true));
   node->AddProperty("planarfigure.drawdashed", mitk::BoolProperty::New(false));
   node->AddProperty("planarfigure.helperline.drawdashed", mitk::BoolProperty::New(false));
 
   node->AddProperty("planarfigure.annotations.font.family", mitk::StringProperty::New("Arial"));
   node->AddProperty("planarfigure.annotations.font.bold", mitk::BoolProperty::New(false));
   node->AddProperty("planarfigure.annotations.font.italic", mitk::BoolProperty::New(false));
   node->AddProperty("planarfigure.annotations.font.size", mitk::IntProperty::New(12));
 
   node->AddProperty("planarfigure.line.width", mitk::FloatProperty::New(2.0));
   node->AddProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0));
   node->AddProperty("planarfigure.outline.width", mitk::FloatProperty::New(2.0));
   node->AddProperty("planarfigure.helperline.width", mitk::FloatProperty::New(1.0));
 
   node->AddProperty("planarfigure.default.line.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.default.outline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.default.helperline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.default.markerline.color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
   node->AddProperty("planarfigure.default.markerline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.default.marker.color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
   node->AddProperty("planarfigure.default.marker.opacity", mitk::FloatProperty::New(1.0));
 
   node->AddProperty("planarfigure.hover.line.color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
   node->AddProperty("planarfigure.hover.line.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.hover.outline.color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
   node->AddProperty("planarfigure.hover.outline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.hover.helperline.color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
   node->AddProperty("planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
   node->AddProperty("planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
   node->AddProperty("planarfigure.hover.marker.opacity", mitk::FloatProperty::New(1.0));
 
   node->AddProperty("planarfigure.selected.line.color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
   node->AddProperty("planarfigure.selected.line.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
   node->AddProperty("planarfigure.selected.outline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
   node->AddProperty("planarfigure.selected.helperline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
   node->AddProperty("planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty("planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
   node->AddProperty("planarfigure.selected.marker.opacity", mitk::FloatProperty::New(1.0));
 }
 
 void mitk::PlanarFigureMapper2D::RenderControlPoints(const mitk::PlanarFigure *planarFigure,
                                                      const PlanarFigureDisplayMode lineDisplayMode,
                                                      const mitk::PlaneGeometry *planarFigurePlaneGeometry,
                                                      const mitk::PlaneGeometry *rendererPlaneGeometry,
                                                      mitk::BaseRenderer *renderer)
 {
   bool isEditable = true;
   m_DataNode->GetBoolProperty("planarfigure.iseditable", isEditable);
 
   PlanarFigureDisplayMode pointDisplayMode = PF_DEFAULT;
 
   const auto selectedControlPointsIdx = (unsigned int)planarFigure->GetSelectedControlPoint();
   const unsigned int numberOfControlPoints = planarFigure->GetNumberOfControlPoints();
   // Draw markers at control points (selected control point will be colored)
   for (unsigned int i = 0; i < numberOfControlPoints; ++i)
   {
     // Only if planar figure is marked as editable: display markers (control points) in a
     // different style if mouse is over them or they are selected
     if (isEditable)
     {
       if (i == selectedControlPointsIdx)
       {
         pointDisplayMode = PF_SELECTED;
       }
       else if (m_IsHovering && isEditable)
       {
         pointDisplayMode = PF_HOVER;
       }
     }
 
     if (m_MarkerOpacity[pointDisplayMode] == 0 && m_MarkerlineOpacity[pointDisplayMode] == 0)
     {
       continue;
     }
 
     if (m_DrawOutline)
     {
       // draw outlines for markers as well
       // linewidth for the contour is only half, as full width looks
       // much too thick!
       this->DrawMarker(planarFigure->GetControlPoint(i),
                        m_OutlineColor[lineDisplayMode],
                        m_MarkerlineOpacity[pointDisplayMode],
                        m_OutlineColor[lineDisplayMode],
                        m_MarkerOpacity[pointDisplayMode],
                        m_OutlineWidth / 2,
                        m_ControlPointShape,
                        planarFigurePlaneGeometry,
                        rendererPlaneGeometry,
                        renderer);
     }
 
     this->DrawMarker(planarFigure->GetControlPoint(i),
                      m_MarkerlineColor[pointDisplayMode],
                      m_MarkerlineOpacity[pointDisplayMode],
                      m_MarkerColor[pointDisplayMode],
                      m_MarkerOpacity[pointDisplayMode],
                      m_LineWidth,
                      m_ControlPointShape,
                      planarFigurePlaneGeometry,
                      rendererPlaneGeometry,
                      renderer);
   }
 
   if (planarFigure->IsPreviewControlPointVisible())
   {
     this->DrawMarker(planarFigure->GetPreviewControlPoint(),
                      m_MarkerlineColor[PF_HOVER],
                      m_MarkerlineOpacity[PF_HOVER],
                      m_MarkerColor[PF_HOVER],
                      m_MarkerOpacity[PF_HOVER],
                      m_LineWidth,
                      m_ControlPointShape,
                      planarFigurePlaneGeometry,
                      rendererPlaneGeometry,
                      renderer);
   }
 }
 
 void mitk::PlanarFigureMapper2D::RenderAnnotations(mitk::BaseRenderer *,
                                                    const std::string name,
                                                    const mitk::Point2D anchorPoint,
                                                    float globalOpacity,
                                                    const PlanarFigureDisplayMode lineDisplayMode,
                                                    double &annotationOffset)
 {
   if (anchorPoint[0] < mitk::eps || anchorPoint[1] < mitk::eps)
   {
     return;
   }
 
   vtkTextProperty* textProp = vtkTextProperty::New();
   textProp->SetFontSize(m_AnnotationSize);
   textProp->SetFontFamilyAsString(m_AnnotationFontFamily.c_str());
   textProp->SetJustificationToLeft();
   textProp->SetOpacity(globalOpacity);
   textProp->SetShadow(0);
   textProp->SetBold(m_DrawAnnotationBold);
   textProp->SetItalic(m_DrawAnnotationItalic);
 
   mitk::Point2D offset;
   offset.Fill(5);
 
   mitk::Point2D scaledAnchorPoint;
   scaledAnchorPoint[0] = anchorPoint[0] * m_DevicePixelRatio;
   scaledAnchorPoint[1] = anchorPoint[1] * m_DevicePixelRatio;
 
   offset[0] = offset[0] * m_DevicePixelRatio;
   offset[1] = offset[1] * m_DevicePixelRatio;
 
 
   if(m_DrawShadow)
   {
     textProp->SetColor(0.0,0.0,0.0);
     this->m_Context->ApplyTextProp(textProp);
     this->m_Context->DrawString(scaledAnchorPoint[0]+offset[0]+1, scaledAnchorPoint[1]+offset[1]-1, name.c_str());
   }
   textProp->SetColor(m_AnnotationColor[lineDisplayMode][0],
           m_AnnotationColor[lineDisplayMode][1],
           m_AnnotationColor[lineDisplayMode][2]);
   this->m_Context->ApplyTextProp(textProp);
   this->m_Context->DrawString(scaledAnchorPoint[0]+offset[0], scaledAnchorPoint[1]+offset[1], name.c_str());
 
   annotationOffset -= 15.0;
   //  annotationOffset -= m_AnnotationAnnotation->GetBoundsOnDisplay( renderer ).Size[1];
   textProp->Delete();
 }
 
 void mitk::PlanarFigureMapper2D::RenderQuantities(const mitk::PlanarFigure *planarFigure,
                                                   mitk::BaseRenderer *,
                                                   const mitk::Point2D anchorPoint,
                                                   double &annotationOffset,
                                                   float globalOpacity,
                                                   const PlanarFigureDisplayMode lineDisplayMode)
 {
   if (anchorPoint[0] < mitk::eps || anchorPoint[1] < mitk::eps)
   {
     return;
   }
 
   std::stringstream quantityString;
   quantityString.setf(ios::fixed, ios::floatfield);
   quantityString.precision(1);
 
   bool firstActiveFeature = true;
   for (unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i)
   {
     if (planarFigure->IsFeatureActive(i) && planarFigure->IsFeatureVisible(i))
     {
       if (!firstActiveFeature)
       {
         quantityString << " x ";
       }
       quantityString << planarFigure->GetQuantity(i) << " ";
       quantityString << planarFigure->GetFeatureUnit(i);
       firstActiveFeature = false;
     }
   }
 
   vtkTextProperty* textProp = vtkTextProperty::New();
   textProp->SetFontSize(m_AnnotationSize);
   textProp->SetFontFamilyAsString(m_AnnotationFontFamily.c_str());
   textProp->SetJustificationToLeft();
   textProp->SetOpacity(globalOpacity);
   textProp->SetShadow(0);
   textProp->SetBold(m_DrawAnnotationBold);
   textProp->SetItalic(m_DrawAnnotationItalic);
 
   mitk::Point2D offset;
   offset.Fill(5);
 
   mitk::Point2D scaledAnchorPoint;
   scaledAnchorPoint[0] = anchorPoint[0] * m_DevicePixelRatio;
   scaledAnchorPoint[1] = anchorPoint[1] * m_DevicePixelRatio;
 
   offset[0] = offset[0] * m_DevicePixelRatio;
   offset[1] = offset[1] * m_DevicePixelRatio;
 
 
   if(m_DrawShadow)
   {
     textProp->SetColor(0,0,0);
     this->m_Context->ApplyTextProp(textProp);
     this->m_Context->DrawString(scaledAnchorPoint[0]+offset[0]+1, scaledAnchorPoint[1]+offset[1]-1, quantityString.str().c_str());
   }
   textProp->SetColor(m_AnnotationColor[lineDisplayMode][0],
           m_AnnotationColor[lineDisplayMode][1],
           m_AnnotationColor[lineDisplayMode][2]);
   this->m_Context->ApplyTextProp(textProp);
   this->m_Context->DrawString(scaledAnchorPoint[0]+offset[0], scaledAnchorPoint[1]+offset[1], quantityString.str().c_str());
 
   annotationOffset -= 15.0;
   //  annotationOffset -= m_AnnotationAnnotation->GetBoundsOnDisplay( renderer ).Size[1];
   textProp->Delete();
 }
 
 void mitk::PlanarFigureMapper2D::RenderLines(const PlanarFigureDisplayMode lineDisplayMode,
                                              mitk::PlanarFigure *planarFigure,
                                              mitk::Point2D &anchorPoint,
                                              const mitk::PlaneGeometry *planarFigurePlaneGeometry,
                                              const mitk::PlaneGeometry *rendererPlaneGeometry,
                                              const mitk::BaseRenderer *renderer)
 {
   // If we want to draw an outline, we do it here
   if (m_DrawOutline)
   {
     const float *color = m_OutlineColor[lineDisplayMode];
     const float opacity = m_OutlineOpacity[lineDisplayMode];
 
     // set the color and opacity here as it is common for all outlines
 
     this->m_Context->GetPen()->SetColorF((double)color[0], (double)color[1], (double)color[2], opacity);
     this->m_Context->GetPen()->SetWidth(m_OutlineWidth);
 
     if (m_DrawDashed)
       this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
     else
       this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
 
     // Draw the outline for all polylines if requested
     this->DrawMainLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
 
     this->m_Context->GetPen()->SetWidth(m_HelperlineWidth);
 
     if (m_DrawHelperDashed)
       this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
     else
       this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
 
     // Draw the outline for all helper objects if requested
     this->DrawHelperLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
   }
 
   // If we want to draw a shadow, we do it here
   if (m_DrawShadow)
   {
     // determine the shadow opacity
     const float opacity = m_OutlineOpacity[lineDisplayMode];
     float shadowOpacity = 0.0f;
     if (opacity > 0.2f)
       shadowOpacity = opacity - 0.2f;
 
     // set the color and opacity here as it is common for all shadows
     this->m_Context->GetPen()->SetColorF(0, 0, 0, shadowOpacity);
     this->m_Context->GetPen()->SetWidth(m_OutlineWidth * m_ShadowWidthFactor);
 
     if (m_DrawDashed)
       this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
     else
       this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
 
     // Draw the outline for all polylines if requested
     this->DrawMainLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
 
     this->m_Context->GetPen()->SetWidth(m_HelperlineWidth);
 
     if (m_DrawHelperDashed)
       this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
     else
       this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
 
     // Draw the outline for all helper objects if requested
     this->DrawHelperLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
   }
 
   // set this in brackets to avoid duplicate variables in the same scope
   {
     const float *color = m_LineColor[lineDisplayMode];
     const float opacity = m_LineOpacity[lineDisplayMode];
 
     // set the color and opacity here as it is common for all mainlines
 
     this->m_Context->GetPen()->SetColorF((double)color[0], (double)color[1], (double)color[2], (double)opacity);
     this->m_Context->GetPen()->SetWidth(m_LineWidth);
 
     if (m_DrawDashed)
       this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
     else
       this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
 
     // Draw the main line for all polylines
     this->DrawMainLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
 
     const float *helperColor = m_HelperlineColor[lineDisplayMode];
     const float helperOpacity = m_HelperlineOpacity[lineDisplayMode];
 
     // we only set the color for the helperlines as the linewidth is unchanged
     this->m_Context->GetPen()->SetColorF((double)helperColor[0], (double)helperColor[1], (double)helperColor[2], (double)helperOpacity);
     this->m_Context->GetPen()->SetWidth(m_HelperlineWidth);
 
     if (m_DrawHelperDashed)
       this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
     else
       this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
 
 
     // Draw helper objects
     this->DrawHelperLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
   }
 
   if (m_DrawDashed || m_DrawHelperDashed)
     this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
 }
diff --git a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
index 2724e47848..103e6de46a 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,136 +1,136 @@
 /*============================================================================
 
 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
 
 #include "MitkQtWidgetsExports.h"
 
 // qt widgets module
 #include "QmitkAbstractMultiWidget.h"
 #include <QmitkSynchronizedNodeSelectionWidget.h>
 #include <QmitkSynchronizedWidgetConnector.h>
 
 #include <nlohmann/json.hpp>
 
 class QSplitter;
 
 /**
 * @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");
+                      const QString& multiWidgetName = "mxn");
 
   ~QmitkMxNMultiWidget();
 
   void InitializeMultiWidget() override;
 
   void Synchronize(bool synchronized) override;
 
   QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
   QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
 
   void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget) override;
 
   /**
   * @brief Initialize the active render windows of the MxNMultiWidget to the given geometry.
   *
   * @param geometry       The geometry to be used to initialize / update the
   *                       active render window's time and slice navigation controller.
   * @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 InitializeViews(const mitk::TimeGeometry* geometry, bool resetCamera) override;
 
   /**
   * @brief Forward the given time geometry to all base renderers, so that they can store it as their
   *        interaction reference geometry.
   *        This will update the alignment status of the reference geometry for each base renderer.
   *        For more details, see 'BaseRenderer::SetInteractionReferenceGeometry'.
   *        Overridem from 'QmitkAbstractMultiWidget'.
   */
   void SetInteractionReferenceGeometry(const mitk::TimeGeometry* referenceGeometry) 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 EnableCrosshair();
   void DisableCrosshair();
 
 public Q_SLOTS:
 
   // mouse events
   void wheelEvent(QWheelEvent* e) override;
   void mousePressEvent(QMouseEvent* e) override;
   void moveEvent(QMoveEvent* e) override;
   void LoadLayout(const nlohmann::json* jsonData);
   void SaveLayout(std::ostream* outStream);
 
 Q_SIGNALS:
 
   void WheelMoved(QWheelEvent *);
   void Moved();
   void UpdateUtilityWidgetViewPlanes();
   void LayoutChanged();
 
 protected:
 
   void RemoveRenderWindowWidget() override;
 
 private:
 
   void SetLayoutImpl() override;
   void SetInteractionSchemeImpl() override { }
 
   QmitkAbstractMultiWidget::RenderWindowWidgetPointer CreateRenderWindowWidget();
   void SetInitialSelection();
   void ToggleSynchronization(QmitkSynchronizedNodeSelectionWidget* synchronizedWidget);
 
   static nlohmann::json BuildJSONFromLayout(const QSplitter* splitter);
   QSplitter* BuildLayoutFromJSON(const nlohmann::json* jsonData, unsigned int* windowCounter, QSplitter* parentSplitter = nullptr);
 
   mitk::SliceNavigationController* m_TimeNavigationController;
   std::unique_ptr<QmitkSynchronizedWidgetConnector> m_SynchronizedWidgetConnector;
 
   bool m_CrosshairVisibility;
 
 };
 
 #endif
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index 3b2f599304..40ac5e11a1 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,633 +1,633 @@
 /*============================================================================
 
 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"
 
 // mitk core
 #include <mitkDisplayActionEventFunctions.h>
 #include <mitkDisplayActionEventHandlerDesynchronized.h>
 #include <mitkDisplayActionEventHandlerSynchronized.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateProperty.h>
 
 // mitk qt widget
 #include <QmitkRenderWindowUtilityWidget.h>
 #include <QmitkRenderWindowWidget.h>
 
 // qt
 #include <QGridLayout>
 #include <QMessageBox>
 #include <QSplitter>
 
 #include <fstream>
 
 QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
                                          Qt::WindowFlags f/* = 0*/,
-                                         const QString& multiWidgetName/* = "mxnmulti"*/)
+                                         const QString& multiWidgetName/* = "mxn"*/)
   : QmitkAbstractMultiWidget(parent, f, multiWidgetName)
   , m_TimeNavigationController(nullptr)
   , m_SynchronizedWidgetConnector(std::make_unique<QmitkSynchronizedWidgetConnector>())
   , 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();
   }
 
   this->SetInitialSelection();
 }
 
 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::AnatomicalPlane& /*orientation*/) const
 {
   // 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::InitializeViews(const mitk::TimeGeometry* geometry, 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 (geometry->IsValidTimePoint(currentTimePoint))
     {
       imageTimeStep = geometry->TimePointToTimeStep(currentTimePoint);
     }
   }
 
   // initialize active render window
   renderingManager->InitializeView(
     this->GetActiveRenderWindowWidget()->GetRenderWindow()->GetVtkRenderWindow(), geometry, resetCamera);
 
   if (!resetCamera)
   {
     this->SetSelectedPosition(currentPosition, "");
     renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
   }
 }
 
 void QmitkMxNMultiWidget::SetInteractionReferenceGeometry(const mitk::TimeGeometry* referenceGeometry)
 {
   // Set the interaction reference referenceGeometry for all render windows.
   auto allRenderWindows = this->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     auto* baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow->GetRenderWindow());
     baseRenderer->SetInteractionReferenceGeometry(referenceGeometry);
   }
 }
 
 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::EnableCrosshair()
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->EnableCrosshair();
   }
 }
 
 void QmitkMxNMultiWidget::DisableCrosshair()
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->DisableCrosshair();
   }
 }
 
 //////////////////////////////////////////////////////////////////////////
 // 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);
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::CreateRenderWindowWidget()
 {
   // create the render window widget and connect signal / slot
   QString renderWindowWidgetName = GetNameFromIndex(GetNumberOfRenderWindowWidgets());
   RenderWindowWidgetPointer renderWindowWidget = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget);
 
   auto renderWindow = renderWindowWidget->GetRenderWindow();
 
   QmitkRenderWindowUtilityWidget* utilityWidget = new QmitkRenderWindowUtilityWidget(this, renderWindow, GetDataStorage());
   renderWindowWidget->AddUtilityWidget(utilityWidget);
 
   connect(utilityWidget, &QmitkRenderWindowUtilityWidget::SynchronizationToggled,
     this, &QmitkMxNMultiWidget::ToggleSynchronization);
   connect(this, &QmitkMxNMultiWidget::UpdateUtilityWidgetViewPlanes,
     utilityWidget, &QmitkRenderWindowUtilityWidget::UpdateViewPlaneSelection);
 
   // needs to be done after 'QmitkRenderWindowUtilityWidget::ToggleSynchronization' has been connected
   // initially synchronize the node selection widget
   utilityWidget->ToggleSynchronization(true);
 
   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 referenceGeometry 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);
 
   return renderWindowWidget;
 }
 
 void QmitkMxNMultiWidget::LoadLayout(const nlohmann::json* jsonData)
 {
   if ((*jsonData).is_null())
   {
     QMessageBox::warning(this, "Load layout", "Could not read window layout");
     return;
   }
 
   unsigned int windowCounter = 0;
 
   try
   {
     auto version = jsonData->at("version").get<std::string>();
     if (version != "1.0")
     {
       QMessageBox::warning(this, "Load layout", "Unknown layout version, could not load");
       return;
     }
 
     delete this->layout();
     auto content = BuildLayoutFromJSON(jsonData, &windowCounter);
     auto hBoxLayout = new QHBoxLayout(this);
     this->setLayout(hBoxLayout);
     hBoxLayout->addWidget(content);
     emit UpdateUtilityWidgetViewPlanes();
   }
   catch (nlohmann::json::out_of_range& e)
   {
     MITK_ERROR << "Error in loading window layout from JSON: " << e.what();
     return;
   }
 
   while (GetNumberOfRenderWindowWidgets() > windowCounter)
   {
     RemoveRenderWindowWidget();
   }
 
   EnableCrosshair();
   emit LayoutChanged();
 }
 
 void QmitkMxNMultiWidget::SaveLayout(std::ostream* outStream)
 {
   if (outStream == nullptr)
   {
     return;
   }
 
   auto layout = this->layout();
   if (layout == nullptr)
     return;
 
   // There should only ever be one item: a splitter
   auto widget = layout->itemAt(0)->widget();
   auto splitter = dynamic_cast<QSplitter*>(widget);
   if (!splitter)
   {
     MITK_ERROR << "Tried to save unexpected layout format. Make sure the layout of this instance contains a single QSplitter.";
     return;
   }
 
   auto layoutJSON = BuildJSONFromLayout(splitter);
   layoutJSON["version"] = "1.0";
   layoutJSON["name"] = "Custom Layout";
 
   *outStream << std::setw(4) << layoutJSON << std::endl;
 
 }
 
 nlohmann::json QmitkMxNMultiWidget::BuildJSONFromLayout(const QSplitter* splitter)
 {
   nlohmann::json resultJSON;
   resultJSON["isWindow"] = false;
   resultJSON["vertical"] = (splitter->orientation() == Qt::Vertical) ? true : false;
   auto sizes = splitter->sizes();
 
   auto content = nlohmann::json::array();
 
   auto countSplitter = splitter->count();
   for (int i = 0; i < countSplitter; ++i)
   {
     auto widget = splitter->widget(i);
     nlohmann::json widgetJSON;
     if (auto widgetSplitter = dynamic_cast<QSplitter*>(widget); widgetSplitter)
     {
       widgetJSON = BuildJSONFromLayout(widgetSplitter);
     }
     else if (auto widgetWindow = dynamic_cast<QmitkRenderWindowWidget*>(widget); widgetWindow)
     {
       widgetJSON["isWindow"] = true;
       widgetJSON["viewDirection"] = widgetWindow->GetSliceNavigationController()->GetViewDirectionAsString();
     }
     widgetJSON["size"] = sizes[i];
     content.push_back(widgetJSON);
   }
   resultJSON["content"] = content;
   return resultJSON;
 }
 
 QSplitter* QmitkMxNMultiWidget::BuildLayoutFromJSON(const nlohmann::json* jsonData, unsigned int* windowCounter, QSplitter* parentSplitter)
 {
 
   bool vertical = jsonData->at("vertical").get<bool>();
   auto orientation = vertical ? Qt::Vertical : Qt::Horizontal;
 
   auto split = new QSplitter(orientation, parentSplitter);
   QList<int> sizes;
 
   for (auto object : jsonData->at("content"))
   {
     bool isWindow = object["isWindow"].get<bool>();
     int size = object["size"].get<int>();
     sizes.append(size);
 
     if (isWindow)
     {
       auto viewDirection = object["viewDirection"].get<std::string>();
       mitk::AnatomicalPlane viewPlane = mitk::AnatomicalPlane::Sagittal;
       if (viewDirection == "Axial")
       {
         viewPlane = mitk::AnatomicalPlane::Axial;
       }
       else if (viewDirection == "Coronal")
       {
         viewPlane = mitk::AnatomicalPlane::Coronal;
       }
       else if (viewDirection == "Original")
       {
         viewPlane = mitk::AnatomicalPlane::Original;
       }
       else if (viewDirection == "Sagittal")
       {
         viewPlane = mitk::AnatomicalPlane::Sagittal;
       }
 
       QmitkAbstractMultiWidget::RenderWindowWidgetPointer window = nullptr;
       QString renderWindowName;
       QmitkAbstractMultiWidget::RenderWindowWidgetMap::iterator it;
 
       // repurpose existing render windows as far as they already exist
       if (*windowCounter < GetRenderWindowWidgets().size())
       {
         renderWindowName = this->GetNameFromIndex(*windowCounter);
         auto renderWindowWidgets = GetRenderWindowWidgets();
         it = renderWindowWidgets.find(renderWindowName);
         if (it != renderWindowWidgets.end())
         {
           window = it->second;
         }
         else
         {
           MITK_ERROR << "Could not find render window " << renderWindowName.toStdString() << ", although it should be there.";
         }
       }
 
       if (window == nullptr)
       {
         window = CreateRenderWindowWidget();
       }
 
       window->GetSliceNavigationController()->SetDefaultViewDirection(viewPlane);
       window->GetSliceNavigationController()->Update();
       split->addWidget(window.get());
       window->show();
       (*windowCounter)++;
     }
     else
     {
       auto subSplitter = BuildLayoutFromJSON(&object, windowCounter, split);
       split->addWidget(subSplitter);
     }
   }
   split->setSizes(sizes);
 
   return split;
 
 }
 
 void QmitkMxNMultiWidget::SetInitialSelection()
 {
   auto dataStorage = this->GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   mitk::NodePredicateAnd::Pointer noHelperObjects = mitk::NodePredicateAnd::New();
   noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
   auto allNodes = dataStorage->GetSubset(noHelperObjects);
   QmitkSynchronizedNodeSelectionWidget::NodeList currentSelection;
   for (auto& node : *allNodes)
   {
     currentSelection.append(node);
   }
 
   m_SynchronizedWidgetConnector->ChangeSelection(currentSelection);
 }
 
 void QmitkMxNMultiWidget::ToggleSynchronization(QmitkSynchronizedNodeSelectionWidget* synchronizedWidget)
 {
   bool synchronized = synchronizedWidget->IsSynchronized();
 
   if (synchronized)
   {
     m_SynchronizedWidgetConnector->ConnectWidget(synchronizedWidget);
     m_SynchronizedWidgetConnector->SynchronizeWidget(synchronizedWidget);
   }
   else
   {
     m_SynchronizedWidgetConnector->DisconnectWidget(synchronizedWidget);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
index 59772bcbac..fee5a07e50 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
@@ -1,244 +1,244 @@
 /*============================================================================
 
 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 "QmitkMxNMultiWidgetEditor.h"
 
 #include <mitkCoreServices.h>
 #include <mitkIPreferencesService.h>
 #include <mitkIPreferences.h>
 
 #include <berryIWorkbenchPage.h>
 #include <berryIWorkbenchPartConstants.h>
 #include <berryUIException.h>
 
 // mxn multi widget editor plugin
 #include "QmitkMultiWidgetDecorationManager.h"
 
 // mitk qt widgets module
 #include <QmitkMxNMultiWidget.h>
 #include <QmitkInteractionSchemeToolBar.h>
 #include <QmitkMultiWidgetConfigurationToolBar.h>
 
 // qt
 #include <QHBoxLayout>
 
 const QString QmitkMxNMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.mxnmultiwidget";
 
 struct QmitkMxNMultiWidgetEditor::Impl final
 {
   Impl();
   ~Impl() = default;
 
   QmitkInteractionSchemeToolBar* m_InteractionSchemeToolBar;
   QmitkMultiWidgetConfigurationToolBar* m_ConfigurationToolBar;
 };
 
 QmitkMxNMultiWidgetEditor::Impl::Impl()
   : m_InteractionSchemeToolBar(nullptr)
   , m_ConfigurationToolBar(nullptr)
 {
   // nothing here
 }
 
 //////////////////////////////////////////////////////////////////////////
 // QmitkMxNMultiWidgetEditor
 //////////////////////////////////////////////////////////////////////////
 QmitkMxNMultiWidgetEditor::QmitkMxNMultiWidgetEditor()
   : QmitkAbstractMultiWidgetEditor()
   , m_Impl(std::make_unique<Impl>())
 {
   // nothing here
 }
 
 QmitkMxNMultiWidgetEditor::~QmitkMxNMultiWidgetEditor()
 {
   GetSite()->GetPage()->RemovePartListener(this);
 }
 
 berry::IPartListener::Events::Types QmitkMxNMultiWidgetEditor::GetPartEventTypes() const
 {
   return Events::CLOSED | Events::OPENED | Events::HIDDEN | Events::VISIBLE;
 }
 
 void QmitkMxNMultiWidgetEditor::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
     if (nullptr != multiWidget)
     {
       multiWidget->ActivateMenuWidget(false);
     }
   }
 }
 
 void QmitkMxNMultiWidgetEditor::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
     if (nullptr != multiWidget)
     {
       multiWidget->EnableCrosshair();
       multiWidget->ActivateMenuWidget(true);
     }
   }
 }
 
 void QmitkMxNMultiWidgetEditor::PartHidden(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
     if (nullptr != multiWidget)
     {
       multiWidget->ActivateMenuWidget(false);
     }
   }
 }
 
 void QmitkMxNMultiWidgetEditor::PartVisible(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
     if (nullptr != multiWidget)
     {
       multiWidget->ActivateMenuWidget(true);
     }
   }
 }
 
 void QmitkMxNMultiWidgetEditor::OnLayoutSet(int row, int column)
 {
   const auto &multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
   if (nullptr != multiWidget)
   {
     QmitkAbstractMultiWidgetEditor::OnLayoutSet(row, column);
     multiWidget->EnableCrosshair();
   }
 }
 
 void QmitkMxNMultiWidgetEditor::OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
 {
   const auto &multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return;
   }
 
   if (mitk::InteractionSchemeSwitcher::PACSStandard == scheme)
   {
     m_Impl->m_InteractionSchemeToolBar->setVisible(true);
   }
   else
   {
     m_Impl->m_InteractionSchemeToolBar->setVisible(false);
   }
 
   QmitkAbstractMultiWidgetEditor::OnInteractionSchemeChanged(scheme);
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidgetEditor::SetFocus()
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr != multiWidget)
   {
     multiWidget->setFocus();
   }
 }
 
 void QmitkMxNMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   QHBoxLayout *layout = new QHBoxLayout(parent);
   layout->setContentsMargins(0, 0, 0, 0);
 
   auto* preferences = this->GetPreferences();
 
   auto multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
-    multiWidget = new QmitkMxNMultiWidget(parent, 0, nullptr);
+    multiWidget = new QmitkMxNMultiWidget(parent);
 
     // create left toolbar: interaction scheme toolbar to switch how the render window navigation behaves in PACS mode
     if (nullptr == m_Impl->m_InteractionSchemeToolBar)
     {
       m_Impl->m_InteractionSchemeToolBar = new QmitkInteractionSchemeToolBar(parent);
       layout->addWidget(m_Impl->m_InteractionSchemeToolBar);
     }
     m_Impl->m_InteractionSchemeToolBar->SetInteractionEventHandler(multiWidget->GetInteractionEventHandler());
 
     multiWidget->SetDataStorage(GetDataStorage());
     multiWidget->InitializeMultiWidget();
     SetMultiWidget(multiWidget);
     connect(static_cast<QmitkMxNMultiWidget*>(multiWidget), &QmitkMxNMultiWidget::LayoutChanged,
       this, &QmitkMxNMultiWidgetEditor::OnLayoutChanged);
   }
 
   layout->addWidget(multiWidget);
 
   // create right toolbar: configuration toolbar to change the render window widget layout
   if (nullptr == m_Impl->m_ConfigurationToolBar)
   {
     m_Impl->m_ConfigurationToolBar = new QmitkMultiWidgetConfigurationToolBar(multiWidget);
     layout->addWidget(m_Impl->m_ConfigurationToolBar);
   }
 
   connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::LayoutSet,
           this, &QmitkMxNMultiWidgetEditor::OnLayoutSet);
   connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::Synchronized,
           this, &QmitkMxNMultiWidgetEditor::OnSynchronize);
   connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::InteractionSchemeChanged,
           this, &QmitkMxNMultiWidgetEditor::OnInteractionSchemeChanged);
   connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::SaveLayout,
     static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::SaveLayout, Qt::DirectConnection);
   connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::LoadLayout,
     static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::LoadLayout);
 
   GetSite()->GetPage()->AddPartListener(this);
 
   OnPreferencesChanged(preferences);
 }
 
 void QmitkMxNMultiWidgetEditor::OnPreferencesChanged(const mitk::IPreferences* preferences)
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return;
   }
 
   // update decoration preferences
   //m_Impl->m_MultiWidgetDecorationManager->DecorationPreferencesChanged(preferences);
 
   int crosshairGapSize = preferences->GetInt("crosshair gap size", 32);
   multiWidget->SetCrosshairGap(crosshairGapSize);
 
   // zooming and panning preferences
   bool constrainedZooming = preferences->GetBool("Use constrained zooming and panning", true);
   mitk::RenderingManager::GetInstance()->SetConstrainedPanningZooming(constrainedZooming);
 
   bool PACSInteractionScheme = preferences->GetBool("PACS like mouse interaction", false);
   OnInteractionSchemeChanged(PACSInteractionScheme ?
     mitk::InteractionSchemeSwitcher::PACSStandard :
     mitk::InteractionSchemeSwitcher::MITKStandard);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkMxNMultiWidgetEditor::OnLayoutChanged()
 {
   FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
 }