diff --git a/Modules/Core/src/Rendering/mitkCrosshairVtkMapper2D.cpp b/Modules/Core/src/Rendering/mitkCrosshairVtkMapper2D.cpp
index 313dcc34ce..9545f4fd01 100644
--- a/Modules/Core/src/Rendering/mitkCrosshairVtkMapper2D.cpp
+++ b/Modules/Core/src/Rendering/mitkCrosshairVtkMapper2D.cpp
@@ -1,244 +1,262 @@
 /*============================================================================
 
 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 "mitkCrosshairVtkMapper2D.h"
 
 // mitk includes
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkDataNode.h>
 #include <mitkProperties.h>
 
 // vtk includes
 #include <mitkIPropertyAliases.h>
 #include <vtkActor2D.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 #include <vtkLine.h>
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper2D.h>
 #include <vtkProperty2D.h>
 
+namespace
+{
+  void SwapInvertedCoordinates(mitk::Point2D& displayBoundsMinimum, mitk::Point2D& displayBoundsMaximum)
+  {
+    for (int i = 0; i < 2; ++i)
+    {
+      if (displayBoundsMaximum[i] < displayBoundsMinimum[i])
+      {
+        auto temporarySwapVariable = displayBoundsMaximum[i];
+        displayBoundsMaximum[i] = displayBoundsMinimum[i];
+        displayBoundsMinimum[i] = temporarySwapVariable;
+      }
+    }
+  }
+}
+
 const mitk::CrosshairData* mitk::CrosshairVtkMapper2D::GetInput() const
 {
   return static_cast<CrosshairData*>(this->GetDataNode()->GetData());
 }
 
 mitk::CrosshairVtkMapper2D::CrosshairVtkMapper2D()
   : defaultGapSize(32)
 {
 }
 
 mitk::CrosshairVtkMapper2D::~CrosshairVtkMapper2D()
 {
 }
 
 void mitk::CrosshairVtkMapper2D::Update(mitk::BaseRenderer* renderer)
 {
   const auto* node = this->GetDataNode();
   if (nullptr == node)
   {
     return;
   }
 
   bool visible = true;
   node->GetVisibility(visible, renderer, "visible");
   if (!visible)
   {
     // Do not render crosshair for base renderer, if the
     // crosshair data node is not visible in that base renderer.
     return;
   }
 
   const auto* data = static_cast<mitk::CrosshairData*>(node->GetData());
   if (nullptr == data)
   {
     // Do not render crosshair for base renderer, if the
     // base data node is no crosshair data.
     return;
   }
 
   this->GenerateDataForRenderer(renderer);
 }
 
 vtkProp* mitk::CrosshairVtkMapper2D::GetVtkProp(BaseRenderer* renderer)
 {
   LocalStorage* ls = m_LSH.GetLocalStorage(renderer);
   return ls->m_CrosshairAssembly;
 }
 
 void mitk::CrosshairVtkMapper2D::SetDefaultProperties(DataNode* node,
                                                       BaseRenderer* renderer,
                                                       bool overwrite)
 {
   CoreServicePointer<IPropertyAliases> aliases(CoreServices::GetPropertyAliases());
   node->AddProperty("Line width", FloatProperty::New(1), renderer, overwrite);
   aliases->AddAlias("line width", "Crosshair.Line Width", "");
   node->AddProperty("Crosshair.Gap Size", IntProperty::New(32), renderer, overwrite);
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 void mitk::CrosshairVtkMapper2D::GenerateDataForRenderer(BaseRenderer* renderer)
 {
   LocalStorage* ls = m_LSH.GetLocalStorage(renderer);
   ls->UpdateGenerateDataTime();
 
   this->CreateVtkCrosshair(renderer);
 
   this->ApplyAllProperties(renderer);
 }
 
 void mitk::CrosshairVtkMapper2D::CreateVtkCrosshair(BaseRenderer* renderer)
 {
   LocalStorage* ls = m_LSH.GetLocalStorage(renderer);
   ls->m_CrosshairActor->SetVisibility(0);
 
   CrosshairData::ConstPointer input = this->GetInput();
   Point3D crosshairPosition = input->GetPosition();
 
   // check if node is inside the renderer geometry
   bool isInside = renderer->GetWorldTimeGeometry()->IsWorldPointInside(crosshairPosition);
   if (!isInside)
   {
     // no need to draw crosshair lines
     return;
   }
 
   int gapSize = defaultGapSize;
   this->GetDataNode()->GetPropertyValue("Crosshair.Gap Size", gapSize, nullptr);
 
   vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPolyData> linesPolyData = vtkSmartPointer<vtkPolyData>::New();
 
   // convert 3D crosshair crosshairPosition to 2D point
   Point2D displayPoint;
   renderer->WorldToDisplay(crosshairPosition, displayPoint);
   Point2D displayPointOne = displayPoint;
   Point2D displayPointTwo = displayPoint;
   Point3D worldPointOne;
   Point3D worldPointTwo;
 
   // convert geometry bounds from 3D to 2D
   const auto worldBounds = renderer->GetWorldTimeGeometry()->GetBoundsInWorld();
   Point3D worldBoundsMinimum;
   worldBoundsMinimum[0] = worldBounds[0];
   worldBoundsMinimum[1] = worldBounds[2];
   worldBoundsMinimum[2] = worldBounds[4];
 
   Point3D worldBoundsMaximum;
   worldBoundsMaximum[0] = worldBounds[1];
   worldBoundsMaximum[1] = worldBounds[3];
   worldBoundsMaximum[2] = worldBounds[5];
 
   Point2D displayBoundsMinimum;
   Point2D displayBoundsMaximum;
   renderer->WorldToDisplay(worldBoundsMinimum, displayBoundsMinimum);
   renderer->WorldToDisplay(worldBoundsMaximum, displayBoundsMaximum);
 
+  SwapInvertedCoordinates(displayBoundsMinimum, displayBoundsMaximum);
+
   // define points for the first / left half of the crosshair x-line
   displayPointOne[0] = displayBoundsMinimum[0];
   displayPointTwo[0] = displayPoint[0] - gapSize;
   renderer->DisplayToWorld(displayPointOne, worldPointOne);
   renderer->DisplayToWorld(displayPointTwo, worldPointTwo);
   this->DrawLine(worldPointOne, worldPointTwo, lines, points);
 
   // define points for the second / right half of the crosshair x-line
   displayPointOne[0] = displayPoint[0] + gapSize;
   displayPointTwo[0] = displayBoundsMaximum[0];
   renderer->DisplayToWorld(displayPointOne, worldPointOne);
   renderer->DisplayToWorld(displayPointTwo, worldPointTwo);
   this->DrawLine(worldPointOne, worldPointTwo, lines, points);
 
   // reset 2D points
   displayPointOne = displayPoint;
   displayPointTwo = displayPoint;
 
   // define points for the first / bottom half of the crosshair y-line
   displayPointOne[1] = displayBoundsMinimum[1];
   displayPointTwo[1] = displayPoint[1] - gapSize;
   renderer->DisplayToWorld(displayPointOne, worldPointOne);
   renderer->DisplayToWorld(displayPointTwo, worldPointTwo);
   this->DrawLine(worldPointOne, worldPointTwo, lines, points);
 
   // define points for the second / top half of the crosshair y-line
   displayPointOne[1] = displayPoint[1] + gapSize;
   displayPointTwo[1] = displayBoundsMaximum[1];
   renderer->DisplayToWorld(displayPointOne, worldPointOne);
   renderer->DisplayToWorld(displayPointTwo, worldPointTwo);
   this->DrawLine(worldPointOne, worldPointTwo, lines, points);
 
   // set vtk data with the created points and lines
   linesPolyData->SetPoints(points);
   linesPolyData->SetLines(lines);
   ls->m_Mapper->SetInputData(linesPolyData);
   ls->m_CrosshairActor->SetMapper(ls->m_Mapper);
   ls->m_CrosshairActor->SetVisibility(1);
 }
 
 void mitk::CrosshairVtkMapper2D::DrawLine(Point3D p0, Point3D p1, vtkCellArray* lines, vtkPoints* points)
 {
   vtkIdType pidStart = points->InsertNextPoint(p0[0], p0[1], p0[2]);
   vtkIdType pidEnd = points->InsertNextPoint(p1[0], p1[1], p1[2]);
 
   vtkSmartPointer<vtkLine> lineVtk = vtkSmartPointer<vtkLine>::New();
   lineVtk->GetPointIds()->SetId(0, pidStart);
   lineVtk->GetPointIds()->SetId(1, pidEnd);
 
   lines->InsertNextCell(lineVtk);
 }
 
 void mitk::CrosshairVtkMapper2D::ApplyAllProperties(BaseRenderer* renderer)
 {
   LocalStorage* ls = m_LSH.GetLocalStorage(renderer);
   ApplyColorAndOpacityProperties2D(renderer, ls->m_CrosshairActor);
 
   float thickness;
   this->GetDataNode()->GetFloatProperty("Line width", thickness, renderer);
   ls->m_CrosshairActor->GetProperty()->SetLineWidth(thickness);
 }
 
 void mitk::CrosshairVtkMapper2D::ApplyColorAndOpacityProperties2D(BaseRenderer* renderer, vtkActor2D* actor)
 {
   float rgba[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
   DataNode* node = GetDataNode();
 
   // check for color prop and use it for rendering if it exists
   node->GetColor(rgba, renderer, "color");
   // check for opacity prop and use it for rendering if it exists
   node->GetOpacity(rgba[3], renderer, "opacity");
 
   double drgba[4] = { rgba[0], rgba[1], rgba[2], rgba[3] };
   actor->GetProperty()->SetColor(drgba);
   actor->GetProperty()->SetOpacity(drgba[3]);
 }
 
 mitk::CrosshairVtkMapper2D::LocalStorage::LocalStorage()
 {
   m_CrosshairAssembly = vtkSmartPointer<vtkPropAssembly>::New();
   m_CrosshairActor = vtkSmartPointer<vtkActor2D>::New();
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper2D>::New();
 
   m_CrosshairActor->SetMapper(m_Mapper);
   m_CrosshairActor->SetVisibility(0);
   m_CrosshairAssembly->AddPart(m_CrosshairActor);
 
   vtkCoordinate *tcoord = vtkCoordinate::New();
   tcoord->SetCoordinateSystemToWorld();
   m_Mapper->SetTransformCoordinate(tcoord);
   tcoord->Delete();
 }
 
 mitk::CrosshairVtkMapper2D::LocalStorage::~LocalStorage()
 {
 }
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index a7d674b631..b95255b87c 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,630 +1,632 @@
 /*============================================================================
 
 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"*/)
   : 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();
 }
 
 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/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
index 2704321fac..be42977ed0 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
@@ -1,316 +1,317 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkRenderWindowWidget.h"
 
 // vtk
 #include <vtkCornerAnnotation.h>
 #include <vtkTextProperty.h>
 
 QmitkRenderWindowWidget::QmitkRenderWindowWidget(QWidget* parent/* = nullptr*/,
                                                  const QString& widgetName/* = ""*/,
                                                  mitk::DataStorage* dataStorage/* = nullptr*/)
   : QFrame(parent)
   , m_WidgetName(widgetName)
   , m_DataStorage(dataStorage)
   , m_RenderWindow(nullptr)
   , m_CrosshairManager(nullptr)
 {
   this->InitializeGUI();
 }
 
 QmitkRenderWindowWidget::~QmitkRenderWindowWidget()
 {
   auto sliceNavigationController = this->GetSliceNavigationController();
   if (nullptr != sliceNavigationController)
   {
     sliceNavigationController->SetCrosshairEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkRenderWindowWidget, const mitk::Point3D &>(
         this, &QmitkRenderWindowWidget::SetCrosshairPosition));
   }
+  this->DisableCrosshair();
 }
 
 void QmitkRenderWindowWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (dataStorage == m_DataStorage)
   {
     return;
   }
 
   m_DataStorage = dataStorage;
   if (nullptr != m_RenderWindow)
   {
     mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow())->SetDataStorage(dataStorage);
   }
 }
 
 mitk::SliceNavigationController* QmitkRenderWindowWidget::GetSliceNavigationController() const
 {
   return m_RenderWindow->GetSliceNavigationController();
 }
 
 void QmitkRenderWindowWidget::RequestUpdate()
 {
   mitk::RenderingManager::GetInstance()->RequestUpdate(m_RenderWindow->renderWindow());
 }
 
 void QmitkRenderWindowWidget::ForceImmediateUpdate()
 {
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(m_RenderWindow->renderWindow());
 }
 
 void QmitkRenderWindowWidget::AddUtilityWidget(QWidget* utilityWidget)
 {
   m_Layout->insertWidget(0, utilityWidget);
 }
 
 void QmitkRenderWindowWidget::SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower)
 {
   vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
   if (nullptr == vtkRenderer)
   {
     return;
   }
 
   m_GradientBackgroundColors.first = upper;
   m_GradientBackgroundColors.second = lower;
   vtkRenderer->SetBackground(lower[0], lower[1], lower[2]);
   vtkRenderer->SetBackground2(upper[0], upper[1], upper[2]);
 
   ShowGradientBackground(true);
 }
 
 void QmitkRenderWindowWidget::ShowGradientBackground(bool show)
 {
   m_RenderWindow->GetRenderer()->GetVtkRenderer()->SetGradientBackground(show);
 }
 
 bool QmitkRenderWindowWidget::IsGradientBackgroundOn() const
 {
   return m_RenderWindow->GetRenderer()->GetVtkRenderer()->GetGradientBackground();
 }
 
 void QmitkRenderWindowWidget::SetDecorationColor(const mitk::Color& color)
 {
   m_DecorationColor = color;
   m_CornerAnnotation->GetTextProperty()->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
 
   QColor hexColor(m_DecorationColor[0] * 255, m_DecorationColor[1] * 255, m_DecorationColor[2] * 255);
   setStyleSheet("QmitkRenderWindowWidget { border: 2px solid " + hexColor.name(QColor::HexRgb) + "; }");
 }
 
 void QmitkRenderWindowWidget::ShowColoredRectangle(bool show)
 {
   if (show)
   {
     setFrameStyle(QFrame::Box | QFrame::Plain);
   }
   else
   {
     setFrameStyle(NoFrame);
   }
 }
 
 bool QmitkRenderWindowWidget::IsColoredRectangleVisible() const
 {
   return frameStyle() > 0;
 }
 
 void QmitkRenderWindowWidget::ShowCornerAnnotation(bool show)
 {
   m_CornerAnnotation->SetVisibility(show);
 }
 
 bool QmitkRenderWindowWidget::IsCornerAnnotationVisible() const
 {
   return m_CornerAnnotation->GetVisibility() > 0;
 }
 
 void QmitkRenderWindowWidget::SetCornerAnnotationText(const std::string& cornerAnnotation)
 {
   m_CornerAnnotation->SetText(0, cornerAnnotation.c_str());
 }
 
 std::string QmitkRenderWindowWidget::GetCornerAnnotationText() const
 {
   return std::string(m_CornerAnnotation->GetText(0));
 }
 
 bool QmitkRenderWindowWidget::IsRenderWindowMenuActivated() const
 {
   return m_RenderWindow->GetActivateMenuWidgetFlag();
 }
 
 void QmitkRenderWindowWidget::SetCrosshairVisibility(bool visible)
 {
   m_CrosshairManager->SetCrosshairVisibility(visible, m_RenderWindow->GetRenderer());
   this->RequestUpdate();
 }
 
 bool QmitkRenderWindowWidget::GetCrosshairVisibility()
 {
   return m_CrosshairManager->GetCrosshairVisibility(m_RenderWindow->GetRenderer());
 }
 
 void QmitkRenderWindowWidget::SetCrosshairGap(unsigned int gapSize)
 {
   m_CrosshairManager->SetCrosshairGap(gapSize);
 }
 
 void QmitkRenderWindowWidget::EnableCrosshair()
 {
   m_CrosshairManager->AddCrosshairNodeToDataStorage(m_DataStorage);
 }
 
 void QmitkRenderWindowWidget::DisableCrosshair()
 {
   m_CrosshairManager->RemoveCrosshairNodeFromDataStorage(m_DataStorage);
 }
 
 void QmitkRenderWindowWidget::InitializeGUI()
 {
   m_Layout = new QVBoxLayout(this);
   m_Layout->setMargin(0);
   setLayout(m_Layout);
   setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   setContentsMargins(0, 0, 0, 0);
 
   if (nullptr == m_DataStorage)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->SetDataStorage(m_DataStorage);
 
   // create render window for this render window widget
   m_RenderWindow = new QmitkRenderWindow(this, m_WidgetName, nullptr);
   m_RenderWindow->SetLayoutIndex(mitk::AnatomicalPlane::Sagittal);
   connect(m_RenderWindow, &QmitkRenderWindow::ResetGeometry,
     this, &QmitkRenderWindowWidget::OnResetGeometry);
 
   auto* sliceNavigationController = this->GetSliceNavigationController();
   sliceNavigationController->SetDefaultViewDirection(mitk::AnatomicalPlane::Sagittal);
 
   m_Layout->addWidget(m_RenderWindow);
 
   // set colors and corner annotation
   InitializeDecorations();
 
   // use crosshair manager
   m_CrosshairManager = mitk::CrosshairManager::New(m_RenderWindow->GetRenderer());
   sliceNavigationController->SetCrosshairEvent.AddListener(
     mitk::MessageDelegate1<QmitkRenderWindowWidget, const mitk::Point3D &>(
       this, &QmitkRenderWindowWidget::SetCrosshairPosition));
 
   // finally add observer, after all relevant objects have been created / initialized
   sliceNavigationController->ConnectGeometrySendEvent(this);
   sliceNavigationController->ConnectGeometrySliceEvent(this);
 
   mitk::TimeGeometry::ConstPointer timeGeometry = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeView(m_RenderWindow->GetVtkRenderWindow(), timeGeometry);
 }
 
 void QmitkRenderWindowWidget::InitializeDecorations()
 {
   vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
   if (nullptr == vtkRenderer)
   {
     return;
   }
 
   // initialize background color gradients
   float black[3] = { 0.0f, 0.0f, 0.0f };
   SetGradientBackgroundColors(black, black);
 
   // initialize annotation text and decoration color
   setFrameStyle(QFrame::Box | QFrame::Plain);
 
   m_CornerAnnotation = vtkSmartPointer<vtkCornerAnnotation>::New();
   m_CornerAnnotation->SetText(0, "Sagittal");
   m_CornerAnnotation->SetMaximumFontSize(12);
   if (0 == vtkRenderer->HasViewProp(m_CornerAnnotation))
   {
     vtkRenderer->AddViewProp(m_CornerAnnotation);
   }
 
   float white[3] = { 1.0f, 1.0f, 1.0f };
   SetDecorationColor(mitk::Color(white));
 }
 
 void QmitkRenderWindowWidget::SetCrosshairPosition(const mitk::Point3D& newPosition)
 {
   m_CrosshairManager->SetCrosshairPosition(newPosition);
   this->RequestUpdate();
 }
 
 mitk::Point3D QmitkRenderWindowWidget::GetCrosshairPosition() const
 {
   return m_CrosshairManager->GetCrosshairPosition();
 }
 
 void QmitkRenderWindowWidget::SetGeometry(const itk::EventObject& event)
 {
   if (!mitk::SliceNavigationController::GeometrySendEvent(nullptr, 0).CheckEvent(&event))
   {
     return;
   }
 
   const auto* sliceNavigationController = this->GetSliceNavigationController();
   m_CrosshairManager->UpdateCrosshairPosition(sliceNavigationController);
 }
 
 void QmitkRenderWindowWidget::SetGeometrySlice(const itk::EventObject& event)
 {
   if (!mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0).CheckEvent(&event))
   {
     return;
   }
 
   const auto* sliceNavigationController = this->GetSliceNavigationController();
   m_CrosshairManager->UpdateCrosshairPosition(sliceNavigationController);
 }
 
 void QmitkRenderWindowWidget::OnResetGeometry()
 {
   const auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->GetRenderWindow());
   const auto* interactionReferenceGeometry = baseRenderer->GetInteractionReferenceGeometry();
   this->ResetGeometry(interactionReferenceGeometry);
   m_RenderWindow->ShowOverlayMessage(false);
 }
 
 void QmitkRenderWindowWidget::ResetGeometry(const mitk::TimeGeometry* referenceGeometry)
 {
   if (nullptr == referenceGeometry)
   {
     return;
   }
 
   mitk::TimeStepType imageTimeStep = 0;
 
   // store the current position to set it again later, if the camera should not be reset
   mitk::Point3D currentPosition = this->GetCrosshairPosition();
 
   // store the current time step to set it again later, if the camera should not be reset
   auto* renderingManager = mitk::RenderingManager::GetInstance();
   const auto currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
   if (referenceGeometry->IsValidTimePoint(currentTimePoint))
   {
     imageTimeStep = referenceGeometry->TimePointToTimeStep(currentTimePoint);
   }
 
   const auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow());
   renderingManager->InitializeView(baseRenderer->GetRenderWindow(), referenceGeometry, false);
 
   // reset position and time step
   this->GetSliceNavigationController()->SelectSliceByPoint(currentPosition);
   renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
 }
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
index bc536b0f6a..7675c4257e 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
@@ -1,238 +1,237 @@
 /*============================================================================
 
 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->DisableCrosshair();
       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);
 
     // 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);
   }
 
   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();
 }