diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index aae74f80bb..6146d1e0e7 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,272 +1,273 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkMxNMultiWidget.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkDisplayActionEventFunctions.h>
 #include <mitkDisplayActionEventHandlerDesynchronized.h>
 #include <mitkDisplayActionEventHandlerSynchronized.h>
 
 // qt
 #include <QGridLayout>
 
 QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          const QString& multiWidgetName/* = "mxnmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, multiWidgetName)
   , m_CrosshairVisibility(false)
 {
   // nothing here
 }
 
 void QmitkMxNMultiWidget::InitializeMultiWidget()
 {
   SetLayout(1, 1);
   ActivateMenuWidget(true);
   SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
   auto displayActionEventHandler = GetDisplayActionEventHandler();
   if (nullptr != displayActionEventHandler)
   {
     displayActionEventHandler->InitActions();
   }
 }
 
 void QmitkMxNMultiWidget::MultiWidgetOpened()
 {
   SetCrosshairVisibility(true);
 }
 
 void QmitkMxNMultiWidget::MultiWidgetClosed()
 {
   SetCrosshairVisibility(false);
 }
 
 void QmitkMxNMultiWidget::Synchronize(bool synchronized)
 {
   if (synchronized)
   {
     SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerSynchronized>());
   }
   else
   {
     SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
   }
 
   auto displayActionEventHandler = GetDisplayActionEventHandler();
   if (nullptr != displayActionEventHandler)
   {
     displayActionEventHandler->InitActions();
   }
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   if ("axial" == widgetName || "sagittal" == widgetName || "coronal" == widgetName || "3d" == widgetName)
   {
     return GetActiveRenderWindowWidget()->GetRenderWindow();
   }
 
   return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& /*viewDirection*/) const
 {
   // currently no mapping between view directions and render windows
   // simply return the currently active render window
   return GetActiveRenderWindowWidget()->GetRenderWindow();
 }
 
 void QmitkMxNMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
 {
   auto currentActiveRenderWindowWidget = GetActiveRenderWindowWidget();
   if (currentActiveRenderWindowWidget == activeRenderWindowWidget)
   {
     return;
   }
 
   // reset the decoration color of the previously active render window widget
   if (nullptr != currentActiveRenderWindowWidget)
   {
     auto decorationColor = currentActiveRenderWindowWidget->GetDecorationColor();
     QColor hexColor(decorationColor[0] * 255, decorationColor[1] * 255, decorationColor[2] * 255);
-    currentActiveRenderWindowWidget->setStyleSheet("border: 2px solid " + hexColor.name(QColor::HexRgb));
+    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("border: 2px solid #FF6464");
+    activeRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid #FF6464; }");
   }
 
   QmitkAbstractMultiWidget::SetActiveRenderWindowWidget(activeRenderWindowWidget);
 }
 
 void QmitkMxNMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget;
   if (widgetName.isNull())
   {
     renderWindowWidget = GetActiveRenderWindowWidget();
   }
   else
   {
     renderWindowWidget = GetRenderWindowWidget(widgetName);
   }
 
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
     renderWindowWidget->RequestUpdate();
     return;
   }
 
   MITK_ERROR << "Position can not be set for an unknown render window widget.";
 }
 
 const mitk::Point3D QmitkMxNMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
 {
   // see T26208
   return mitk::Point3D();
 }
 
 void QmitkMxNMultiWidget::SetCrosshairVisibility(bool activate)
 {
   auto renderWindowWidgets = GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->ActivateCrosshair(activate);
   }
 
   m_CrosshairVisibility = activate;
 }
 
 void QmitkMxNMultiWidget::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(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;
   }
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PUBLIC SLOTS
 // MOUSE EVENTS
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkMxNMultiWidget::mousePressEvent(QMouseEvent* e)
 {
   if (QEvent::MouseButtonPress != e->type())
   {
     return;
   }
 
   auto renderWindowWidget = dynamic_cast<QmitkRenderWindowWidget*>(this->sender());
   if (nullptr == renderWindowWidget)
   {
     return;
   }
 
   auto renderWindowWidgetPointer = GetRenderWindowWidget(renderWindowWidget->GetWidgetName());
   SetActiveRenderWindowWidget(renderWindowWidgetPointer);
 }
 
 void QmitkMxNMultiWidget::moveEvent(QMoveEvent* e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the overlays as the MultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::SetLayoutImpl()
 {
   int requiredRenderWindowWidgets = GetRowCount() * GetColumnCount();
   int existingRenderWindowWidgets = GetRenderWindowWidgets().size();
 
   int difference = requiredRenderWindowWidgets - existingRenderWindowWidgets;
   while (0 < difference)
   {
     // more render window widgets needed
     CreateRenderWindowWidget();
     --difference;
   }
 
   while (0 > difference)
   {
     // less render window widgets needed
     RemoveRenderWindowWidget();
     ++difference;
   }
 
   auto firstRenderWindowWidget = GetFirstRenderWindowWidget();
   if (nullptr != firstRenderWindowWidget)
   {
     SetActiveRenderWindowWidget(firstRenderWindowWidget);
   }
 
   GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
 }
 
 void QmitkMxNMultiWidget::CreateRenderWindowWidget()
 {
   // create the render window widget and connect signal / slot
   QString renderWindowWidgetName = GetNameFromIndex(GetNumberOfRenderWindowWidgets());
   RenderWindowWidgetPointer renderWindowWidget = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
 
   connect(renderWindowWidget.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkMxNMultiWidget::mousePressEvent);
 
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget);
 
   auto renderWindow = renderWindowWidget->GetRenderWindow();
   auto layoutManager = GetMultiWidgetLayoutManager();
   connect(renderWindow, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(renderWindow, &QmitkRenderWindow::ResetView, this, &QmitkMxNMultiWidget::ResetCrosshair);
   connect(renderWindow, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkMxNMultiWidget::SetCrosshairVisibility);
   connect(renderWindow, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkMxNMultiWidget::SetWidgetPlaneMode);
 }
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
index daaaadefa6..c30c15cd4f 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
@@ -1,254 +1,251 @@
 /*============================================================================
 
 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_PointSetNode(nullptr)
   , m_PointSet(nullptr)
 {
   this->InitializeGUI();
 }
 
 QmitkRenderWindowWidget::~QmitkRenderWindowWidget()
 {
   auto sliceNavigationController = m_RenderWindow->GetSliceNavigationController();
   if (nullptr != sliceNavigationController)
   {
     sliceNavigationController->SetCrosshairEvent.RemoveListener(mitk::MessageDelegate1<QmitkRenderWindowWidget, mitk::Point3D>(this, &QmitkRenderWindowWidget::SetCrosshair));
   }
   if (nullptr != m_DataStorage)
   {
     m_DataStorage->Remove(m_PointSetNode);
   }
 }
 
 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::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::ActivateCrosshair(bool activate)
 {
   if (nullptr == m_DataStorage)
   {
     return;
   }
 
   if (activate)
   {
     try
     {
       m_DataStorage->Add(m_PointSetNode);
     }
     catch(std::invalid_argument& /*e*/)
     {
       // crosshair already existing
       return;
     }
   }
   else
   {
     m_DataStorage->Remove(m_PointSetNode);
   }
 }
 
 void QmitkRenderWindowWidget::InitializeGUI()
 {
   m_Layout = new QHBoxLayout(this);
   m_Layout->setMargin(0);
   setLayout(m_Layout);
   setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   setContentsMargins(0, 0, 0, 0);
 
   if (nullptr == m_DataStorage)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->SetDataStorage(m_DataStorage);
 
   // create render window for this render window widget
   m_RenderWindow = new QmitkRenderWindow(this, m_WidgetName, nullptr);
   m_RenderWindow->SetLayoutIndex(mitk::BaseRenderer::ViewDirection::SAGITTAL);
   m_RenderWindow->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
   m_RenderWindow->GetSliceNavigationController()->SetCrosshairEvent.AddListener(mitk::MessageDelegate1<QmitkRenderWindowWidget, mitk::Point3D>(this, &QmitkRenderWindowWidget::SetCrosshair));
 
   connect(m_RenderWindow, &QmitkRenderWindow::mouseEvent, this, &QmitkRenderWindowWidget::MouseEvent);
 
   mitk::TimeGeometry::ConstPointer timeGeometry = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews(timeGeometry);
   m_Layout->addWidget(m_RenderWindow);
 
   // add point set as a crosshair
   m_PointSetNode = mitk::DataNode::New();
   m_PointSetNode->SetProperty("name", mitk::StringProperty::New("Crosshair of render window " + m_WidgetName.toStdString()));
   m_PointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true)); // crosshair-node should typically be invisible
 
   // set the crosshair only visible for this specific renderer
   m_PointSetNode->SetBoolProperty("fixedLayer", true, m_RenderWindow->GetRenderer());
   m_PointSetNode->SetVisibility(true, m_RenderWindow->GetRenderer());
   m_PointSetNode->SetVisibility(false);
 
   m_PointSet = mitk::PointSet::New();
   m_PointSetNode->SetData(m_PointSet);
 
   // set colors and corner annotation
   InitializeDecorations();
 }
 
 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 decoration color, rectangle and annotation text
-  float white[3] = { 1.0f, 1.0f, 1.0f };
-  m_DecorationColor = white;
-
+  // initialize annotation text and decoration color
   setFrameStyle(QFrame::Box | QFrame::Plain);
-  QColor hexColor(m_DecorationColor[0] * 255, m_DecorationColor[1] * 255, m_DecorationColor[2] * 255);
-  setStyleSheet("border: 2px solid " + hexColor.name(QColor::HexRgb));
 
   m_CornerAnnotation = vtkSmartPointer<vtkCornerAnnotation>::New();
   m_CornerAnnotation->SetText(0, "Sagittal");
   m_CornerAnnotation->SetMaximumFontSize(12);
-  m_CornerAnnotation->GetTextProperty()->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
   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::SetCrosshair(mitk::Point3D selectedPoint)
 {
   m_PointSet->SetPoint(1, selectedPoint, 0);
   mitk::RenderingManager::GetInstance()->RequestUpdate(m_RenderWindow->renderWindow());
 }