diff --git a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutManager.h b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutManager.h
index 0c5b2dd6a1..2a39a28bf1 100644
--- a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutManager.h
+++ b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutManager.h
@@ -1,94 +1,94 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QMITKMULTIWIDGETLAYOUTMANAGER_H
 #define QMITKMULTIWIDGETLAYOUTMANAGER_H
 
 #include "MitkQtWidgetsExports.h"
 
 #include <QObject>
 
 class QmitkAbstractMultiWidget;
 class QmitkRenderWindowWidget;
 
 /**
 * @brief
 *
 *
 */
 class MITKQTWIDGETS_EXPORT QmitkMultiWidgetLayoutManager : public QObject
 {
   Q_OBJECT
 
 public:
 
   enum class LayoutDesign
   {
     DEFAULT = 0,
     ALL_2D_TOP_3D_BOTTOM,
     ALL_2D_LEFT_3D_RIGHT,
     ONE_BIG,
     ONLY_2D_HORIZONTAL,
     ONLY_2D_VERTICAL,
     ONE_TOP_3D_BOTTOM,
     ONE_LEFT_3D_RIGHT,
     ALL_HORIZONTAL,
     ALL_VERTICAL,
     REMOVE_ONE,
     NONE
   };
 
   QmitkMultiWidgetLayoutManager(QmitkAbstractMultiWidget* multiwidget);
 
   /**
   * @brief This function is called by render window widgets. Given a specific
   *        layout design the layout of the multi widget data member is set with this method.
   */
-  void OnLayoutDesignChanged(LayoutDesign layoutDesign);
+  void SetLayoutDesign(LayoutDesign layoutDesign);
   /**
   * @brief Allow setting the current render window widget without relying on the sending object.
   *
-  *    Calling 'OnLayoutDesignChanged' will overwrite the current render window widget but using the public
-  *    layout setter the current render window widget cna be defined using the function.
+  *    Calling 'SetLayoutDesign' will overwrite the current render window widget but using the public
+  *    layout setter the current render window widget can be defined using the function.
   *    This is necessary for layouts that work with a specific selected render window widget.
   */
   void SetCurrentRenderWindowWidget(QmitkRenderWindowWidget* renderWindowWidget);
 
   void SetDefaultLayout();
   void SetAll2DTop3DBottomLayout();
   void SetAll2DLeft3DRightLayout();
 
   void SetOneBigLayout();
 
   void SetOnly2DHorizontalLayout();
   void SetOnly2DVerticalLayout();
 
   void SetOneTop3DBottomLayout();
   void SetOneLeft3DRightLayout();
 
   void SetAllHorizontalLayout();
   void SetAllVerticalLayout();
 
   void RemoveOneLayout();
 
 private:
 
   QmitkAbstractMultiWidget* m_MultiWidget;
   QmitkRenderWindowWidget* m_CurrentRenderWindowWidget;
 
 };
 
 #endif // QMITKMULTIWIDGETLAYOUTMANAGER_H
diff --git a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutManager.cpp b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutManager.cpp
index aa20567644..6d4ed1ef36 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutManager.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutManager.cpp
@@ -1,541 +1,541 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkMultiWidgetLayoutManager.h"
 
 #include <mitkLogMacros.h>
 #include <QmitkAbstractMultiWidget.h>
 #include <QmitkRenderWindow.h>
 #include <QmitkRenderWindowWidget.h>
 
 // qt
 #include <QHBoxLayout>
 #include <QSPlitter>
 
 QmitkMultiWidgetLayoutManager::QmitkMultiWidgetLayoutManager(QmitkAbstractMultiWidget* multiwidget)
   : QObject(multiwidget)
   , m_MultiWidget(multiwidget)
   , m_CurrentRenderWindowWidget(nullptr)
 {
   // nothing here
 }
 
-void QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged(LayoutDesign layoutDesign)
+void QmitkMultiWidgetLayoutManager::SetLayoutDesign(LayoutDesign layoutDesign)
 {
   if (nullptr == m_MultiWidget)
   {
     return;
   }
 
   // retrieve the render window name from the sending render window
   auto renderWindow = dynamic_cast<QmitkRenderWindow*>(QObject::sender());
   m_CurrentRenderWindowWidget = m_MultiWidget->GetRenderWindowWidget(renderWindow).get();
 
   switch (layoutDesign)
   {
   case LayoutDesign::DEFAULT:
   {
     SetDefaultLayout();
     break;
   }
   case LayoutDesign::ALL_2D_TOP_3D_BOTTOM:
   {
     SetAll2DTop3DBottomLayout();
     break;
   }
   case LayoutDesign::ALL_2D_LEFT_3D_RIGHT:
   {
     SetAll2DLeft3DRightLayout();
     break;
   }
   case LayoutDesign::ONE_BIG:
   {
     SetOneBigLayout();
     break;
   }
   case LayoutDesign::ONLY_2D_HORIZONTAL:
   {
     SetOnly2DHorizontalLayout();
     break;
   }
   case LayoutDesign::ONLY_2D_VERTICAL:
   {
     SetOnly2DVerticalLayout();
     break;
   }
   case LayoutDesign::ONE_TOP_3D_BOTTOM:
   {
     SetOneTop3DBottomLayout();
     break;
   }
   case LayoutDesign::ONE_LEFT_3D_RIGHT:
   {
     SetOneLeft3DRightLayout();
     break;
   }
   case LayoutDesign::ALL_HORIZONTAL:
   {
     SetAllHorizontalLayout();
     break;
   }
   case LayoutDesign::ALL_VERTICAL:
   {
     SetAllVerticalLayout();
     break;
   }
   case LayoutDesign::REMOVE_ONE:
   {
     RemoveOneLayout();
     break;
   }
   };
 }
 
 void QmitkMultiWidgetLayoutManager::SetCurrentRenderWindowWidget(QmitkRenderWindowWidget* renderWindowWidget)
 {
   m_CurrentRenderWindowWidget = renderWindowWidget;
 }
 
 void QmitkMultiWidgetLayoutManager::SetDefaultLayout()
 {
   MITK_INFO << "Set default layout" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   delete m_MultiWidget->layout();
 
   auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   m_MultiWidget->setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   auto mainSplit = new QSplitter(Qt::Vertical, m_MultiWidget);
   hBoxLayout->addWidget(mainSplit);
 
   QList<int> splitterSizeRow;
   for (int row = 0; row < m_MultiWidget->GetRowCount(); ++row)
   {
     splitterSizeRow.push_back(1000);
 
     QList<int> splitterSizeColumn;
     auto splitter = new QSplitter(mainSplit);
     for (int column = 0; column < m_MultiWidget->GetColumnCount(); ++column)
     {
       splitterSizeColumn.push_back(1000);
       auto renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(row, column);
       splitter->addWidget(renderWindowWidget.get());
       renderWindowWidget->show();
     }
     splitter->setSizes(splitterSizeColumn);
   }
 
   mainSplit->setSizes(splitterSizeRow);
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::DEFAULT);
   }
 }
 
 void QmitkMultiWidgetLayoutManager::SetAll2DTop3DBottomLayout()
 {
   MITK_INFO << "Set all 2D top and 3D bottom layout" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   delete m_MultiWidget->layout();
 
   auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   m_MultiWidget->setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   auto mainSplit = new QSplitter(Qt::Vertical, m_MultiWidget);
   hBoxLayout->addWidget(mainSplit);
 
   auto subSplit2D = new QSplitter(mainSplit);
   QList<int> splitterSize;
   auto all2DRenderWindowWidgets = m_MultiWidget->Get2DRenderWindowWidgets();
   for (const auto& renderWindowWidget : all2DRenderWindowWidgets)
   {
     subSplit2D->addWidget(renderWindowWidget.second.get());
     renderWindowWidget.second->show();
     splitterSize.push_back(1000);
   }
   subSplit2D->setSizes(splitterSize);
 
   auto subSplit3D = new QSplitter(mainSplit);
   splitterSize.clear();
   auto all3DRenderWindowWidgets = m_MultiWidget->Get3DRenderWindowWidgets();
   for (const auto& renderWindowWidget : all3DRenderWindowWidgets)
   {
     subSplit3D->addWidget(renderWindowWidget.second.get());
     renderWindowWidget.second->show();
     splitterSize.push_back(1000);
   }
   subSplit3D->setSizes(splitterSize);
 
   // set size for main splitter
   splitterSize.clear();
   splitterSize.push_back(600);
   splitterSize.push_back(1000);
   mainSplit->setSizes(splitterSize);
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::ALL_2D_TOP_3D_BOTTOM);
   }
 }
 
 void QmitkMultiWidgetLayoutManager::SetAll2DLeft3DRightLayout()
 {
   MITK_INFO << "Set all 2D left and 3D right layout" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   delete m_MultiWidget->layout();
 
   auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   m_MultiWidget->setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   auto mainSplit = new QSplitter(m_MultiWidget);
   hBoxLayout->addWidget(mainSplit);
 
   auto subSplit2D = new QSplitter(Qt::Vertical, mainSplit);
   QList<int> splitterSize;
   auto all2DRenderWindowWidgets = m_MultiWidget->Get2DRenderWindowWidgets();
   for (const auto& renderWindowWidget : all2DRenderWindowWidgets)
   {
     subSplit2D->addWidget(renderWindowWidget.second.get());
     renderWindowWidget.second->show();
     splitterSize.push_back(1000);
   }
   subSplit2D->setSizes(splitterSize);
 
   auto subSplit3D = new QSplitter( mainSplit);
   splitterSize.clear();
   auto all3DRenderWindowWidgets = m_MultiWidget->Get3DRenderWindowWidgets();
   for (const auto& renderWindowWidget : all3DRenderWindowWidgets)
   {
     subSplit3D->addWidget(renderWindowWidget.second.get());
     renderWindowWidget.second->show();
     splitterSize.push_back(1000);
   }
   subSplit3D->setSizes(splitterSize);
 
   // set size for main splitter
   splitterSize.clear();
   splitterSize.push_back(600);
   splitterSize.push_back(1000);
   mainSplit->setSizes(splitterSize);
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::ALL_2D_LEFT_3D_RIGHT);
   }
 }
 
 void QmitkMultiWidgetLayoutManager::SetOneBigLayout()
 {
   MITK_INFO << "Set single 2D layout" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   delete m_MultiWidget->layout();
 
   auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   m_MultiWidget->setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   auto mainSplit = new QSplitter(m_MultiWidget);
   hBoxLayout->addWidget(mainSplit);
   mainSplit->addWidget(m_CurrentRenderWindowWidget);
   m_CurrentRenderWindowWidget->show();
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::ONE_BIG);
   }
 }
 
 void QmitkMultiWidgetLayoutManager::SetOnly2DHorizontalLayout()
 {
   MITK_INFO << "Set only 2D layout" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   delete m_MultiWidget->layout();
 
   auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   m_MultiWidget->setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   auto mainSplit = new QSplitter(m_MultiWidget);
   hBoxLayout->addWidget(mainSplit);
 
   QList<int> splitterSize;
   auto all2DRenderWindowWidgets = m_MultiWidget->Get2DRenderWindowWidgets();
   for (const auto& renderWindowWidget : all2DRenderWindowWidgets)
   {
     mainSplit->addWidget(renderWindowWidget.second.get());
     renderWindowWidget.second->show();
     splitterSize.push_back(1000);
   }
   mainSplit->setSizes(splitterSize);
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::ONLY_2D_HORIZONTAL);
   }
 }
 
 void QmitkMultiWidgetLayoutManager::SetOnly2DVerticalLayout()
 {
   MITK_INFO << "Set only 2D layout" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   delete m_MultiWidget->layout();
 
   auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   m_MultiWidget->setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   auto mainSplit = new QSplitter(Qt::Vertical, m_MultiWidget);
   hBoxLayout->addWidget(mainSplit);
 
   QList<int> splitterSize;
   auto all2DRenderWindowWidgets = m_MultiWidget->Get2DRenderWindowWidgets();
   for (const auto& renderWindowWidget : all2DRenderWindowWidgets)
   {
     mainSplit->addWidget(renderWindowWidget.second.get());
     renderWindowWidget.second->show();
     splitterSize.push_back(1000);
   }
   mainSplit->setSizes(splitterSize);
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::ONLY_2D_VERTICAL);
   }
 }
 
 void QmitkMultiWidgetLayoutManager::SetOneTop3DBottomLayout()
 {
   MITK_INFO << "Set one 2D top and 3D bottom layout" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   delete m_MultiWidget->layout();
 
   auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   m_MultiWidget->setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   auto mainSplit = new QSplitter(Qt::Vertical, m_MultiWidget);
   hBoxLayout->addWidget(mainSplit);
 
   mainSplit->addWidget(m_CurrentRenderWindowWidget);
   m_CurrentRenderWindowWidget->show();
 
   auto subSplit3D = new QSplitter(mainSplit);
   QList<int> splitterSize;
   auto all3DRenderWindowWidgets = m_MultiWidget->Get3DRenderWindowWidgets();
   for (const auto& renderWindowWidget : all3DRenderWindowWidgets)
   {
     subSplit3D->addWidget(renderWindowWidget.second.get());
     renderWindowWidget.second->show();
     splitterSize.push_back(1000);
   }
   subSplit3D->setSizes(splitterSize);
 
   // set size for main splitter
   splitterSize.clear();
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   mainSplit->setSizes(splitterSize);
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::ONE_TOP_3D_BOTTOM);
   }
 }
 
 void QmitkMultiWidgetLayoutManager::SetOneLeft3DRightLayout()
 {
   MITK_INFO << "Set one 2D left and 3D right layout" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   delete m_MultiWidget->layout();
 
   auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   m_MultiWidget->setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   auto mainSplit = new QSplitter(m_MultiWidget);
   hBoxLayout->addWidget(mainSplit);
 
   mainSplit->addWidget(m_CurrentRenderWindowWidget);
   m_CurrentRenderWindowWidget->show();
 
   auto subSplit3D = new QSplitter(Qt::Vertical, mainSplit);
   QList<int> splitterSize;
   auto all3DRenderWindowWidgets = m_MultiWidget->Get3DRenderWindowWidgets();
   for (const auto& renderWindowWidget : all3DRenderWindowWidgets)
   {
     subSplit3D->addWidget(renderWindowWidget.second.get());
     renderWindowWidget.second->show();
     splitterSize.push_back(1000);
   }
   subSplit3D->setSizes(splitterSize);
 
   // set size for main splitter
   splitterSize.clear();
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   mainSplit->setSizes(splitterSize);
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::ONE_LEFT_3D_RIGHT);
   }
 }
 
 void QmitkMultiWidgetLayoutManager::SetAllHorizontalLayout()
 {
   MITK_INFO << "Set default layout" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   delete m_MultiWidget->layout();
 
   auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   m_MultiWidget->setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   auto mainSplit = new QSplitter(m_MultiWidget);
   hBoxLayout->addWidget(mainSplit);
 
   QList<int> splitterSize;
   auto allRenderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : allRenderWindowWidgets)
   {
     if (nullptr != renderWindowWidget.second)
     {
       mainSplit->addWidget(renderWindowWidget.second.get());
       renderWindowWidget.second->show();
       splitterSize.push_back(1000);
     }
   }
 
   // set size for main splitter
   mainSplit->setSizes(splitterSize);
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::ALL_HORIZONTAL);
   }
 }
 
 void QmitkMultiWidgetLayoutManager::SetAllVerticalLayout()
 {
   MITK_INFO << "Set all vertical" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   delete m_MultiWidget->layout();
 
   auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
   hBoxLayout->setContentsMargins(0, 0, 0, 0);
   m_MultiWidget->setLayout(hBoxLayout);
   hBoxLayout->setMargin(0);
 
   auto mainSplit = new QSplitter(Qt::Vertical, m_MultiWidget);
   hBoxLayout->addWidget(mainSplit);
 
   QList<int> splitterSize;
   auto allRenderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : allRenderWindowWidgets)
   {
     mainSplit->addWidget(renderWindowWidget.second.get());
     renderWindowWidget.second->show();
     splitterSize.push_back(1000);
   }
 
   // set size for splitter
   mainSplit->setSizes(splitterSize);
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::ALL_VERTICAL);
   }
 }
 
 void QmitkMultiWidgetLayoutManager::RemoveOneLayout()
 {
   MITK_INFO << "Remove single render window" << std::endl;
 
   m_MultiWidget->ActivateMenuWidget(false);
 
   m_CurrentRenderWindowWidget->hide();
 
   m_MultiWidget->ActivateMenuWidget(true);
 
   auto allRenderWindows = m_MultiWidget->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     renderWindow->LayoutDesignListChanged(LayoutDesign::NONE);
   }
 }
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index 01b70b8eb5..6c4c5dc73f 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,256 +1,256 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkMxNMultiWidget.h"
 #include "QmitkRenderWindowWidget.h"
 
 // qt
 #include <QGridLayout>
 
 QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          mitk::RenderingManager* renderingManager/* = nullptr*/,
                                          mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/,
                                          const QString& multiWidgetName/* = "mxnmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, renderingManager, renderingMode, multiWidgetName)
   , m_CrosshairVisibility(false)
 {
   // nothing here
 }
 
 void QmitkMxNMultiWidget::InitializeMultiWidget()
 {
   SetLayout(1, 1);
 
   ActivateMenuWidget(true);
 }
 
 void QmitkMxNMultiWidget::MultiWidgetOpened()
 {
   SetCrosshairVisibility(true);
 }
 
 void QmitkMxNMultiWidget::MultiWidgetClosed()
 {
   SetCrosshairVisibility(false);
 }
 
 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));
 
   }
 
   // set the new decoration color of the currently active render window widget
   if (nullptr != activeRenderWindowWidget)
   {
     activeRenderWindowWidget->setStyleSheet("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;
   }
 
   auto renderingManager = GetRenderingManager();
   if (nullptr == renderingManager)
   {
     return;
   }
 
   renderingManager->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()->OnLayoutDesignChanged(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
+  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(), GetRenderingManager());
   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::OnLayoutDesignChanged);
+  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/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index 42ec2824b4..87ca55e6bb 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,808 +1,808 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #define SMW_INFO MITK_INFO("widget.stdmulti")
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkCameraController.h>
 #include <mitkImage.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkInteractionConst.h>
 #include <mitkLine.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkPlaneGeometryDataMapper2D.h>
 #include <mitkPointSet.h>
 #include <mitkProperties.h>
 #include <mitkStatusBar.h>
 #include <mitkVtkLayerController.h>
 
 // qt
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 
 // vtk
 #include <vtkSmartPointer.h>
 
 // c++
 #include <iomanip>
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          mitk::RenderingManager *renderingManager/* = nullptr*/,
                                          mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/,
                                          const QString &name/* = "stdmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, renderingManager, renderingMode, name)
   , m_TimeNavigationController(nullptr)
   , m_PendingCrosshairPositionEvent(false)
 {
   m_TimeNavigationController = GetRenderingManager()->GetTimeNavigationController();
 }
 
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   m_TimeNavigationController->Disconnect(GetRenderWindow1()->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(GetRenderWindow2()->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(GetRenderWindow3()->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(GetRenderWindow4()->GetSliceNavigationController());
 }
 
 void QmitkStdMultiWidget::InitializeMultiWidget()
 {
   // yellow is default color for widget4
   m_DecorationColorWidget4[0] = 1.0f;
   m_DecorationColorWidget4[1] = 1.0f;
   m_DecorationColorWidget4[2] = 0.0f;
 
   SetLayout(2, 2);
 
   // transfer colors in WorldGeometry-Nodes of the associated Renderer
   mitk::IntProperty::Pointer layer;
   // of widget 1
   m_PlaneNode1 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow1()->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetColor(GetDecorationColor(0));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode1->SetProperty("layer", layer);
 
   // of widget 2
   m_PlaneNode2 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow2()->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetColor(GetDecorationColor(1));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode2->SetProperty("layer", layer);
 
   // of widget 3
   m_PlaneNode3 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow3()->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetColor(GetDecorationColor(2));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode3->SetProperty("layer", layer);
 
   // the parent node
   m_ParentNodeForGeometryPlanes =
     mitk::BaseRenderer::GetInstance(GetRenderWindow4()->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   layer = mitk::IntProperty::New(1000);
   m_ParentNodeForGeometryPlanes->SetProperty("layer", layer);
 
   AddDisplayPlaneSubTree();
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   if ("axial" == widgetName)
   {
     return GetRenderWindow1();
   }
 
   if ("sagittal" == widgetName)
   {
     return GetRenderWindow2();
   }
 
   if ("coronal" == widgetName)
   {
     return GetRenderWindow3();
   }
 
   if ("3d" == widgetName)
   {
     return GetRenderWindow4();
   }
 
 
   return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const
 {
   return GetRenderWindow(static_cast<unsigned int>(viewDirection));
 }
 
 void QmitkStdMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& /*widgetName*/)
 {
   GetRenderWindow1()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   GetRenderWindow2()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   GetRenderWindow3()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
 
   RequestUpdateAll();
 }
 
 const mitk::Point3D QmitkStdMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
 {
   const mitk::PlaneGeometry* plane1 = GetRenderWindow1()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry* plane2 = GetRenderWindow2()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry* plane3 = GetRenderWindow3()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ((plane1 != nullptr) && (plane2 != nullptr)
    && (plane1->IntersectionLine(plane2, line)))
   {
     mitk::Point3D point;
     if ((plane3 != nullptr) && (plane3->IntersectionPoint(line, point)))
     {
       return point;
     }
   }
 
   return mitk::Point3D();
 }
 
 void QmitkStdMultiWidget::SetCrosshairVisibility(bool visible)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible);
   }
 
   RequestUpdateAll();
 }
 
 bool QmitkStdMultiWidget::GetCrosshairVisibility() const
 {
   bool crosshairVisibility = true;
 
   if (m_PlaneNode1.IsNotNull())
   {
     bool visibilityProperty = false;
     m_PlaneNode1->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   if (m_PlaneNode2.IsNotNull())
   {
     bool visibilityProperty = false;
     crosshairVisibility &= m_PlaneNode2->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   if (m_PlaneNode3.IsNotNull())
   {
     bool visibilityProperty = false;
     crosshairVisibility &= m_PlaneNode3->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   return crosshairVisibility;
 }
 
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   GetRenderingManager()->InitializeViewsByBoundingObjects(dataStorage);
 
   SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   switch (userMode)
   {
   case 0:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKStandard);
     break;
   case 1:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationUncoupled);
     break;
   case 2:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationCoupled);
     break;
   case 3:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKSwivel);
     break;
   }
 }
 
 mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 void QmitkStdMultiWidget::AddPlanesToDataStorage()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
    && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     dataStorage->Add(m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
   }
 }
 
 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
    && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     dataStorage->Remove(m_PlaneNode1);
     dataStorage->Remove(m_PlaneNode2);
     dataStorage->Remove(m_PlaneNode3);
     dataStorage->Remove(m_ParentNodeForGeometryPlanes);
   }
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
 {
   if (!m_PendingCrosshairPositionEvent)
   {
     m_PendingCrosshairPositionEvent = true;
     QTimer::singleShot(0, this, SLOT(HandleCrosshairPositionEventDelayed()));
   }
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(unsigned int number) const
 {
   switch (number)
   {
   case 0:
     return GetRenderWindow1();
   case 1:
     return GetRenderWindow2();
   case 2:
     return GetRenderWindow3();
   case 3:
     return GetRenderWindow4();
   default:
     MITK_ERROR << "Requested unknown render window";
     break;
   }
 
   return nullptr;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 0));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 1));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 0));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 1));
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1() const
 {
   return m_PlaneNode1;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2() const
 {
   return m_PlaneNode2;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3() const
 {
   return m_PlaneNode3;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(unsigned number) const
 {
   switch (number)
   {
   case 1:
     return m_PlaneNode1;
   case 2:
     return m_PlaneNode2;
   case 3:
     return m_PlaneNode3;
   default:
     MITK_ERROR << "Requested unknown render window";
     break;
   }
 
   return nullptr;
 }
 
 void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
 {
   switch (widgetNumber)
   {
   case 0:
     if (m_PlaneNode1.IsNotNull())
     {
       m_PlaneNode1->SetColor(color);
     }
     break;
   case 1:
     if (m_PlaneNode2.IsNotNull())
     {
       m_PlaneNode2->SetColor(color);
     }
     break;
   case 2:
     if (m_PlaneNode3.IsNotNull())
     {
       m_PlaneNode3->SetColor(color);
     }
     break;
   case 3:
     m_DecorationColorWidget4 = color;
     break;
   default:
     MITK_ERROR << "Decoration color for unknown widget!";
     break;
   }
 }
 
 mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber)
 {
   // The implementation looks a bit messy here, but it avoids
   // synchronization of the color of the geometry nodes and an
   // internal member here.
   // Default colors were chosen for decent visibility.
   // Feel free to change your preferences in the workbench.
   float tmp[3] = { 0.0f, 0.0f, 0.0f };
   switch (widgetNumber)
   {
   case 0:
   {
     if (m_PlaneNode1.IsNotNull())
     {
       if (m_PlaneNode1->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode1->GetProperty("color"))->GetColor();
       }
     }
     float red[3] = { 0.753f, 0.0f, 0.0f }; // This is #C00000 in hex
     return mitk::Color(red);
   }
   case 1:
   {
     if (m_PlaneNode2.IsNotNull())
     {
       if (m_PlaneNode2->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode2->GetProperty("color"))->GetColor();
       }
     }
     float green[3] = { 0.0f, 0.69f, 0.0f }; // This is #00B000 in hex
     return mitk::Color(green);
   }
   case 2:
   {
     if (m_PlaneNode3.IsNotNull())
     {
       if (m_PlaneNode3->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode3->GetProperty("color"))->GetColor();
       }
     }
     float blue[3] = { 0.0, 0.502f, 1.0f }; // This is #0080FF in hex
     return mitk::Color(blue);
   }
   case 3:
   {
     return m_DecorationColorWidget4;
   }
   default:
     MITK_ERROR << "Decoration color for unknown widget!";
     float black[3] = { 0.0f, 0.0f, 0.0f };
     return mitk::Color(black);
   }
 }
 
 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent* 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 QmitkStdMultiWidget::moveEvent(QMoveEvent* e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the Annotation as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 void QmitkStdMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   m_PendingCrosshairPositionEvent = false;
 
   // find image with highest layer
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = dataStorage->GetSubset(isImageData).GetPointer();
   mitk::Point3D crosshairPos = GetSelectedPosition("");
   mitk::BaseRenderer* baseRenderer = GetRenderWindow1()->GetSliceNavigationController()->GetRenderer();
   auto globalCurrentTimePoint = baseRenderer->GetTime();
   mitk::DataNode::Pointer node = mitk::FindTopmostVisibleNode(nodes, crosshairPos, globalCurrentTimePoint, baseRenderer);
 
   mitk::DataNode::Pointer topSourceNode;
   mitk::Image::Pointer image;
   bool isBinary = false;
   int component = 0;
 
   if (node.IsNotNull())
   {
     node->GetBoolProperty("binary", isBinary);
     if (isBinary)
     {
       mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = dataStorage->GetSources(node, nullptr, true);
       if (!sourcenodes->empty())
       {
         topSourceNode = mitk::FindTopmostVisibleNode(sourcenodes, crosshairPos, globalCurrentTimePoint, baseRenderer);
       }
       if (topSourceNode.IsNotNull())
       {
         image = dynamic_cast<mitk::Image *>(topSourceNode->GetData());
         topSourceNode->GetIntProperty("Image.Displayed Component", component);
       }
       else
       {
         image = dynamic_cast<mitk::Image *>(node->GetData());
         node->GetIntProperty("Image.Displayed Component", component);
       }
     }
     else
     {
       image = dynamic_cast<mitk::Image *>(node->GetData());
       node->GetIntProperty("Image.Displayed Component", component);
     }
   }
 
   std::string statusText;
   std::stringstream stream;
   itk::Index<3> p;
   unsigned int timestep = baseRenderer->GetTimeStep();
 
   if (image.IsNotNull() && (image->GetTimeSteps() > timestep))
   {
     image->GetGeometry()->WorldToIndex(crosshairPos, p);
     stream.precision(2);
     stream << "Position: <" << std::fixed << crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", "
       << std::fixed << crosshairPos[2] << "> mm";
     stream << "; Index: <" << p[0] << ", " << p[1] << ", " << p[2] << "> ";
 
     mitk::ScalarType pixelValue;
 
     mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess,
       image->GetChannelDescriptor().GetPixelType(),
       image,
       image->GetVolumeData(image->GetTimeGeometry()->TimePointToTimeStep(globalCurrentTimePoint)),
       p,
       pixelValue,
       component);
 
     if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
     {
       stream << "; Time: " << globalCurrentTimePoint << " ms; Pixelvalue: " << std::scientific << pixelValue << "  ";
     }
     else
     {
       stream << "; Time: " << globalCurrentTimePoint << " ms; Pixelvalue: " << pixelValue << "  ";
     }
   }
   else
   {
     stream << "No image information at this position!";
   }
 
   statusText = stream.str();
   mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
 }
 
 void QmitkStdMultiWidget::Fit()
 {
   vtkSmartPointer<vtkRenderer> vtkrenderer;
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->GetRenderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->GetRenderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->GetRenderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow4()->GetRenderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   mitk::BaseRenderer::GetInstance(GetRenderWindow1()->GetRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow2()->GetRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow3()->GetRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow4()->GetRenderWindow())->GetCameraController()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
 {
   // add the displayed planes of the multiwidget to a node to which the subtree
   // @a planesSubTree points ...
 
   mitk::PlaneGeometryDataMapper2D::Pointer mapper;
 
   // ... of widget 1
   mitk::BaseRenderer* renderer1 = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->GetRenderWindow());
   m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane"));
   m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   mitk::BaseRenderer* renderer2 = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->GetRenderWindow());
   m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane"));
   m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->GetRenderWindow());
   m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane"));
   m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   m_ParentNodeForGeometryPlanes = mitk::DataNode::New();
   m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets"));
   m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true));
 }
 
 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
 {
   mitk::Point2D pointOnDisplay;
   renderer->WorldToDisplay(p, pointOnDisplay);
 
   if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] ||
     pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] ||
     pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] ||
     pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1])
   {
     mitk::Point2D pointOnPlane;
     renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane);
     renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane);
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
 {
   auto dataStorage = GetDataStorage();
   if (nullptr != dataStorage)
   {
     mitk::DataNode* dataNode = dataStorage->GetNamedNode(widgetName);
     if (dataNode != nullptr)
     {
       dataNode->SetVisibility(visible, renderer);
     }
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible, renderer);
   }
   GetRenderingManager()->RequestUpdateAll();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkStdMultiWidget::SetLayoutImpl()
 {
   CreateRenderWindowWidgets();
-  GetMultiWidgetLayoutManager()->OnLayoutDesignChanged(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
+  GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
 
   // Initialize views as axial, sagittal, coronal to all data objects in DataStorage
   auto geo = GetDataStorage()->ComputeBoundingGeometry3D(GetDataStorage()->GetAll());
   GetRenderingManager()->InitializeViews(geo);
 }
 
 void QmitkStdMultiWidget::CreateRenderWindowWidgets()
 {
   // create axial render window (widget)
   QString renderWindowWidgetName = GetNameFromIndex(0, 0);
   RenderWindowWidgetPointer renderWindowWidget1 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
   auto renderWindow1 = renderWindowWidget1->GetRenderWindow();
   renderWindow1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
   renderWindowWidget1->SetDecorationColor(GetDecorationColor(0));
   renderWindowWidget1->SetCornerAnnotationText("Axial");
   renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(ViewDirection::AXIAL);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget1);
 
   // create sagittal render window (widget)
   renderWindowWidgetName = GetNameFromIndex(0, 1);
   RenderWindowWidgetPointer renderWindowWidget2 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
   auto renderWindow2 = renderWindowWidget2->GetRenderWindow();
   renderWindow2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
   renderWindowWidget2->SetDecorationColor(GetDecorationColor(1));
   renderWindowWidget2->setStyleSheet("border: 0px");
   renderWindowWidget2->SetCornerAnnotationText("Sagittal");
   renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(ViewDirection::SAGITTAL);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget2);
 
   // create coronal render window (widget)
   renderWindowWidgetName = GetNameFromIndex(1, 0);
   RenderWindowWidgetPointer renderWindowWidget3 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
   auto renderWindow3 = renderWindowWidget3->GetRenderWindow();
   renderWindow3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
   renderWindowWidget3->SetDecorationColor(GetDecorationColor(2));
   renderWindowWidget3->SetCornerAnnotationText("Coronal");
   renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(ViewDirection::CORONAL);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget3);
 
   // create 3D render window (widget)
   renderWindowWidgetName = GetNameFromIndex(1, 1);
   RenderWindowWidgetPointer renderWindowWidget4 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
   auto renderWindow4 = renderWindowWidget4->GetRenderWindow();
   renderWindow4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
   renderWindowWidget4->SetDecorationColor(GetDecorationColor(3));
   renderWindowWidget4->SetCornerAnnotationText("3D");
   renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(ViewDirection::THREE_D);
   mitk::BaseRenderer::GetInstance(renderWindowWidget4->GetRenderWindow()->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget4);
 
   SetActiveRenderWindowWidget(renderWindowWidget1);
 
   // connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow1->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow2->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow3->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow4->GetSliceNavigationController(), false);
   renderWindow1->GetSliceNavigationController()->ConnectGeometrySendEvent(
     mitk::BaseRenderer::GetInstance(renderWindow4->GetRenderWindow()));
 
   // reverse connection between sliceNavigationControllers and timeNavigationController
   renderWindow1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   renderWindow2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   renderWindow3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   //renderWindow4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
 
   auto layoutManager = GetMultiWidgetLayoutManager();
   connect(renderWindowWidget1.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
   connect(renderWindow1, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow1, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow1, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
-  connect(renderWindow1, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged);
+  connect(renderWindow1, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
 
   connect(renderWindowWidget2.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
   connect(renderWindow2, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow2, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow2, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
-  connect(renderWindow2, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged);
+  connect(renderWindow2, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
 
   connect(renderWindowWidget3.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
   connect(renderWindow3, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow3, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow3, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
-  connect(renderWindow3, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged);
+  connect(renderWindow3, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
 
   connect(renderWindowWidget4.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
   connect(renderWindow4, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow4, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow4, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
-  connect(renderWindow4, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged);
+  connect(renderWindow4, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
 }