diff --git a/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h b/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h
index fd0d48212e..6f55e7e4ad 100644
--- a/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h
+++ b/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h
@@ -1,69 +1,70 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKMULTIWIDGETCONFIGURATIONTOOLBAR_H
 #define QMITKMULTIWIDGETCONFIGURATIONTOOLBAR_H
 
 #include "MitkQtWidgetsExports.h"
 
 #include <mitkInteractionSchemeSwitcher.h>
 
+#include <nlohmann/json.hpp>
+
 // qt
 #include <QToolBar>
 
 class QmitkAbstractMultiWidget;
 class QmitkMultiWidgetLayoutSelectionWidget;
 
 /**
 * @brief
 *
 *
 */
 class MITKQTWIDGETS_EXPORT QmitkMultiWidgetConfigurationToolBar : public QToolBar
 {
   Q_OBJECT
 
 public:
 
   QmitkMultiWidgetConfigurationToolBar(QmitkAbstractMultiWidget* multiWidget);
   ~QmitkMultiWidgetConfigurationToolBar() override;
 
 Q_SIGNALS:
 
   void LayoutSet(int row, int column);
-  void CustomLayoutLoad(std::string filename);
-  void PresetLayoutLoad(std::string filename);
   void SaveLayout(std::string filename);
+  void LoadLayout(const nlohmann::json * jsonData);
   void Synchronized(bool synchronized);
   void InteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
 
 protected Q_SLOTS:
 
   void OnSetLayout();
   void OnSynchronize();
   void OnInteractionSchemeChanged();
 
 private:
 
   void InitializeToolBar();;
   void AddButtons();
 
   QmitkAbstractMultiWidget* m_MultiWidget;
 
   QAction* m_SynchronizeAction;
   QAction* m_InteractionSchemeChangeAction;
 
   QmitkMultiWidgetLayoutSelectionWidget* m_LayoutSelectionPopup;
 
 };
 
 #endif // QMITKMULTIWIDGETCONFIGURATIONTOOLBAR_H
diff --git a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
index f02418f538..a25000d7bb 100644
--- a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
+++ b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
@@ -1,61 +1,62 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKMULTIWIDGETLAYOUTSELECTIONWIDGET_H
 #define QMITKMULTIWIDGETLAYOUTSELECTIONWIDGET_H
 
 #include "MitkQtWidgetsExports.h"
 
 #include "ui_QmitkMultiWidgetLayoutSelectionWidget.h"
 
+#include <nlohmann/json.hpp>
+
 // qt
 #include "QWidget"
 
 /**
 * @brief
 *
 *
 */
 class MITKQTWIDGETS_EXPORT QmitkMultiWidgetLayoutSelectionWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkMultiWidgetLayoutSelectionWidget(QWidget* parent = nullptr);
 
 Q_SIGNALS:
 
   void LayoutSet(int row, int column);
   void SaveLayout(std::string filename);
-  void CustomLayoutLoad(std::string filename);
-  void PresetLayoutLoad(std::string filename);
+  void LoadLayout(const nlohmann::json* jsonData);
 
 private Q_SLOTS:
 
   void OnTableItemSelectionChanged();
   void OnSetLayoutButtonClicked();
   void OnSaveLayoutButtonClicked();
   void OnLoadLayoutButtonClicked();
   void OnLayoutPresetSelected(int index);
 
 private:
 
   void Init();
 
 
   Ui::QmitkMultiWidgetLayoutSelectionWidget ui;
-  std::map<int, std::string> m_PresetNameMap;
+  std::map<int, nlohmann::json> m_PresetMap;
 
 };
 
 #endif // QMITKMULTIWIDGETLAYOUTSELECTIONWIDGET_H
diff --git a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
index f96c90597f..1dd5f59398 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,119 +1,117 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKMXNMULTIWIDGET_H
 #define QMITKMXNMULTIWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkAbstractMultiWidget.h"
 
 #include <nlohmann/json.hpp>
 
 class QSplitter;
 
 /**
 * @brief The 'QmitkMxNMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
 *        Render windows can dynamically be added and removed to change the layout of the multi widget. This
 *        is done by using the 'SetLayout'-function to define a layout. This will automatically add or remove
 *        the appropriate number of render window widgets.
 */
 class MITKQTWIDGETS_EXPORT QmitkMxNMultiWidget : public QmitkAbstractMultiWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkMxNMultiWidget(QWidget* parent = nullptr,
                       Qt::WindowFlags f = 0,
                       const QString& multiWidgetName = "mxnmulti");
 
   ~QmitkMxNMultiWidget();
 
   void InitializeMultiWidget() override;
 
   void Synchronize(bool synchronized) override;
 
   QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
   QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
 
   void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget) override;
   /**
    * @brief Set the reference geometry for interaction inside the active render windows of the MxNMultiWidget.
    *
    * @param referenceGeometry   The reference geometry which is used for updating the
    *                            time geometry inside the active render window.
    * @param resetCamera         If true, the camera and crosshair will be reset to the default view (centered, no zoom).
    *                            If false, the current crosshair position and the camera zoom will be stored and reset
    *                            after the reference geometry has been updated.
    */
   void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) override;
 
   /**
   * @brief Returns true if the render windows are coupled; false if not.
   *
   * For the MxNMultiWidget the render windows are typically decoupled.
   */
   bool HasCoupledRenderWindows() const override;
 
   void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
   const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
 
   void SetCrosshairVisibility(bool visible) override;
   bool GetCrosshairVisibility() const override;
   void SetCrosshairGap(unsigned int gapSize) override;
 
   void ResetCrosshair() override;
 
   void SetWidgetPlaneMode(int userMode) override;
 
   mitk::SliceNavigationController* GetTimeNavigationController();
 
   void AddPlanesToDataStorage();
   void RemovePlanesFromDataStorage();
 
 public Q_SLOTS:
 
   // mouse events
   void wheelEvent(QWheelEvent* e) override;
   void mousePressEvent(QMouseEvent* e) override;
   void moveEvent(QMoveEvent* e) override;
-  void LoadCustomLayout(std::string filename);
-  void LoadPresetLayout(std::string filename);
-  void LoadLayout(nlohmann::json data);
+  void LoadLayout(const nlohmann::json* jsonData);
   void SaveLayout(std::string filename);
 
 Q_SIGNALS:
 
   void WheelMoved(QWheelEvent *);
   void Moved();
 
 protected:
 
   void RemoveRenderWindowWidget() override;
 
 private:
 
   void SetLayoutImpl() override;
   void SetInteractionSchemeImpl() override { }
 
   void CreateRenderWindowWidget();
   nlohmann::json BuildJSONFromLayout(QSplitter* splitter);
-  QSplitter* BuildLayoutFromJSON(nlohmann::json jsonData, unsigned int* windowCounter, QSplitter* parentSplitter = nullptr);
+  QSplitter* BuildLayoutFromJSON(const nlohmann::json* jsonData, unsigned int* windowCounter, QSplitter* parentSplitter = nullptr);
 
   mitk::SliceNavigationController* m_TimeNavigationController;
 
   bool m_CrosshairVisibility;
 
 };
 
 #endif // QMITKMXNMULTIWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp b/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
index 155d00bb83..1987f7653f 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
@@ -1,112 +1,111 @@
 /*============================================================================
 
 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 "QmitkMultiWidgetConfigurationToolBar.h"
 
 // mitk qt widgets module
 #include "QmitkAbstractMultiWidget.h"
 #include "QmitkMultiWidgetLayoutSelectionWidget.h"
 
 QmitkMultiWidgetConfigurationToolBar::QmitkMultiWidgetConfigurationToolBar(QmitkAbstractMultiWidget* multiWidget)
   : QToolBar(multiWidget)
   , m_MultiWidget(multiWidget)
 {
   QToolBar::setOrientation(Qt::Vertical);
   QToolBar::setIconSize(QSize(17, 17));
 
   InitializeToolBar();
 }
 
 QmitkMultiWidgetConfigurationToolBar::~QmitkMultiWidgetConfigurationToolBar()
 {
   // nothing here
 }
 
 void QmitkMultiWidgetConfigurationToolBar::InitializeToolBar()
 {
   // create popup to show a widget to modify the multi widget layout
   m_LayoutSelectionPopup = new QmitkMultiWidgetLayoutSelectionWidget(this);
   m_LayoutSelectionPopup->hide();
 
   AddButtons();
 
   connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::LayoutSet, this, &QmitkMultiWidgetConfigurationToolBar::LayoutSet);
   connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::SaveLayout, this, &QmitkMultiWidgetConfigurationToolBar::SaveLayout);
-  connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::CustomLayoutLoad, this, &QmitkMultiWidgetConfigurationToolBar::CustomLayoutLoad);
-  connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::PresetLayoutLoad, this, &QmitkMultiWidgetConfigurationToolBar::PresetLayoutLoad);
+  connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::LoadLayout, this, &QmitkMultiWidgetConfigurationToolBar::LoadLayout);
 }
 
 void QmitkMultiWidgetConfigurationToolBar::AddButtons()
 {
   QAction* setLayoutAction = new QAction(QIcon(":/Qmitk/mwLayout.png"), tr("Set multi widget layout"), this);
   connect(setLayoutAction, &QAction::triggered, this, &QmitkMultiWidgetConfigurationToolBar::OnSetLayout);
   QToolBar::addAction(setLayoutAction);
 
   m_SynchronizeAction = new QAction(QIcon(":/Qmitk/mwDesynchronized.png"), tr("Synchronize render windows"), this);
   m_SynchronizeAction->setCheckable(true);
   m_SynchronizeAction->setChecked(false);
   connect(m_SynchronizeAction, &QAction::triggered, this, &QmitkMultiWidgetConfigurationToolBar::OnSynchronize);
   QToolBar::addAction(m_SynchronizeAction);
 
   m_InteractionSchemeChangeAction = new QAction(QIcon(":/Qmitk/mwMITK.png"), tr("Change to PACS interaction"), this);
   m_InteractionSchemeChangeAction->setCheckable(true);
   m_InteractionSchemeChangeAction->setChecked(false);
   connect(m_InteractionSchemeChangeAction, &QAction::triggered, this, &QmitkMultiWidgetConfigurationToolBar::OnInteractionSchemeChanged);
   QToolBar::addAction(m_InteractionSchemeChangeAction);
 }
 
 void QmitkMultiWidgetConfigurationToolBar::OnSetLayout()
 {
   if (nullptr != m_MultiWidget)
   {
     m_LayoutSelectionPopup->setWindowFlags(Qt::Popup);
     m_LayoutSelectionPopup->move(this->cursor().pos().x() - m_LayoutSelectionPopup->width(), this->cursor().pos().y());
     m_LayoutSelectionPopup->show();
   }
 }
 
 void QmitkMultiWidgetConfigurationToolBar::OnSynchronize()
 {
   bool synchronized = m_SynchronizeAction->isChecked();
   if (synchronized)
   {
     m_SynchronizeAction->setIcon(QIcon(":/Qmitk/mwSynchronized.png"));
     m_SynchronizeAction->setText(tr("Desynchronize render windows"));
   }
   else
   {
     m_SynchronizeAction->setIcon(QIcon(":/Qmitk/mwDesynchronized.png"));
     m_SynchronizeAction->setText(tr("Synchronize render windows"));
   }
 
   m_SynchronizeAction->setChecked(synchronized);
   emit Synchronized(synchronized);
 }
 
 void QmitkMultiWidgetConfigurationToolBar::OnInteractionSchemeChanged()
 {
   bool PACSInteractionScheme = m_InteractionSchemeChangeAction->isChecked();
   if (PACSInteractionScheme)
   {
     m_InteractionSchemeChangeAction->setIcon(QIcon(":/Qmitk/mwPACS.png"));
     m_InteractionSchemeChangeAction->setText(tr("Change to MITK interaction"));
     emit InteractionSchemeChanged(mitk::InteractionSchemeSwitcher::PACSStandard);
   }
   else
   {
     m_InteractionSchemeChangeAction->setIcon(QIcon(":/Qmitk/mwMITK.png"));
     m_InteractionSchemeChangeAction->setText(tr("Change to PACS interaction"));
     emit InteractionSchemeChanged(mitk::InteractionSchemeSwitcher::MITKStandard);
   }
 
   m_InteractionSchemeChangeAction->setChecked(PACSInteractionScheme);
 }
diff --git a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
index 659c6121ae..58f11714ad 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
@@ -1,129 +1,129 @@
 /*============================================================================
 
 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 "QmitkMultiWidgetLayoutSelectionWidget.h"
 
 #include <QFileDialog>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
-#include <nlohmann/json.hpp>
-
 QmitkMultiWidgetLayoutSelectionWidget::QmitkMultiWidgetLayoutSelectionWidget(QWidget* parent/* = 0*/)
   : QWidget(parent)
 {
   Init();
 }
 
 void QmitkMultiWidgetLayoutSelectionWidget::Init()
 {
   ui.setupUi(this);
 
   auto stylesheet = "QTableWidget::item{background-color: white;}\nQTableWidget::item:selected{background-color: #1C97EA;}";
   ui.tableWidget->setStyleSheet(stylesheet);
 
   connect(ui.tableWidget, &QTableWidget::itemSelectionChanged, this, &QmitkMultiWidgetLayoutSelectionWidget::OnTableItemSelectionChanged);
   connect(ui.setLayoutPushButton, &QPushButton::clicked, this, &QmitkMultiWidgetLayoutSelectionWidget::OnSetLayoutButtonClicked);
   connect(ui.loadLayoutPushButton, &QPushButton::clicked, this, &QmitkMultiWidgetLayoutSelectionWidget::OnLoadLayoutButtonClicked);
   connect(ui.saveLayoutPushButton, &QPushButton::clicked, this, &QmitkMultiWidgetLayoutSelectionWidget::OnSaveLayoutButtonClicked);
   connect(ui.selectDefaultLayoutComboBox, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &QmitkMultiWidgetLayoutSelectionWidget::OnLayoutPresetSelected);
 
   ui.selectDefaultLayoutComboBox->addItem("Select a layout preset");
   auto presetResources = us::GetModuleContext()->GetModule()->FindResources("/", "*.json", false);
   for (const auto& resource : presetResources)
   {
     us::ModuleResourceStream jsonStream(resource);
     auto data = nlohmann::json::parse(jsonStream);
     auto resourceName = data["name"].get<std::string>();
     ui.selectDefaultLayoutComboBox->addItem(QString::fromStdString(resourceName));
-    m_PresetNameMap[ui.selectDefaultLayoutComboBox->count() - 1] = resource.GetResourcePath();
+    m_PresetMap[ui.selectDefaultLayoutComboBox->count() - 1] = data;
   }
 }
 
 void QmitkMultiWidgetLayoutSelectionWidget::OnTableItemSelectionChanged()
 {
   QItemSelectionModel* selectionModel = ui.tableWidget->selectionModel();
 
   int row = 0;
   int column = 0;
   QModelIndexList indices = selectionModel->selectedIndexes();
   if (indices.size() > 0)
   {
     row = indices[0].row();
     column = indices[0].column();
 
     QModelIndex topLeft = ui.tableWidget->model()->index(0, 0, QModelIndex());
     QModelIndex bottomRight = ui.tableWidget->model()->index(row, column, QModelIndex());
 
     QItemSelection cellSelection;
     cellSelection.select(topLeft, bottomRight);
     selectionModel->select(cellSelection, QItemSelectionModel::Select);
   }
 }
 
 void QmitkMultiWidgetLayoutSelectionWidget::OnSetLayoutButtonClicked()
 {
   int row = 0;
   int column = 0;
   QModelIndexList indices = ui.tableWidget->selectionModel()->selectedIndexes();
   if (indices.size() > 0)
   {
     // find largest row and column
     for (const auto& modelIndex : qAsConst(indices))
     {
       if (modelIndex.row() > row)
       {
         row = modelIndex.row();
       }
       if (modelIndex.column() > column)
       {
         column = modelIndex.column();
       }
     }
 
     close();
     emit LayoutSet(row+1, column+1);
   }
 }
 
 void QmitkMultiWidgetLayoutSelectionWidget::OnSaveLayoutButtonClicked()
 {
   QString filename = QFileDialog::getSaveFileName(nullptr, "Select where to save the current layout", "", "MITK Window Layout (*.json)");
   if (filename.isEmpty())
     return;
 
   emit SaveLayout(filename.toStdString());
 }
 
 void QmitkMultiWidgetLayoutSelectionWidget::OnLoadLayoutButtonClicked()
 {
   QString filename = QFileDialog::getOpenFileName(nullptr, "Load a layout file", "", "MITK Window Layouts (*.json)");
   if (filename.isEmpty())
     return;
 
-  emit CustomLayoutLoad(filename.toStdString());
+  std::ifstream f(filename.toStdString());
+  auto jsonData = nlohmann::json::parse(f);
+  emit LoadLayout(&jsonData);
 }
 
 void QmitkMultiWidgetLayoutSelectionWidget::OnLayoutPresetSelected(int index)
 {
   if (index == 0)
   {
     // First entry is only for description
     return;
   }
 
-  std::string filename = m_PresetNameMap[index];
-  emit PresetLayoutLoad(filename);
+  auto jsonData = m_PresetMap[index];
+  emit LoadLayout(&jsonData);
 }
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index 3da7e338a8..729a305dba 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,563 +1,534 @@
 /*============================================================================
 
 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>
 #include <QMessageBox>
 #include <QSplitter>
 
-#include <usGetModuleContext.h>
-#include <usModuleContext.h>
-#include <usModuleResource.h>
-#include <usModuleResourceStream.h>
-
 #include <fstream>
 
 QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          const QString& multiWidgetName/* = "mxnmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, multiWidgetName)
   , m_TimeNavigationController(nullptr)
   , 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();
   }
 }
 
 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::SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, 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 (referenceGeometry->IsValidTimePoint(currentTimePoint))
     {
       imageTimeStep = referenceGeometry->TimePointToTimeStep(currentTimePoint);
     }
   }
 
   // initialize active render window
   renderingManager->InitializeView(
     this->GetActiveRenderWindowWidget()->GetRenderWindow()->GetVtkRenderWindow(), referenceGeometry, resetCamera);
 
   if (!resetCamera)
   {
     this->SetSelectedPosition(currentPosition, "");
     renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
   }
 }
 
 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::AddPlanesToDataStorage()
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->AddPlanesToDataStorage();
   }
 }
 
 void QmitkMxNMultiWidget::RemovePlanesFromDataStorage()
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->RemovePlanesFromDataStorage();
   }
 }
 
 //////////////////////////////////////////////////////////////////////////
 // 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);
 }
 
 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(), true);
   renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
   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);
 
   // connect time navigation controller to react on geometry 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);
 }
 
-void QmitkMxNMultiWidget::LoadCustomLayout(std::string filename)
-{
-  if (filename.empty())
-  {
-    return;
-  }
-
-  std::ifstream f(filename);
-  auto data = nlohmann::json::parse(f);
-  LoadLayout(data);
-}
-
-void QmitkMxNMultiWidget::LoadPresetLayout(std::string filename)
+void QmitkMxNMultiWidget::LoadLayout(const nlohmann::json* jsonData)
 {
-  auto jsonResource = us::GetModuleContext()->GetModule()->GetResource(filename);
-  if (!jsonResource.IsValid() || !jsonResource.IsFile())
-  {
-    return;
-  }
-
-  us::ModuleResourceStream jsonStream(jsonResource);
-  auto data = nlohmann::json::parse(jsonStream);
-  LoadLayout(data);
-}
-
-void QmitkMxNMultiWidget::LoadLayout(nlohmann::json data)
-{
-  if (data.is_null())
+  if ((*jsonData).is_null())
   {
     QMessageBox::warning(this, "Load layout", "Could not read window layout");
   }
 
   delete this->layout();
   unsigned int windowCounter = 0;
-  auto content = BuildLayoutFromJSON(data, &windowCounter);
+  auto content = BuildLayoutFromJSON(jsonData, &windowCounter);
   auto hBoxLayout = new QHBoxLayout(this);
   this->setLayout(hBoxLayout);
   hBoxLayout->addWidget(content);
 
   while (GetNumberOfRenderWindowWidgets() > windowCounter)
   {
     RemoveRenderWindowWidget();
   }
 }
 
 void QmitkMxNMultiWidget::SaveLayout(std::string filename)
 {
   if (filename.empty())
     return;
 
   nlohmann::json layoutJSON;
   auto layout = this->layout();
   if (layout == nullptr)
     return;
 
   // There should only ever be one item: either a window or a splitter
   auto widget = layout->itemAt(0)->widget();
 
   if (auto splitter = dynamic_cast<QSplitter*>(widget); splitter)
   {
     layoutJSON = BuildJSONFromLayout(splitter);
   }
   else if (auto window = dynamic_cast<QmitkRenderWindowWidget*>(widget); window)
   {
     layoutJSON["isWindow"] = true;
   }
 
   std::ofstream outStream(filename);
   outStream << std::setw(4) << layoutJSON << std::endl;
 
 }
 
 nlohmann::json QmitkMxNMultiWidget::BuildJSONFromLayout(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(nlohmann::json jsonData, unsigned int* windowCounter, QSplitter* parentSplitter)
+QSplitter* QmitkMxNMultiWidget::BuildLayoutFromJSON(const nlohmann::json* jsonData, unsigned int* windowCounter, QSplitter* parentSplitter)
 {
-  bool vertical = jsonData["vertical"].get<bool>();
+
+  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["content"])
+  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;
       QString renderWindowName;
       QmitkAbstractMultiWidget::RenderWindowWidgetMap::iterator it;
       if (*windowCounter < GetRenderWindowWidgets().size())
       {
         renderWindowName = this->GetNameFromIndex(*windowCounter);
       }
       else
       {
         CreateRenderWindowWidget();
         renderWindowName = this->GetNameFromIndex(this->GetNumberOfRenderWindowWidgets() - 1);
       }
       auto temp = renderWindowName.toStdString();
       auto renderWindowWidgets = GetRenderWindowWidgets();
       it = renderWindowWidgets.find(renderWindowName);
       if (it != renderWindowWidgets.end())
       {
         window = it->second;
         window->GetSliceNavigationController()->SetDefaultViewDirection(viewPlane);
         window->GetSliceNavigationController()->Update();
         split->addWidget(window.get());
         window->show();
         (*windowCounter)++;
       }
     }
     else
     {
-      auto subSplitter = BuildLayoutFromJSON(object, windowCounter, split);
+      auto subSplitter = BuildLayoutFromJSON(&object, windowCounter, split);
       split->addWidget(subSplitter);
     }
   }
   split->setSizes(sizes);
 
   return split;
 
 }
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
index 311897eea6..ab9d0be839 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
@@ -1,240 +1,238 @@
 /*============================================================================
 
 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->RemovePlanesFromDataStorage();
       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->AddPlanesToDataStorage();
       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->AddPlanesToDataStorage();
   }
 }
 
 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::CustomLayoutLoad,
-          static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::LoadCustomLayout);
   connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::SaveLayout,
     static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::SaveLayout);
-  connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::PresetLayoutLoad,
-    static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::LoadPresetLayout);
+  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();
 }