diff --git a/Modules/QtWidgets/files.cmake b/Modules/QtWidgets/files.cmake
index 67c6335c3e..dca87db1cb 100644
--- a/Modules/QtWidgets/files.cmake
+++ b/Modules/QtWidgets/files.cmake
@@ -1,186 +1,189 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   QmitkAbstractDataStorageModel.cpp
   QmitkAbstractMultiWidget.cpp
   QmitkAbstractNodeSelectionWidget.cpp
   QmitkApplicationCursor.cpp
+  QmitkAutomatedLayoutWidget.cpp
   QmitkDataStorageComboBox.cpp
   QmitkDataStorageDefaultListModel.cpp
   QmitkDataStorageHistoryModel.cpp
   QmitkDataStorageListModel.cpp
   QmitkDataStorageTableModel.cpp
   QmitkDataStorageSimpleTreeModel.cpp
   QmitkDataStorageTreeModel.cpp
   QmitkDataStorageTreeModelInternalItem.cpp
   QmitkDnDDataNodeWidget.cpp
   QmitkFileReaderOptionsDialog.cpp
   QmitkFileReaderWriterOptionsWidget.cpp
   QmitkFileWriterOptionsDialog.cpp
   QmitkInteractionSchemeToolBar.cpp
   QmitkIOUtil.cpp
   QmitkLevelWindowPresetDefinitionDialog.cpp
   QmitkLevelWindowRangeChangeDialog.cpp
   QmitkLevelWindowWidgetContextMenu.cpp
   QmitkLevelWindowWidget.cpp
   QmitkLineEditLevelWindowWidget.cpp
   QmitkMemoryUsageIndicatorView.cpp
   QmitkMimeTypes.cpp
   QmitkMultiNodeSelectionWidget.cpp
   QmitkMultiWidgetConfigurationToolBar.cpp
   QmitkMultiWidgetLayoutManager.cpp
   QmitkMultiWidgetLayoutSelectionWidget.cpp
   QmitkNodeDescriptor.cpp
   QmitkNodeSelectionButton.cpp
   QmitkNodeSelectionConstants.cpp
   QmitkNodeSelectionDialog.cpp
   QmitkNodeSelectionListItemWidget.cpp
   QmitkNodeSelectionPreferenceHelper.cpp
   QmitkNodeDescriptor.cpp
   QmitkColoredNodeDescriptor.cpp
   QmitkNodeDescriptorManager.cpp
   QmitkProgressBar.cpp
   QmitkPropertiesTableEditor.cpp
   QmitkPropertiesTableModel.cpp
   QmitkPropertyDelegate.cpp
   QmitkRegisterClasses.cpp
   QmitkRenderingManager.cpp
   QmitkRenderWindowDataStorageTreeModel.cpp
   QmitkRenderingManagerFactory.cpp
   QmitkRenderWindow.cpp
   QmitkRenderWindowMenu.cpp
   QmitkRenderWindowUtilityWidget.cpp
   QmitkRenderWindowWidget.cpp
   QmitkRenderWindowContextDataStorageInspector.cpp
   mitkRenderWindowLayerController.cpp
   mitkRenderWindowLayerUtilities.cpp
   mitkRenderWindowViewDirectionController.cpp
   QmitkServiceListWidget.cpp
   QmitkSingleNodeSelectionWidget.cpp
   QmitkSliceNavigationWidget.cpp
   QmitkSliderLevelWindowWidget.cpp
   QmitkStdMultiWidget.cpp
   QmitkStepperAdapter.cpp
   QmitkMxNMultiWidget.cpp
   QmitkDataStorageComboBoxWithSelectNone.cpp
   QmitkDataStorageFilterProxyModel.cpp
   QmitkPropertyItem.cpp
   QmitkPropertyItemDelegate.cpp
   QmitkPropertyItemModel.cpp
   QmitkStyleManager.cpp
   QmitkAbstractDataStorageInspector.cpp
   QmitkDataStorageFavoriteNodesInspector.cpp
   QmitkDataStorageListInspector.cpp
   QmitkDataStorageTreeInspector.cpp
   QmitkDataStorageSelectionHistoryInspector.cpp
   QmitkModelViewSelectionConnector.cpp
   mitkIDataStorageInspectorProvider.cpp
   mitkQtWidgetsActivator.cpp
   mitkDataStorageInspectorGenerator.cpp
   QmitkOverlayWidget.cpp
   QmitkSimpleTextOverlayWidget.cpp
   QmitkButtonOverlayWidget.cpp
   QmitkNodeDetailsDialog.cpp
   QmitkRenderWindowDataNodeTableModel.cpp
   QmitkSynchronizedNodeSelectionWidget.cpp
   QmitkSynchronizedWidgetConnector.cpp
 )
 
 set(MOC_H_FILES
   include/QmitkAbstractDataStorageModel.h
   include/QmitkAbstractMultiWidget.h
   include/QmitkAbstractNodeSelectionWidget.h
+  include/QmitkAutomatedLayoutWidget.h
   include/QmitkDataStorageComboBox.h
   include/QmitkDataStorageTableModel.h
   include/QmitkDataStorageTreeModel.h
   include/QmitkDataStorageSimpleTreeModel.h
   include/QmitkDataStorageDefaultListModel.h
   include/QmitkDnDDataNodeWidget.h
   include/QmitkFileReaderOptionsDialog.h
   include/QmitkFileReaderWriterOptionsWidget.h
   include/QmitkFileWriterOptionsDialog.h
   include/QmitkInteractionSchemeToolBar.h
   include/QmitkLevelWindowPresetDefinitionDialog.h
   include/QmitkLevelWindowRangeChangeDialog.h
   include/QmitkLevelWindowWidgetContextMenu.h
   include/QmitkLevelWindowWidget.h
   include/QmitkLineEditLevelWindowWidget.h
   include/QmitkMemoryUsageIndicatorView.h
   include/QmitkMultiNodeSelectionWidget.h
   include/QmitkMultiWidgetConfigurationToolBar.h
   include/QmitkMultiWidgetLayoutManager.h
   include/QmitkMultiWidgetLayoutSelectionWidget.h
   include/QmitkNodeDescriptor.h
   include/QmitkNodeSelectionButton.h
   include/QmitkNodeSelectionDialog.h
   include/QmitkNodeSelectionListItemWidget.h
   include/QmitkColoredNodeDescriptor.h
   include/QmitkNodeDescriptorManager.h
   include/QmitkProgressBar.h
   include/QmitkPropertiesTableEditor.h
   include/QmitkPropertyDelegate.h
   include/QmitkRenderingManager.h
   include/QmitkRenderWindow.h
   include/QmitkRenderWindowDataStorageTreeModel.h
   include/QmitkRenderWindowMenu.h
   include/QmitkRenderWindowUtilityWidget.h
   include/QmitkRenderWindowWidget.h
   include/QmitkRenderWindowContextDataStorageInspector.h
   include/mitkRenderWindowLayerController.h
   include/mitkRenderWindowLayerUtilities.h
   include/mitkRenderWindowViewDirectionController.h
   include/QmitkServiceListWidget.h
   include/QmitkSingleNodeSelectionWidget.h
   include/QmitkSliceNavigationWidget.h
   include/QmitkSliderLevelWindowWidget.h
   include/QmitkStdMultiWidget.h
   include/QmitkMxNMultiWidget.h
   include/QmitkStepperAdapter.h
   include/QmitkDataStorageComboBoxWithSelectNone.h
   include/QmitkPropertyItemDelegate.h
   include/QmitkPropertyItemModel.h
   include/QmitkAbstractDataStorageInspector.h
   include/QmitkDataStorageFavoriteNodesInspector.h
   include/QmitkDataStorageListInspector.h
   include/QmitkDataStorageTreeInspector.h
   include/QmitkDataStorageHistoryModel.h
   include/QmitkDataStorageSelectionHistoryInspector.h
   include/QmitkModelViewSelectionConnector.h
   include/QmitkOverlayWidget.h
   include/QmitkSimpleTextOverlayWidget.h
   include/QmitkButtonOverlayWidget.h
   include/QmitkNodeDetailsDialog.h
   include/QmitkRenderWindowDataNodeTableModel.h
   include/QmitkSynchronizedNodeSelectionWidget.h
   include/QmitkSynchronizedWidgetConnector.h
 )
 
 set(UI_FILES
+  src/QmitkAutomatedLayoutWidget.ui
   src/QmitkFileReaderOptionsDialog.ui
   src/QmitkFileWriterOptionsDialog.ui
   src/QmitkLevelWindowPresetDefinition.ui
   src/QmitkLevelWindowWidget.ui
   src/QmitkLevelWindowRangeChange.ui
   src/QmitkMemoryUsageIndicator.ui
   src/QmitkMultiNodeSelectionWidget.ui
   src/QmitkMultiWidgetLayoutSelectionWidget.ui
   src/QmitkNodeSelectionDialog.ui
   src/QmitkNodeSelectionListItemWidget.ui
   src/QmitkRenderWindowContextDataStorageInspector.ui
   src/QmitkServiceListWidgetControls.ui
   src/QmitkSingleNodeSelectionWidget.ui
   src/QmitkSliceNavigationWidget.ui
   src/QmitkDataStorageListInspector.ui
   src/QmitkDataStorageTreeInspector.ui
   src/QmitkDataStorageSelectionHistoryInspector.ui
   src/QmitkSynchronizedNodeSelectionWidget.ui
   src/QmitkNodeDetailsDialog.ui
 )
 
 set(RESOURCE_FILES
   mxnLayout_twoRowsEachDirection.json
 )
 
 set(QRC_FILES
   resource/Qmitk.qrc
 )
diff --git a/Modules/QtWidgets/include/QmitkAutomatedLayoutWidget.h b/Modules/QtWidgets/include/QmitkAutomatedLayoutWidget.h
new file mode 100644
index 0000000000..40564ee207
--- /dev/null
+++ b/Modules/QtWidgets/include/QmitkAutomatedLayoutWidget.h
@@ -0,0 +1,50 @@
+/*============================================================================
+
+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 QmitkAutomatedLayoutDialog_h
+#define QmitkAutomatedLayoutDialog_h
+
+#include <MitkQtWidgetsExports.h>
+
+#include <mitkDataStorage.h>
+
+#include <QWidget>
+
+namespace Ui
+{
+  class QmitkAutomatedLayoutWidget;
+}
+
+class MITKQTWIDGETS_EXPORT QmitkAutomatedLayoutWidget : public QWidget
+{
+  Q_OBJECT
+
+private Q_SLOTS:
+  void OnSetLayoutClicked();
+  void OnSelectionDialogClosed();
+
+Q_SIGNALS:
+  void SetDataBasedLayout(const QList<mitk::DataNode::Pointer>& nodes);
+
+
+public:
+  explicit QmitkAutomatedLayoutWidget(QWidget* parent = nullptr);
+  void SetDataStorage(mitk::DataStorage::Pointer dataStorage);
+
+private:
+
+  Ui::QmitkAutomatedLayoutWidget* m_Controls;
+  mitk::DataStorage::Pointer m_DataStorage;
+};
+
+
+#endif
diff --git a/Modules/QtWidgets/include/QmitkMultiNodeSelectionWidget.h b/Modules/QtWidgets/include/QmitkMultiNodeSelectionWidget.h
index 54c9f87f0f..e4ad19807b 100644
--- a/Modules/QtWidgets/include/QmitkMultiNodeSelectionWidget.h
+++ b/Modules/QtWidgets/include/QmitkMultiNodeSelectionWidget.h
@@ -1,82 +1,85 @@
 /*============================================================================
 
 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 QmitkMultiNodeSelectionWidget_h
 #define QmitkMultiNodeSelectionWidget_h
 
 #include <MitkQtWidgetsExports.h>
 
 #include <ui_QmitkMultiNodeSelectionWidget.h>
 
 #include <mitkDataStorage.h>
 #include <mitkWeakPointer.h>
 #include <mitkNodePredicateBase.h>
 
 #include <QmitkAbstractNodeSelectionWidget.h>
 #include <QmitkSimpleTextOverlayWidget.h>
 
 class QmitkAbstractDataStorageModel;
 
 /**
 * @class QmitkMultiNodeSelectionWidget
 * @brief Widget that allows to perform and represents a multiple node selection.
 */
 class MITKQTWIDGETS_EXPORT QmitkMultiNodeSelectionWidget : public QmitkAbstractNodeSelectionWidget
 {
   Q_OBJECT
 
 public:
   explicit QmitkMultiNodeSelectionWidget(QWidget* parent = nullptr);
 
   using NodeList = QmitkAbstractNodeSelectionWidget::NodeList;
 
   /**
   * @brief Helper function that is used to check the given selection for consistency.
   *        Returning an empty string assumes that everything is alright and the selection
   *        is valid. If the string is not empty, the content of the string will be used
   *        as error message in the overlay to indicate the problem.
   */
   using SelectionCheckFunctionType = std::function<std::string(const NodeList &)>;
   /**
   * @brief A selection check function can be set. If set the widget uses this function to
   *        check the made/set selection. If the selection is valid, everything is fine.
   *        If selection is indicated as invalid, it will not be communicated by the widget
   *        (no signal emission).
   */
   void SetSelectionCheckFunction(const SelectionCheckFunctionType &checkFunction);
 
   /** Returns if the current internal selection is violating the current check function, if set.*/
   bool CurrentSelectionViolatesCheckFunction() const;
 
+Q_SIGNALS:
+  void DialogClosed();
+
 public Q_SLOTS:
   void OnEditSelection();
 
 protected Q_SLOTS:
   void OnClearSelection(const mitk::DataNode* node);
 
 protected:
   void changeEvent(QEvent *event) override;
 
   void UpdateInfo() override;
   void OnInternalSelectionChanged() override;
 
   bool AllowEmissionOfSelection(const NodeList& emissionCandidates) const override;
 
   QmitkSimpleTextOverlayWidget* m_Overlay;
 
   SelectionCheckFunctionType m_CheckFunction;
   mutable std::string m_CheckResponse;
 
   Ui_QmitkMultiNodeSelectionWidget m_Controls;
 };
 
 #endif
diff --git a/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h b/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h
index 18bb853e67..e5d36d8a7e 100644
--- a/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h
+++ b/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h
@@ -1,70 +1,73 @@
 /*============================================================================
 
 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 <MitkQtWidgetsExports.h>
 
 #include <mitkInteractionSchemeSwitcher.h>
+#include <mitkDataStorage.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;
+  void SetDataStorage(mitk::DataStorage::Pointer dataStorage);
 
 Q_SIGNALS:
 
   void LayoutSet(int row, int column);
   void SaveLayout(std::ostream* outStream);
   void LoadLayout(const nlohmann::json* jsonData);
+  void SetDataBasedLayout(const QList<mitk::DataNode::Pointer>& nodes);
   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
diff --git a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
index 14d9fed068..fa38feb2d2 100644
--- a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
+++ b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
@@ -1,65 +1,74 @@
 /*============================================================================
 
 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 <QmitkAutomatedLayoutWidget.h>
 
 #include <nlohmann/json.hpp>
 
 // qt
 #include "QWidget"
 
+namespace Ui
+{
+  class QmitkMultiWidgetLayoutSelectionWidget;
+}
+
 /**
 * @brief
 *
 *
 */
 class MITKQTWIDGETS_EXPORT QmitkMultiWidgetLayoutSelectionWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkMultiWidgetLayoutSelectionWidget(QWidget* parent = nullptr);
+  void SetDataStorage(mitk::DataStorage::Pointer dataStorage);
 
 Q_SIGNALS:
 
   void LayoutSet(int row, int column);
+  void SetDataBasedLayout(const QList<mitk::DataNode::Pointer>& nodes);
 
   // needs to be connected via Qt::DirectConnection (usually default), to ensure the stream pointers validity
   void SaveLayout(std::ostream* outStream);
 
   void LoadLayout(const nlohmann::json* jsonData);
 
 private Q_SLOTS:
 
   void OnTableItemSelectionChanged();
   void OnSetLayoutButtonClicked();
+  void OnDataBasedLayoutButtonClicked();
   void OnSaveLayoutButtonClicked();
   void OnLoadLayoutButtonClicked();
   void OnLayoutPresetSelected(int index);
 
 private:
 
   void Init();
 
 
-  Ui::QmitkMultiWidgetLayoutSelectionWidget ui;
+  Ui::QmitkMultiWidgetLayoutSelectionWidget* ui;
   std::map<int, nlohmann::json> m_PresetMap;
+  QmitkAutomatedLayoutWidget* m_AutomatedDataLayoutWidget;
 
 };
 
 #endif
diff --git a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
index 92d5e7a7b5..233d5771e6 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,131 +1,133 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkMxNMultiWidget_h
 #define QmitkMxNMultiWidget_h
 
 #include "MitkQtWidgetsExports.h"
 
 // qt widgets module
 #include "QmitkAbstractMultiWidget.h"
 #include <QmitkSynchronizedNodeSelectionWidget.h>
 #include <QmitkSynchronizedWidgetConnector.h>
 
 #include <nlohmann/json.hpp>
 
 class QSplitter;
 
 /**
 * @brief The 'QmitkMxNMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
 *        Render windows can dynamically be added and removed to change the layout of the multi widget. This
 *        is done by using the 'SetLayout'-function to define a layout. This will automatically add or remove
 *        the appropriate number of render window widgets.
 */
 class MITKQTWIDGETS_EXPORT QmitkMxNMultiWidget : public QmitkAbstractMultiWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkMxNMultiWidget(QWidget* parent = nullptr,
                       Qt::WindowFlags f = {},
                       const QString& multiWidgetName = "mxn");
 
   ~QmitkMxNMultiWidget();
 
   void InitializeMultiWidget() override;
 
   void Synchronize(bool synchronized) override;
 
   QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
   QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
 
   void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget) override;
 
   /**
   * @brief Initialize the active render windows of the MxNMultiWidget to the given geometry.
   *
   * @param geometry       The geometry to be used to initialize / update the
   *                       active render window's time and slice navigation controller.
   * @param resetCamera    If true, the camera and crosshair will be reset to the default view (centered, no zoom).
   *                       If false, the current crosshair position and the camera zoom will be stored and reset
   *                       after the reference geometry has been updated.
   */
   void InitializeViews(const mitk::TimeGeometry* geometry, bool resetCamera) override;
 
   /**
   * @brief Forward the given time geometry to all base renderers, so that they can store it as their
   *        interaction reference geometry.
   *        This will update the alignment status of the reference geometry for each base renderer.
   *        For more details, see 'BaseRenderer::SetInteractionReferenceGeometry'.
   *        Overridem from 'QmitkAbstractMultiWidget'.
   */
   void SetInteractionReferenceGeometry(const mitk::TimeGeometry* referenceGeometry) override;
 
   /**
   * @brief Returns true if the render windows are coupled; false if not.
   *
   * For the MxNMultiWidget the render windows are typically decoupled.
   */
   bool HasCoupledRenderWindows() const override;
 
   void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
   const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
 
   void SetCrosshairVisibility(bool visible) override;
   bool GetCrosshairVisibility() const override;
   void SetCrosshairGap(unsigned int gapSize) override;
 
   void ResetCrosshair() override;
 
   void SetWidgetPlaneMode(int userMode) override;
 
   mitk::SliceNavigationController* GetTimeNavigationController();
 
   void EnableCrosshair();
   void DisableCrosshair();
 
 public Q_SLOTS:
 
   // mouse events
   void wheelEvent(QWheelEvent* e) override;
   void mousePressEvent(QMouseEvent* e) override;
   void moveEvent(QMoveEvent* e) override;
   void LoadLayout(const nlohmann::json* jsonData);
   void SaveLayout(std::ostream* outStream);
+  void SetDataBasedLayout(const QmitkAbstractNodeSelectionWidget::NodeList& nodes);
 
 Q_SIGNALS:
 
   void WheelMoved(QWheelEvent *);
   void Moved();
   void UpdateUtilityWidgetViewPlanes();
   void LayoutChanged();
 
 private:
 
   void SetLayoutImpl() override;
   void SetInteractionSchemeImpl() override { }
 
   QmitkAbstractMultiWidget::RenderWindowWidgetPointer CreateRenderWindowWidget();
+  QmitkAbstractMultiWidget::RenderWindowWidgetPointer GetWindowFromIndex(size_t index);
   void SetInitialSelection();
   void ToggleSynchronization(QmitkSynchronizedNodeSelectionWidget* synchronizedWidget);
 
   static nlohmann::json BuildJSONFromLayout(const QSplitter* splitter);
   QSplitter* BuildLayoutFromJSON(const nlohmann::json* jsonData, unsigned int* windowCounter, QSplitter* parentSplitter = nullptr);
 
   std::unique_ptr<QmitkSynchronizedWidgetConnector> m_SynchronizedWidgetConnector;
 
   bool m_CrosshairVisibility;
 
 };
 
 #endif
diff --git a/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h b/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h
index 8df33517f5..3ba92caf6f 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h
@@ -1,77 +1,79 @@
 /*============================================================================
 
 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 QmitkRenderWindowUtilityWidget_h
 #define QmitkRenderWindowUtilityWidget_h
 
 #include "MitkQtWidgetsExports.h"
 
 // qt widgets module
 #include <QmitkSynchronizedNodeSelectionWidget.h>
 #include <QmitkSliceNavigationWidget.h>
 #include <QmitkStepperAdapter.h>
 #include <mitkRenderWindowLayerController.h>
 #include <mitkRenderWindowViewDirectionController.h>
 
 // qt
 #include <QWidget>
 #include <QHBoxLayout>
 #include <QMenuBar>
 #include <QComboBox>
 
 namespace mitk
 {
   class DataStorage;
 }
 
 class QmitkRenderWindow;
 
 class MITKQTWIDGETS_EXPORT QmitkRenderWindowUtilityWidget : public QWidget
 {
 	Q_OBJECT
 
 public:
 
   QmitkRenderWindowUtilityWidget(
     QWidget* parent = nullptr,
     QmitkRenderWindow* renderWindow = nullptr,
     mitk::DataStorage* dataStorage = nullptr
   );
 
   ~QmitkRenderWindowUtilityWidget() override;
 
   void ToggleSynchronization(bool synchronized);
 
   void SetGeometry(const itk::EventObject& event);
 
 public Q_SLOTS:
   void UpdateViewPlaneSelection();
 
 Q_SIGNALS:
 
   void SynchronizationToggled(QmitkSynchronizedNodeSelectionWidget* synchronizedWidget);
+  void SetDataSelection(const QList<mitk::DataNode::Pointer>& newSelection);
 
 private:
 
   mitk::BaseRenderer* m_BaseRenderer;
   QmitkSynchronizedNodeSelectionWidget* m_NodeSelectionWidget;
+  QPushButton* m_SynchPushButton;
   QmitkSliceNavigationWidget* m_SliceNavigationWidget;
   QmitkStepperAdapter* m_StepperAdapter;
   std::unique_ptr<mitk::RenderWindowLayerController> m_RenderWindowLayerController;
   std::unique_ptr<mitk::RenderWindowViewDirectionController> m_RenderWindowViewDirectionController;
   QComboBox* m_ViewDirectionSelector;
 
   void ChangeViewDirection(const QString& viewDirection);
 
 };
 
 #endif
diff --git a/Modules/QtWidgets/include/QmitkRenderWindowWidget.h b/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
index 98f734fec0..b9b803e64f 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
@@ -1,123 +1,125 @@
 /*============================================================================
 
 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 QmitkRenderWindowWidget_h
 #define QmitkRenderWindowWidget_h
 
 #include "MitkQtWidgetsExports.h"
 
 // qt widgets module
 #include <QmitkRenderWindow.h>
 
 // mitk core
 #include <mitkCrosshairManager.h>
 #include <mitkDataStorage.h>
 #include <mitkRenderWindow.h>
+#include <QmitkRenderWindowUtilityWidget.h>
 
 // qt
 #include <QFrame>
 #include <QMouseEvent>
 #include <QVBoxLayout>
 
 class vtkCornerAnnotation;
 
 /**
 * @brief The 'QmitkRenderWindowWidget' is a QFrame that holds a render window
 *        and some associates properties, e.g. decorations.
 *        Decorations are corner annotation (text and color), frame color or background color
 *        and can be set using this class.
 *        The 'QmitkRenderWindowWidget' is used inside a 'QmitkAbstractMultiWidget', where a map contains
 *        several render window widgets to create the multi widget display.
 *        This class uses a CrosshairManager, which allows to use plane geometries as crosshair.
 */
 class MITKQTWIDGETS_EXPORT QmitkRenderWindowWidget : public QFrame
 {
   Q_OBJECT
 
 public:
 
   QmitkRenderWindowWidget(
     QWidget* parent = nullptr,
     const QString& widgetName = "",
     mitk::DataStorage* dataStorage = nullptr);
 
   ~QmitkRenderWindowWidget() override;
 
   void SetDataStorage(mitk::DataStorage* dataStorage);
 
   const QString& GetWidgetName() const { return m_WidgetName; };
   QmitkRenderWindow* GetRenderWindow() const { return m_RenderWindow; };
 
   mitk::SliceNavigationController* GetSliceNavigationController() const;
 
   void RequestUpdate();
   void ForceImmediateUpdate();
 
   void AddUtilityWidget(QWidget* utilityWidget);
+  QmitkRenderWindowUtilityWidget* GetUtilityWidget();
 
   void SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower);
   void ShowGradientBackground(bool enable);
   std::pair<mitk::Color, mitk::Color> GetGradientBackgroundColors() const { return m_GradientBackgroundColors; };
   bool IsGradientBackgroundOn() const;
 
   void SetDecorationColor(const mitk::Color& color);
   mitk::Color GetDecorationColor() const { return m_DecorationColor; };
 
   void ShowColoredRectangle(bool show);
   bool IsColoredRectangleVisible() const;
 
   void ShowCornerAnnotation(bool show);
   bool IsCornerAnnotationVisible() const;
   void SetCornerAnnotationText(const std::string& cornerAnnotation);
   std::string GetCornerAnnotationText() const;
 
   bool IsRenderWindowMenuActivated() const;
 
   void SetCrosshairVisibility(bool visible);
   bool GetCrosshairVisibility();
   void SetCrosshairGap(unsigned int gapSize);
 
   void EnableCrosshair();
   void DisableCrosshair();
 
   void SetCrosshairPosition(const mitk::Point3D& newPosition);
   mitk::Point3D GetCrosshairPosition() const;
 
   void SetGeometry(const itk::EventObject& event);
   void SetGeometrySlice(const itk::EventObject& event);
 
 public Q_SLOTS:
 
   void OnResetGeometry();
 
 private:
 
   void InitializeGUI();
   void InitializeDecorations();
   void ResetGeometry(const mitk::TimeGeometry* referenceGeometry);
 
   QString m_WidgetName;
   QVBoxLayout* m_Layout;
 
   mitk::DataStorage* m_DataStorage;
 
   QmitkRenderWindow* m_RenderWindow;
 
   mitk::CrosshairManager::Pointer m_CrosshairManager;
 
   std::pair<mitk::Color, mitk::Color> m_GradientBackgroundColors;
   mitk::Color m_DecorationColor;
   vtkSmartPointer<vtkCornerAnnotation> m_CornerAnnotation;
 
 };
 
 #endif
diff --git a/Modules/QtWidgets/include/QmitkSynchronizedNodeSelectionWidget.h b/Modules/QtWidgets/include/QmitkSynchronizedNodeSelectionWidget.h
index 104403f81f..2a418227ec 100644
--- a/Modules/QtWidgets/include/QmitkSynchronizedNodeSelectionWidget.h
+++ b/Modules/QtWidgets/include/QmitkSynchronizedNodeSelectionWidget.h
@@ -1,103 +1,105 @@
 /*============================================================================
 
 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 QmitkSynchronizedNodeSelectionWidget_h
 #define QmitkSynchronizedNodeSelectionWidget_h
 
 #include <MitkQtWidgetsExports.h>
 
 #include "ui_QmitkSynchronizedNodeSelectionWidget.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 
 // qt widgets module
 #include <QmitkAbstractNodeSelectionWidget.h>
 #include <QmitkRenderWindowDataNodeTableModel.h>
 
 /*
 * @brief The 'QmitkSynchronizedNodeSelectionWidget' implements the 'QmitkAbstractNodeSelectionWidget'
 *        by providing a table view, using a 'QmitkRenderWindowDataNodeTableModel' and extending it
 *        with base renderer-specific functionality.
 * 
 *        Given a base renderer, the selection widget is able to display and access render window specific properties
 *        of the selected nodes, making it possible to switch between a "synchronized" and "desynchronized" selection
 *        state.
 *        The widget can be used to decide if all data nodes of the data storage should be selected or
 *        only an individually selected set of nodes, defined by a 'QmitkNodeSelectionDialog'.
 *        If individual nodes are selected / removed from the selection, the widget can inform other
 *        'QmitkSynchronizedNodeSelectionWidget' about the current selection, if desired.
 *        Additionally the widget allows to reinitialize the corresponding base renderer with a specific
 *        data node geometry.
 */
 class MITKQTWIDGETS_EXPORT QmitkSynchronizedNodeSelectionWidget : public QmitkAbstractNodeSelectionWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkSynchronizedNodeSelectionWidget(QWidget* parent);
   ~QmitkSynchronizedNodeSelectionWidget();
 
   using NodeList = QmitkAbstractNodeSelectionWidget::NodeList;
 
   void SetBaseRenderer(mitk::BaseRenderer* baseRenderer);
 
   void SetSelectAll(bool selectAll);
   bool GetSelectAll() const;
   void SelectAll();
   void SetSynchronized(bool synchronize);
   bool IsSynchronized() const;
 
 Q_SIGNALS:
 
   void SelectionModeChanged(bool selectAll);
   void DeregisterSynchronization();
 
+public Q_SLOTS:
+  void SetSelection(const NodeList& newSelection);
+
 private Q_SLOTS:
 
-  void OnModelUpdated();
   void OnSelectionModeChanged(bool selectAll);
   void OnEditSelection();
   void OnTableClicked(const QModelIndex& index);
 
 protected:
 
   void SetUpConnections();
   void Initialize();
 
   void UpdateInfo() override;
   void OnDataStorageChanged() override;
   void OnNodePredicateChanged() override;
   void ReviseSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection) override;
   void OnInternalSelectionChanged() override;
   bool AllowEmissionOfSelection(const NodeList& emissionCandidates) const override;
   void OnNodeAddedToStorage(const mitk::DataNode* node) override;
   void OnNodeModified(const itk::Object* caller, const itk::EventObject& event) override;
 
 private:
 
   void ReviseSynchronizedSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection);
   void ReviseDesynchronizedSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection);
   void ReinitNode(const mitk::DataNode* dataNode);
   void RemoveFromInternalSelection(mitk::DataNode* dataNode);
   bool IsParentNodeSelected(const mitk::DataNode* dataNode) const;
   void DeselectNode(mitk::DataNode* dataNode);
 
   Ui::QmitkSynchronizedNodeSelectionWidget m_Controls;
   mitk::WeakPointer<mitk::BaseRenderer> m_BaseRenderer;
 
   std::unique_ptr<QmitkRenderWindowDataNodeTableModel> m_StorageModel;
 
 };
 
 #endif
diff --git a/Modules/QtWidgets/src/QmitkAutomatedLayoutWidget.cpp b/Modules/QtWidgets/src/QmitkAutomatedLayoutWidget.cpp
new file mode 100644
index 0000000000..5404d060f1
--- /dev/null
+++ b/Modules/QtWidgets/src/QmitkAutomatedLayoutWidget.cpp
@@ -0,0 +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.
+
+============================================================================*/
+
+#include <QmitkAutomatedLayoutWidget.h>
+#include <mitkNodePredicateDataType.h>
+#include <mitkNodePredicateAnd.h>
+#include <mitkNodePredicateNot.h>
+#include <mitkNodePredicateProperty.h>
+#include <mitkImage.h>
+
+#include <ui_QmitkAutomatedLayoutWidget.h>
+
+QmitkAutomatedLayoutWidget::QmitkAutomatedLayoutWidget(QWidget* parent)
+  : QWidget(parent)
+  , m_Controls(new Ui::QmitkAutomatedLayoutWidget)
+{
+  m_Controls->setupUi(this);
+
+  auto isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
+  auto isNotHelper = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"));
+  auto isNotHidden = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object"));
+  auto isValidImage = mitk::NodePredicateAnd::New(isImage, isNotHelper, isNotHidden);
+  m_Controls->dataSelector->SetNodePredicate(isValidImage);
+  m_Controls->dataSelector->SetInvalidInfo(QStringLiteral("Please select images for the layout"));
+  m_Controls->dataSelector->SetPopUpTitel(QStringLiteral("Select input images"));
+  m_Controls->dataSelector->SetPopUpHint(QStringLiteral("Select as many images as you want to compare"));
+
+  m_Controls->setLayoutButton->setEnabled(false);
+
+  connect(m_Controls->dataSelector, &QmitkMultiNodeSelectionWidget::DialogClosed, this, &QmitkAutomatedLayoutWidget::OnSelectionDialogClosed);
+  connect(m_Controls->setLayoutButton, &QPushButton::clicked, this, &QmitkAutomatedLayoutWidget::OnSetLayoutClicked);
+}
+
+void QmitkAutomatedLayoutWidget::SetDataStorage(mitk::DataStorage::Pointer dataStorage)
+{
+  // smart pointer to data storage needs to be saved here because dataSelector makes it a regular pointer
+  m_DataStorage = dataStorage;
+  m_Controls->dataSelector->SetDataStorage(m_DataStorage);
+}
+
+void QmitkAutomatedLayoutWidget::OnSetLayoutClicked()
+{
+  auto selectedNodes = m_Controls->dataSelector->GetSelectedNodes();
+  emit SetDataBasedLayout(selectedNodes);
+  this->hide();
+}
+
+void QmitkAutomatedLayoutWidget::OnSelectionDialogClosed()
+{
+  bool setLayoutEnabled = m_Controls->dataSelector->GetSelectedNodes().size() > 0;
+  m_Controls->setLayoutButton->setEnabled(setLayoutEnabled);
+  this->show();
+}
diff --git a/Modules/QtWidgets/src/QmitkAutomatedLayoutWidget.ui b/Modules/QtWidgets/src/QmitkAutomatedLayoutWidget.ui
new file mode 100644
index 0000000000..13be69219d
--- /dev/null
+++ b/Modules/QtWidgets/src/QmitkAutomatedLayoutWidget.ui
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QmitkAutomatedLayoutWidget</class>
+ <widget class="QWidget" name="QmitkAutomatedLayoutWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Widget</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QmitkMultiNodeSelectionWidget" name="dataSelector" native="true"/>
+   </item>
+   <item>
+    <widget class="QPushButton" name="setLayoutButton">
+     <property name="text">
+      <string>Set Layout</string>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QmitkMultiNodeSelectionWidget</class>
+   <extends>QWidget</extends>
+   <header location="global">QmitkMultiNodeSelectionWidget.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Modules/QtWidgets/src/QmitkMultiNodeSelectionWidget.cpp b/Modules/QtWidgets/src/QmitkMultiNodeSelectionWidget.cpp
index 5bbf899831..7ed9f6eafc 100644
--- a/Modules/QtWidgets/src/QmitkMultiNodeSelectionWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiNodeSelectionWidget.cpp
@@ -1,164 +1,165 @@
 /*============================================================================
 
 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 "QmitkMultiNodeSelectionWidget.h"
 
 #include <algorithm>
 
 #include <QmitkCustomVariants.h>
 #include <QmitkNodeSelectionDialog.h>
 #include <QmitkNodeSelectionListItemWidget.h>
 
 QmitkMultiNodeSelectionWidget::QmitkMultiNodeSelectionWidget(QWidget* parent)
   : QmitkAbstractNodeSelectionWidget(parent)
 {
   m_Controls.setupUi(this);
   m_Overlay = new QmitkSimpleTextOverlayWidget(m_Controls.list);
   m_Overlay->setVisible(false);
   m_CheckFunction = [](const NodeList &) { return ""; };
 
   this->OnInternalSelectionChanged();
   this->UpdateInfo();
 
   connect(m_Controls.btnChange, SIGNAL(clicked(bool)), this, SLOT(OnEditSelection()));
 }
 
 void QmitkMultiNodeSelectionWidget::SetSelectionCheckFunction(const SelectionCheckFunctionType &checkFunction)
 {
   m_CheckFunction = checkFunction;
 
   auto newEmission = this->CompileEmitSelection();
   auto newCheckResponse = m_CheckFunction(newEmission);
 
   if (newCheckResponse.empty() && !m_CheckResponse.empty())
   {
     this->EmitSelection(newEmission);
   }
   m_CheckResponse = newCheckResponse;
   this->UpdateInfo();
 }
 
 void QmitkMultiNodeSelectionWidget::OnEditSelection()
 {
   QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(this, m_PopUpTitel, m_PopUpHint);
 
   dialog->SetDataStorage(m_DataStorage.Lock());
   dialog->SetNodePredicate(m_NodePredicate);
   dialog->SetCurrentSelection(this->CompileEmitSelection());
   dialog->SetSelectOnlyVisibleNodes(m_SelectOnlyVisibleNodes);
   dialog->SetSelectionMode(QAbstractItemView::MultiSelection);
   dialog->SetSelectionCheckFunction(m_CheckFunction);
 
   m_Controls.btnChange->setChecked(true);
   if (dialog->exec())
   {
     this->HandleChangeOfInternalSelection(dialog->GetSelectedNodes());
   }
   m_Controls.btnChange->setChecked(false);
 
+  emit DialogClosed();
   delete dialog;
 }
 
 void QmitkMultiNodeSelectionWidget::UpdateInfo()
 {
   if (!m_Controls.list->count())
   {
     if (m_IsOptional)
     {
       if (this->isEnabled())
       {
         m_Overlay->SetOverlayText(QStringLiteral("<font class=\"normal\">") + m_EmptyInfo + QStringLiteral("</font>"));
       }
       else
       {
         m_Overlay->SetOverlayText(QStringLiteral("<font class=\"disabled\">") + m_EmptyInfo + QStringLiteral("</font>"));
       }
     }
     else
     {
       if (this->isEnabled())
       {
         m_Overlay->SetOverlayText(QStringLiteral("<font class=\"warning\">") + m_InvalidInfo + QStringLiteral("</font>"));
       }
       else
       {
         m_Overlay->SetOverlayText(QStringLiteral("<font class=\"disabled\">") + m_InvalidInfo + QStringLiteral("</font>"));
       }
     }
   }
   else
   {
     if (!m_CheckResponse.empty())
     {
       m_Overlay->SetOverlayText(QString::fromStdString(m_CheckResponse));
     }
   }
 
   m_Overlay->setVisible(m_Controls.list->count() == 0 || !m_CheckResponse.empty());
 
   for (auto i = 0; i < m_Controls.list->count(); ++i)
   {
     auto item = m_Controls.list->item(i);
     auto widget = qobject_cast<QmitkNodeSelectionListItemWidget*>(m_Controls.list->itemWidget(item));
     widget->SetClearAllowed(m_IsOptional || m_Controls.list->count() > 1);
   }
 }
 
 void QmitkMultiNodeSelectionWidget::OnInternalSelectionChanged()
 {
   m_Controls.list->clear();
   auto currentSelection = this->GetCurrentInternalSelection();
   for (auto& node : currentSelection)
   {
     if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node))
     {
       QListWidgetItem *newItem = new QListWidgetItem;
 
       newItem->setSizeHint(QSize(0, 40));
       QmitkNodeSelectionListItemWidget* widget = new QmitkNodeSelectionListItemWidget;
 
       widget->SetSelectedNode(node);
       widget->SetClearAllowed(m_IsOptional || currentSelection.size() > 1);
 
       connect(widget, &QmitkNodeSelectionListItemWidget::ClearSelection, this, &QmitkMultiNodeSelectionWidget::OnClearSelection);
       newItem->setData(Qt::UserRole, QVariant::fromValue<mitk::DataNode::Pointer>(node));
 
       m_Controls.list->addItem(newItem);
       m_Controls.list->setItemWidget(newItem, widget);
     }
   }
 }
 
 void QmitkMultiNodeSelectionWidget::OnClearSelection(const mitk::DataNode* node)
 {
   this->RemoveNodeFromSelection(node);
 }
 
 void QmitkMultiNodeSelectionWidget::changeEvent(QEvent *event)
 {
   if (event->type() == QEvent::EnabledChange)
   {
     this->UpdateInfo();
   }
   QmitkAbstractNodeSelectionWidget::changeEvent(event);
 }
 
 bool QmitkMultiNodeSelectionWidget::AllowEmissionOfSelection(const NodeList& emissionCandidates) const
 {
   m_CheckResponse = m_CheckFunction(emissionCandidates);
   return m_CheckResponse.empty();
 }
 
 bool QmitkMultiNodeSelectionWidget::CurrentSelectionViolatesCheckFunction() const
 {
   return !m_CheckResponse.empty();
 }
diff --git a/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp b/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
index 1987f7653f..2446476a64 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
@@ -1,111 +1,119 @@
 /*============================================================================
 
 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::SetDataBasedLayout, this, &QmitkMultiWidgetConfigurationToolBar::SetDataBasedLayout);
   connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::SaveLayout, this, &QmitkMultiWidgetConfigurationToolBar::SaveLayout);
   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::SetDataStorage(mitk::DataStorage::Pointer dataStorage)
+{
+  if (m_LayoutSelectionPopup == nullptr)
+    return;
+  m_LayoutSelectionPopup->SetDataStorage(dataStorage);
+}
+
 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 d7c6dc070f..da35c00133 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
@@ -1,138 +1,160 @@
 /*============================================================================
 
 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 <QmitkMultiWidgetLayoutSelectionWidget.h>
+#include <ui_QmitkMultiWidgetLayoutSelectionWidget.h>
 
 #include <QFileDialog>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
 QmitkMultiWidgetLayoutSelectionWidget::QmitkMultiWidgetLayoutSelectionWidget(QWidget* parent/* = 0*/)
   : QWidget(parent)
+  , ui(new Ui::QmitkMultiWidgetLayoutSelectionWidget)
 {
   Init();
 }
 
 void QmitkMultiWidgetLayoutSelectionWidget::Init()
 {
-  ui.setupUi(this);
+  ui->setupUi(this);
 
   auto stylesheet = "QTableWidget::item{background-color: white;}\nQTableWidget::item:selected{background-color: #1C97EA;}";
-  ui.tableWidget->setStyleSheet(stylesheet);
+  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);
+  m_AutomatedDataLayoutWidget = new QmitkAutomatedLayoutWidget(this);
+  connect(m_AutomatedDataLayoutWidget, &QmitkAutomatedLayoutWidget::SetDataBasedLayout, this, &QmitkMultiWidgetLayoutSelectionWidget::SetDataBasedLayout);
+  m_AutomatedDataLayoutWidget->hide();
 
-  ui.selectDefaultLayoutComboBox->addItem("Select a layout preset");
+  connect(ui->tableWidget, &QTableWidget::itemSelectionChanged, this, &QmitkMultiWidgetLayoutSelectionWidget::OnTableItemSelectionChanged);
+  connect(ui->setLayoutPushButton, &QPushButton::clicked, this, &QmitkMultiWidgetLayoutSelectionWidget::OnSetLayoutButtonClicked);
+  connect(ui->dataBasedLayoutButton, &QPushButton::clicked, this, &QmitkMultiWidgetLayoutSelectionWidget::OnDataBasedLayoutButtonClicked);
+  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("/", "mxnLayout_*.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_PresetMap[ui.selectDefaultLayoutComboBox->count() - 1] = data;
+    ui->selectDefaultLayoutComboBox->addItem(QString::fromStdString(resourceName));
+    m_PresetMap[ui->selectDefaultLayoutComboBox->count() - 1] = data;
   }
 }
 
+void QmitkMultiWidgetLayoutSelectionWidget::SetDataStorage(mitk::DataStorage::Pointer dataStorage)
+{
+  if (m_AutomatedDataLayoutWidget == nullptr)
+    return;
+  m_AutomatedDataLayoutWidget->SetDataStorage(dataStorage);
+}
+
 void QmitkMultiWidgetLayoutSelectionWidget::OnTableItemSelectionChanged()
 {
-  QItemSelectionModel* selectionModel = ui.tableWidget->selectionModel();
+  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());
+    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();
+  QModelIndexList indices = ui->tableWidget->selectionModel()->selectedIndexes();
   if (indices.size() > 0)
   {
     // find largest row and column
     for (const auto& modelIndex : std::as_const(indices))
     {
       if (modelIndex.row() > row)
       {
         row = modelIndex.row();
       }
       if (modelIndex.column() > column)
       {
         column = modelIndex.column();
       }
     }
 
     close();
     emit LayoutSet(row+1, column+1);
   }
-  ui.selectDefaultLayoutComboBox->setCurrentIndex(0);
+  ui->selectDefaultLayoutComboBox->setCurrentIndex(0);
+}
+
+void QmitkMultiWidgetLayoutSelectionWidget::OnDataBasedLayoutButtonClicked()
+{
+  this->hide();
+  m_AutomatedDataLayoutWidget->setWindowFlags(Qt::Popup);
+  m_AutomatedDataLayoutWidget->move(this->pos().x() - m_AutomatedDataLayoutWidget->width() + this->width(), this->pos().y());
+  m_AutomatedDataLayoutWidget->show();
 }
 
 void QmitkMultiWidgetLayoutSelectionWidget::OnSaveLayoutButtonClicked()
 {
   QString filename = QFileDialog::getSaveFileName(nullptr, "Select where to save the current layout", "", "MITK Window Layout (*.json)");
   if (filename.isEmpty())
     return;
 
   QString fileExt(".json");
   if (!filename.endsWith(fileExt))
     filename += fileExt;
 
   auto outStream = std::ofstream(filename.toStdString());
   emit SaveLayout(&outStream);
 }
 
 void QmitkMultiWidgetLayoutSelectionWidget::OnLoadLayoutButtonClicked()
 {
   QString filename = QFileDialog::getOpenFileName(nullptr, "Load a layout file", "", "MITK Window Layouts (*.json)");
   if (filename.isEmpty())
     return;
 
-  ui.selectDefaultLayoutComboBox->setCurrentIndex(0);
+  ui->selectDefaultLayoutComboBox->setCurrentIndex(0);
 
   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;
   }
 
   auto jsonData = m_PresetMap[index];
   close();
   emit LoadLayout(&jsonData);
 }
diff --git a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.ui b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.ui
index 391d5b8cb2..01af707ab0 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.ui
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.ui
@@ -1,123 +1,149 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkMultiWidgetLayoutSelectionWidget</class>
  <widget class="QWidget" name="QmitkMultiWidgetLayoutSelectionWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>224</width>
-    <height>290</height>
+    <height>324</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QTableWidget" name="tableWidget">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>200</width>
+       <height>150</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>200</width>
+       <height>150</height>
+      </size>
+     </property>
      <property name="editTriggers">
       <set>QAbstractItemView::NoEditTriggers</set>
      </property>
      <property name="showDropIndicator" stdset="0">
       <bool>false</bool>
      </property>
      <property name="dragDropOverwriteMode">
       <bool>false</bool>
      </property>
      <property name="rowCount">
       <number>3</number>
      </property>
      <property name="columnCount">
       <number>4</number>
      </property>
      <attribute name="horizontalHeaderVisible">
       <bool>false</bool>
      </attribute>
-     <attribute name="horizontalHeaderDefaultSectionSize">
+     <attribute name="horizontalHeaderMinimumSectionSize">
       <number>50</number>
      </attribute>
-     <attribute name="horizontalHeaderMinimumSectionSize">
+     <attribute name="horizontalHeaderDefaultSectionSize">
       <number>50</number>
      </attribute>
      <attribute name="verticalHeaderVisible">
       <bool>false</bool>
      </attribute>
-     <attribute name="verticalHeaderDefaultSectionSize">
+     <attribute name="verticalHeaderMinimumSectionSize">
       <number>50</number>
      </attribute>
-     <attribute name="verticalHeaderMinimumSectionSize">
+     <attribute name="verticalHeaderDefaultSectionSize">
       <number>50</number>
      </attribute>
      <row/>
      <row/>
      <row/>
      <column/>
      <column/>
      <column/>
      <column/>
     </widget>
    </item>
    <item>
     <widget class="QPushButton" name="setLayoutPushButton">
      <property name="text">
       <string>Set multi widget layout</string>
      </property>
     </widget>
    </item>
    <item>
-    <widget class="Line" name="line">
-     <property name="minimumSize">
-      <size>
-       <width>0</width>
-       <height>0</height>
-      </size>
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
      </property>
-     <property name="baseSize">
+     <property name="sizeHint" stdset="0">
       <size>
-       <width>0</width>
-       <height>0</height>
+       <width>20</width>
+       <height>10</height>
       </size>
      </property>
-     <property name="lineWidth">
-      <number>1</number>
-     </property>
-     <property name="midLineWidth">
-      <number>0</number>
+    </spacer>
+   </item>
+   <item>
+    <widget class="QPushButton" name="dataBasedLayoutButton">
+     <property name="text">
+      <string>Data-based layout</string>
      </property>
+    </widget>
+   </item>
+   <item>
+    <spacer name="verticalSpacer_2">
      <property name="orientation">
-      <enum>Qt::Horizontal</enum>
+      <enum>Qt::Vertical</enum>
      </property>
-    </widget>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>10</height>
+      </size>
+     </property>
+    </spacer>
    </item>
    <item>
     <widget class="QComboBox" name="selectDefaultLayoutComboBox">
      <property name="editable">
       <bool>false</bool>
      </property>
      <property name="currentText">
       <string/>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QPushButton" name="saveLayoutPushButton">
        <property name="text">
         <string>Save layout</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="loadLayoutPushButton">
        <property name="text">
         <string>Load layout</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources/>
  <connections/>
 </ui>
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index 55c15a1c4e..ef255e9858 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,600 +1,650 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkMxNMultiWidget.h"
 
 // mitk core
 #include <mitkDisplayActionEventFunctions.h>
 #include <mitkDisplayActionEventHandlerDesynchronized.h>
 #include <mitkDisplayActionEventHandlerSynchronized.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateProperty.h>
 
 // mitk qt widget
 #include <QmitkRenderWindowUtilityWidget.h>
 #include <QmitkRenderWindowWidget.h>
 
 // qt
 #include <QGridLayout>
 #include <QMessageBox>
 #include <QSplitter>
 
 #include <fstream>
 
 QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          const QString& multiWidgetName/* = "mxn"*/)
   : QmitkAbstractMultiWidget(parent, f, multiWidgetName)
   , m_SynchronizedWidgetConnector(std::make_unique<QmitkSynchronizedWidgetConnector>())
   , m_CrosshairVisibility(false)
 {
 }
 
 QmitkMxNMultiWidget::~QmitkMxNMultiWidget()
 {
 }
 
 void QmitkMxNMultiWidget::InitializeMultiWidget()
 {
   SetLayout(1, 1);
   SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
   auto displayActionEventHandler = GetDisplayActionEventHandler();
   if (nullptr != displayActionEventHandler)
   {
     displayActionEventHandler->InitActions();
   }
 
   this->SetInitialSelection();
 }
 
 void QmitkMxNMultiWidget::Synchronize(bool synchronized)
 {
   if (synchronized)
   {
     SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerSynchronized>());
   }
   else
   {
     SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
   }
 
   auto displayActionEventHandler = GetDisplayActionEventHandler();
   if (nullptr != displayActionEventHandler)
   {
     displayActionEventHandler->InitActions();
   }
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   if ("axial" == widgetName || "sagittal" == widgetName || "coronal" == widgetName || "3d" == widgetName)
   {
     return GetActiveRenderWindowWidget()->GetRenderWindow();
   }
 
   return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const mitk::AnatomicalPlane& /*orientation*/) const
 {
   // currently no mapping between plane orientation and render windows
   // simply return the currently active render window
   return GetActiveRenderWindowWidget()->GetRenderWindow();
 }
 
 void QmitkMxNMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
 {
   auto currentActiveRenderWindowWidget = GetActiveRenderWindowWidget();
   if (currentActiveRenderWindowWidget == activeRenderWindowWidget)
   {
     return;
   }
 
   // reset the decoration color of the previously active render window widget
   if (nullptr != currentActiveRenderWindowWidget)
   {
     auto decorationColor = currentActiveRenderWindowWidget->GetDecorationColor();
     QColor hexColor(decorationColor[0] * 255, decorationColor[1] * 255, decorationColor[2] * 255);
     currentActiveRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid " +
                                                    hexColor.name(QColor::HexRgb) + "; }");
   }
 
   // set the new decoration color of the currently active render window widget
   if (nullptr != activeRenderWindowWidget)
   {
     activeRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid #FF6464; }");
   }
 
   QmitkAbstractMultiWidget::SetActiveRenderWindowWidget(activeRenderWindowWidget);
 }
 
 void QmitkMxNMultiWidget::InitializeViews(const mitk::TimeGeometry* geometry, bool resetCamera)
 {
   auto* renderingManager = mitk::RenderingManager::GetInstance();
   mitk::Point3D currentPosition = mitk::Point3D();
   unsigned int imageTimeStep = 0;
   if (!resetCamera)
   {
     // store the current position to set it again later, if the camera should not be reset
     currentPosition = this->GetSelectedPosition("");
 
     // store the current time step to set it again later, if the camera should not be reset
     const mitk::TimePointType currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
     if (geometry->IsValidTimePoint(currentTimePoint))
     {
       imageTimeStep = geometry->TimePointToTimeStep(currentTimePoint);
     }
   }
 
   // initialize active render window
   renderingManager->InitializeView(
     this->GetActiveRenderWindowWidget()->GetRenderWindow()->GetVtkRenderWindow(), geometry, resetCamera);
 
   if (!resetCamera)
   {
     this->SetSelectedPosition(currentPosition, "");
     renderingManager->GetTimeNavigationController()->GetStepper()->SetPos(imageTimeStep);
   }
 }
 
 void QmitkMxNMultiWidget::SetInteractionReferenceGeometry(const mitk::TimeGeometry* referenceGeometry)
 {
   // Set the interaction reference referenceGeometry for all render windows.
   auto allRenderWindows = this->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     auto* baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow());
     baseRenderer->SetInteractionReferenceGeometry(referenceGeometry);
   }
 }
 
 bool QmitkMxNMultiWidget::HasCoupledRenderWindows() const
 {
   return false;
 }
 
 void QmitkMxNMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget;
   if (widgetName.isNull() || widgetName.isEmpty())
   {
     renderWindowWidget = GetActiveRenderWindowWidget();
   }
   else
   {
     renderWindowWidget = GetRenderWindowWidget(widgetName);
   }
 
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
     return;
   }
 
   MITK_ERROR << "Position can not be set for an unknown render window widget.";
 }
 
 const mitk::Point3D QmitkMxNMultiWidget::GetSelectedPosition(const QString& widgetName) const
 {
   RenderWindowWidgetPointer renderWindowWidget;
   if (widgetName.isNull() || widgetName.isEmpty())
   {
     renderWindowWidget = GetActiveRenderWindowWidget();
   }
   else
   {
     renderWindowWidget = GetRenderWindowWidget(widgetName);
   }
 
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->GetCrosshairPosition();
   }
 
   MITK_ERROR << "Crosshair position can not be retrieved.";
   return mitk::Point3D(0.0);
 }
 
 void QmitkMxNMultiWidget::SetCrosshairVisibility(bool visible)
 {
   // get the specific render window that sent the signal
   QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
   if (nullptr == renderWindow)
   {
     return;
   }
 
   auto renderWindowWidget = this->GetRenderWindowWidget(renderWindow);
   renderWindowWidget->SetCrosshairVisibility(visible);
 }
 
 bool QmitkMxNMultiWidget::GetCrosshairVisibility() const
 {
   // get the specific render window that sent the signal
   QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
   if (nullptr == renderWindow)
   {
     return false;
   }
 
   auto renderWindowWidget = this->GetRenderWindowWidget(renderWindow);
   return renderWindowWidget->GetCrosshairVisibility();
 }
 
 void QmitkMxNMultiWidget::SetCrosshairGap(unsigned int gapSize)
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->SetCrosshairGap(gapSize);
   }
 }
 
 void QmitkMxNMultiWidget::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   // get the specific render window that sent the signal
   QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
   if (nullptr == renderWindow)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->InitializeViewByBoundingObjects(renderWindow->GetVtkRenderWindow(), 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;
   }
 }
 
 void QmitkMxNMultiWidget::EnableCrosshair()
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->EnableCrosshair();
   }
 }
 
 void QmitkMxNMultiWidget::DisableCrosshair()
 {
   auto renderWindowWidgets = this->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->DisableCrosshair();
   }
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PUBLIC SLOTS
 // MOUSE EVENTS
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkMxNMultiWidget::mousePressEvent(QMouseEvent*)
 {
   // nothing here, but necessary for mouse interactions (.xml-configuration files)
 }
 
 void QmitkMxNMultiWidget::moveEvent(QMoveEvent* e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the overlays as the MultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::SetLayoutImpl()
 {
   int requiredRenderWindowWidgets = GetRowCount() * GetColumnCount();
   int existingRenderWindowWidgets = GetRenderWindowWidgets().size();
 
   int difference = requiredRenderWindowWidgets - existingRenderWindowWidgets;
   while (0 < difference)
   {
     // more render window widgets needed
     CreateRenderWindowWidget();
     --difference;
   }
 
   while (0 > difference)
   {
     // less render window widgets needed
     RemoveRenderWindowWidget();
     ++difference;
   }
 
   auto firstRenderWindowWidget = GetFirstRenderWindowWidget();
   if (nullptr != firstRenderWindowWidget)
   {
     SetActiveRenderWindowWidget(firstRenderWindowWidget);
   }
 
   GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::CreateRenderWindowWidget()
 {
   // create the render window widget and connect signal / slot
   QString renderWindowWidgetName = GetNameFromIndex(GetNumberOfRenderWindowWidgets());
   RenderWindowWidgetPointer renderWindowWidget = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget);
 
   auto renderWindow = renderWindowWidget->GetRenderWindow();
 
   QmitkRenderWindowUtilityWidget* utilityWidget = new QmitkRenderWindowUtilityWidget(this, renderWindow, GetDataStorage());
   renderWindowWidget->AddUtilityWidget(utilityWidget);
 
   connect(utilityWidget, &QmitkRenderWindowUtilityWidget::SynchronizationToggled,
     this, &QmitkMxNMultiWidget::ToggleSynchronization);
   connect(this, &QmitkMxNMultiWidget::UpdateUtilityWidgetViewPlanes,
     utilityWidget, &QmitkRenderWindowUtilityWidget::UpdateViewPlaneSelection);
 
   // needs to be done after 'QmitkRenderWindowUtilityWidget::ToggleSynchronization' has been connected
   // initially synchronize the node selection widget
   utilityWidget->ToggleSynchronization(true);
 
   auto layoutManager = GetMultiWidgetLayoutManager();
   connect(renderWindow, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(renderWindow, &QmitkRenderWindow::ResetView, this, &QmitkMxNMultiWidget::ResetCrosshair);
   connect(renderWindow, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkMxNMultiWidget::SetCrosshairVisibility);
   connect(renderWindow, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkMxNMultiWidget::SetWidgetPlaneMode);
 
   return renderWindowWidget;
 }
 
+QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::GetWindowFromIndex(size_t index)
+{
+  if (index >= GetRenderWindowWidgets().size())
+  {
+    return nullptr;
+  }
+
+  auto renderWindowName = this->GetNameFromIndex(index);
+  auto renderWindowWidgets = GetRenderWindowWidgets();
+  auto it = renderWindowWidgets.find(renderWindowName);
+  if (it != renderWindowWidgets.end())
+  {
+    return it->second;
+  }
+  else
+  {
+    MITK_ERROR << "Could not find render window " << renderWindowName.toStdString() << ", although it should be there.";
+    return nullptr;
+  }
+}
+
 void QmitkMxNMultiWidget::LoadLayout(const nlohmann::json* jsonData)
 {
   if ((*jsonData).is_null())
   {
     QMessageBox::warning(this, "Load layout", "Could not read window layout");
     return;
   }
 
   unsigned int windowCounter = 0;
 
   try
   {
     auto version = jsonData->at("version").get<std::string>();
     if (version != "1.0")
     {
       QMessageBox::warning(this, "Load layout", "Unknown layout version, could not load");
       return;
     }
 
     delete this->layout();
     auto content = BuildLayoutFromJSON(jsonData, &windowCounter);
     auto hBoxLayout = new QHBoxLayout(this);
     this->setLayout(hBoxLayout);
     hBoxLayout->addWidget(content);
     emit UpdateUtilityWidgetViewPlanes();
   }
   catch (nlohmann::json::out_of_range& e)
   {
     MITK_ERROR << "Error in loading window layout from JSON: " << e.what();
     return;
   }
 
   while (GetNumberOfRenderWindowWidgets() > windowCounter)
   {
     RemoveRenderWindowWidget();
   }
 
   EnableCrosshair();
   emit LayoutChanged();
 }
 
 void QmitkMxNMultiWidget::SaveLayout(std::ostream* outStream)
 {
   if (outStream == nullptr)
   {
     return;
   }
 
   auto layout = this->layout();
   if (layout == nullptr)
     return;
 
   // There should only ever be one item: a splitter
   auto widget = layout->itemAt(0)->widget();
   auto splitter = dynamic_cast<QSplitter*>(widget);
   if (!splitter)
   {
     MITK_ERROR << "Tried to save unexpected layout format. Make sure the layout of this instance contains a single QSplitter.";
     return;
   }
 
   auto layoutJSON = BuildJSONFromLayout(splitter);
   layoutJSON["version"] = "1.0";
   layoutJSON["name"] = "Custom Layout";
 
   *outStream << std::setw(4) << layoutJSON << std::endl;
 
 }
 
 nlohmann::json QmitkMxNMultiWidget::BuildJSONFromLayout(const QSplitter* splitter)
 {
   nlohmann::json resultJSON;
   resultJSON["isWindow"] = false;
   resultJSON["vertical"] = (splitter->orientation() == Qt::Vertical) ? true : false;
   auto sizes = splitter->sizes();
 
   auto content = nlohmann::json::array();
 
   auto countSplitter = splitter->count();
   for (int i = 0; i < countSplitter; ++i)
   {
     auto widget = splitter->widget(i);
     nlohmann::json widgetJSON;
     if (auto widgetSplitter = dynamic_cast<QSplitter*>(widget); widgetSplitter)
     {
       widgetJSON = BuildJSONFromLayout(widgetSplitter);
     }
     else if (auto widgetWindow = dynamic_cast<QmitkRenderWindowWidget*>(widget); widgetWindow)
     {
       widgetJSON["isWindow"] = true;
       widgetJSON["viewDirection"] = widgetWindow->GetSliceNavigationController()->GetViewDirectionAsString();
     }
     widgetJSON["size"] = sizes[i];
     content.push_back(widgetJSON);
   }
   resultJSON["content"] = content;
   return resultJSON;
 }
 
 QSplitter* QmitkMxNMultiWidget::BuildLayoutFromJSON(const nlohmann::json* jsonData, unsigned int* windowCounter, QSplitter* parentSplitter)
 {
 
   bool vertical = jsonData->at("vertical").get<bool>();
   auto orientation = vertical ? Qt::Vertical : Qt::Horizontal;
 
   auto split = new QSplitter(orientation, parentSplitter);
   QList<int> sizes;
 
   for (auto object : jsonData->at("content"))
   {
     bool isWindow = object["isWindow"].get<bool>();
     int size = object["size"].get<int>();
     sizes.append(size);
 
     if (isWindow)
     {
       auto viewDirection = object["viewDirection"].get<std::string>();
       mitk::AnatomicalPlane viewPlane = mitk::AnatomicalPlane::Sagittal;
       if (viewDirection == "Axial")
       {
         viewPlane = mitk::AnatomicalPlane::Axial;
       }
       else if (viewDirection == "Coronal")
       {
         viewPlane = mitk::AnatomicalPlane::Coronal;
       }
       else if (viewDirection == "Original")
       {
         viewPlane = mitk::AnatomicalPlane::Original;
       }
       else if (viewDirection == "Sagittal")
       {
         viewPlane = mitk::AnatomicalPlane::Sagittal;
       }
 
-      QmitkAbstractMultiWidget::RenderWindowWidgetPointer window = nullptr;
-      QString renderWindowName;
-      QmitkAbstractMultiWidget::RenderWindowWidgetMap::iterator it;
-
       // repurpose existing render windows as far as they already exist
-      if (*windowCounter < GetRenderWindowWidgets().size())
-      {
-        renderWindowName = this->GetNameFromIndex(*windowCounter);
-        auto renderWindowWidgets = GetRenderWindowWidgets();
-        it = renderWindowWidgets.find(renderWindowName);
-        if (it != renderWindowWidgets.end())
-        {
-          window = it->second;
-        }
-        else
-        {
-          MITK_ERROR << "Could not find render window " << renderWindowName.toStdString() << ", although it should be there.";
-        }
-      }
-
+      auto window = GetWindowFromIndex(*windowCounter);
       if (window == nullptr)
       {
         window = CreateRenderWindowWidget();
       }
 
       window->GetSliceNavigationController()->SetDefaultViewDirection(viewPlane);
       window->GetSliceNavigationController()->Update();
       split->addWidget(window.get());
       window->show();
       (*windowCounter)++;
     }
     else
     {
       auto subSplitter = BuildLayoutFromJSON(&object, windowCounter, split);
       split->addWidget(subSplitter);
     }
   }
   split->setSizes(sizes);
 
   return split;
 
 }
 
+void QmitkMxNMultiWidget::SetDataBasedLayout(const QmitkAbstractNodeSelectionWidget::NodeList& nodes)
+{
+  auto vSplit = new QSplitter(Qt::Vertical);
+
+  unsigned int windowCounter = 0;
+  for (auto node : nodes)
+  {
+    auto hSplit = new QSplitter(Qt::Horizontal);
+    for (auto viewPlane : { mitk::AnatomicalPlane::Axial, mitk::AnatomicalPlane::Coronal, mitk::AnatomicalPlane::Sagittal })
+    {
+      // repurpose existing render windows as far as they already exist
+      auto window = GetWindowFromIndex(windowCounter++);
+      if (window == nullptr)
+      {
+        window = CreateRenderWindowWidget();
+      }
+
+      auto utilityWidget = window->GetUtilityWidget();
+      utilityWidget->ToggleSynchronization(false);
+      utilityWidget->SetDataSelection(QList({ node }));
+      window->GetSliceNavigationController()->SetDefaultViewDirection(viewPlane);
+      window->GetSliceNavigationController()->Update();
+      auto baseRenderer = mitk::BaseRenderer::GetInstance(window->GetRenderWindow()->GetVtkRenderWindow());
+      mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), node->GetData()->GetTimeGeometry());
+      hSplit->addWidget(window.get());
+      window->show();
+    }
+    auto sizes = QList<int>({1, 1, 1});
+    hSplit->setSizes(sizes);
+    vSplit->addWidget(hSplit);
+  }
+
+  delete this->layout();
+  auto hBoxLayout = new QHBoxLayout(this);
+  this->setLayout(hBoxLayout);
+  hBoxLayout->addWidget(vSplit);
+  emit UpdateUtilityWidgetViewPlanes();
+
+  while (GetNumberOfRenderWindowWidgets() > windowCounter)
+  {
+    RemoveRenderWindowWidget();
+  }
+
+  EnableCrosshair();
+  emit LayoutChanged();
+}
+
 void QmitkMxNMultiWidget::SetInitialSelection()
 {
   auto dataStorage = this->GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   mitk::NodePredicateAnd::Pointer noHelperObjects = mitk::NodePredicateAnd::New();
   noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
   auto allNodes = dataStorage->GetSubset(noHelperObjects);
   QmitkSynchronizedNodeSelectionWidget::NodeList currentSelection;
   for (auto& node : *allNodes)
   {
     currentSelection.append(node);
   }
 
   m_SynchronizedWidgetConnector->ChangeSelection(currentSelection);
 }
 
 void QmitkMxNMultiWidget::ToggleSynchronization(QmitkSynchronizedNodeSelectionWidget* synchronizedWidget)
 {
   bool synchronized = synchronizedWidget->IsSynchronized();
 
   if (synchronized)
   {
     m_SynchronizedWidgetConnector->ConnectWidget(synchronizedWidget);
     m_SynchronizedWidgetConnector->SynchronizeWidget(synchronizedWidget);
   }
   else
   {
     m_SynchronizedWidgetConnector->DisconnectWidget(synchronizedWidget);
   }
 }
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp
index 4934c397d3..47057d7442 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp
@@ -1,185 +1,190 @@
 /*============================================================================
 
 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 "QmitkRenderWindowUtilityWidget.h"
 
 #include <QWidgetAction>
 
 // mitk core
 #include <mitkDataStorage.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateProperty.h>
 
 // mitk qt widgets
 #include <QmitkRenderWindow.h>
 #include <QmitkStyleManager.h>
 
 // itk
 #include <itkSpatialOrientationAdapter.h>
 
 QmitkRenderWindowUtilityWidget::QmitkRenderWindowUtilityWidget(
   QWidget* parent/* = nullptr */,
   QmitkRenderWindow* renderWindow/* = nullptr */,
   mitk::DataStorage* dataStorage/* = nullptr */)
   : m_NodeSelectionWidget(nullptr)
   , m_SliceNavigationWidget(nullptr)
   , m_StepperAdapter(nullptr)
   , m_ViewDirectionSelector(nullptr)
 {
   this->setParent(parent);
   auto layout = new QHBoxLayout(this);
   layout->setContentsMargins({});
 
   mitk::NodePredicateAnd::Pointer noHelperObjects = mitk::NodePredicateAnd::New();
   noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
 
   m_BaseRenderer = mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow());
 
   m_NodeSelectionWidget = new QmitkSynchronizedNodeSelectionWidget(parent);
   m_NodeSelectionWidget->SetBaseRenderer(m_BaseRenderer);
   m_NodeSelectionWidget->SetDataStorage(dataStorage);
   m_NodeSelectionWidget->SetNodePredicate(noHelperObjects);
+  connect(this, &QmitkRenderWindowUtilityWidget::SetDataSelection, m_NodeSelectionWidget, &QmitkSynchronizedNodeSelectionWidget::SetSelection);
 
   auto menuBar = new QMenuBar(this);
   menuBar->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
   menuBar->setNativeMenuBar(false);
   auto dataMenu = menuBar->addMenu("Data");
   QWidgetAction* dataAction = new QWidgetAction(dataMenu);
   dataAction->setDefaultWidget(m_NodeSelectionWidget);
   dataMenu->addAction(dataAction);
   layout->addWidget(menuBar);
 
-  auto* synchPushButton = new QPushButton(this);
+  m_SynchPushButton = new QPushButton(this);
   auto* synchIcon = new QIcon();
   auto synchronizeSvg = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg"));
   auto desynchronizeSvg = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg"));
   synchIcon->addPixmap(synchronizeSvg.pixmap(64), QIcon::Normal, QIcon::On);
   synchIcon->addPixmap(desynchronizeSvg.pixmap(64), QIcon::Normal, QIcon::Off);
-  synchPushButton->setIcon(*synchIcon);
-  synchPushButton->setToolTip("Synchronize / desynchronize data management");
-  synchPushButton->setCheckable(true);
-  synchPushButton->setChecked(true);
-  connect(synchPushButton, &QPushButton::clicked,
+  m_SynchPushButton->setIcon(*synchIcon);
+  m_SynchPushButton->setToolTip("Synchronize / desynchronize data management");
+  m_SynchPushButton->setCheckable(true);
+  m_SynchPushButton->setChecked(true);
+  connect(m_SynchPushButton, &QPushButton::clicked,
     this, &QmitkRenderWindowUtilityWidget::ToggleSynchronization);
-  layout->addWidget(synchPushButton);
+  layout->addWidget(m_SynchPushButton);
 
   auto* sliceNavigationController = m_BaseRenderer->GetSliceNavigationController();
   m_SliceNavigationWidget = new QmitkSliceNavigationWidget(this);
   m_StepperAdapter =
     new QmitkStepperAdapter(m_SliceNavigationWidget, sliceNavigationController->GetStepper());
   layout->addWidget(m_SliceNavigationWidget);
 
   mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer{ m_BaseRenderer };
   m_RenderWindowViewDirectionController = std::make_unique<mitk::RenderWindowViewDirectionController>();
   m_RenderWindowViewDirectionController->SetControlledRenderer(controlledRenderer);
   m_RenderWindowViewDirectionController->SetDataStorage(dataStorage);
 
   m_ViewDirectionSelector = new QComboBox(this);
   QStringList viewDirections{ "axial", "coronal", "sagittal"};
   m_ViewDirectionSelector->insertItems(0, viewDirections);
   m_ViewDirectionSelector->setMinimumContentsLength(12);
   connect(m_ViewDirectionSelector, &QComboBox::currentTextChanged, this, &QmitkRenderWindowUtilityWidget::ChangeViewDirection);
   UpdateViewPlaneSelection();
 
   layout->addWidget(m_ViewDirectionSelector);
 
   // finally add observer, after all relevant objects have been created / initialized
   sliceNavigationController->ConnectGeometrySendEvent(this);
 }
 
 QmitkRenderWindowUtilityWidget::~QmitkRenderWindowUtilityWidget()
 {
 }
 
 void QmitkRenderWindowUtilityWidget::ToggleSynchronization(bool synchronized)
 {
+  if (m_SynchPushButton->isChecked() != synchronized)
+  {
+    m_SynchPushButton->setChecked(synchronized);
+  }
   m_NodeSelectionWidget->SetSynchronized(synchronized);
   emit SynchronizationToggled(m_NodeSelectionWidget);
 }
 
 void QmitkRenderWindowUtilityWidget::SetGeometry(const itk::EventObject& event)
 {
   if (!mitk::SliceNavigationController::GeometrySendEvent(nullptr, 0).CheckEvent(&event))
   {
     return;
   }
 
   const auto* sliceNavigationController = m_BaseRenderer->GetSliceNavigationController();
   auto viewDirection = sliceNavigationController->GetViewDirection();
   unsigned int axis = 0;
   switch (viewDirection)
   {
   case mitk::AnatomicalPlane::Original:
     return;
   case mitk::AnatomicalPlane::Axial:
   {
     axis = 2;
     break;
   }
   case mitk::AnatomicalPlane::Coronal:
   {
     axis = 1;
     break;
   }
   case mitk::AnatomicalPlane::Sagittal:
   {
     axis = 0;
     break;
   }
   }
 
   const auto* inputTimeGeometry = sliceNavigationController->GetInputWorldTimeGeometry();
   const mitk::BaseGeometry* rendererGeometry = m_BaseRenderer->GetCurrentWorldGeometry();
 
   mitk::TimeStepType timeStep = sliceNavigationController->GetStepper()->GetPos();
   mitk::BaseGeometry::ConstPointer geometry = inputTimeGeometry->GetGeometryForTimeStep(timeStep);
   if (geometry == nullptr)
     return;
 
   mitk::AffineTransform3D::MatrixType matrix = geometry->GetIndexToWorldTransform()->GetMatrix();
   matrix.GetVnlMatrix().normalize_columns();
   mitk::AffineTransform3D::MatrixType::InternalMatrixType inverseMatrix = matrix.GetInverse();
 
   int dominantAxis = itk::Function::Max3(inverseMatrix[0][axis], inverseMatrix[1][axis], inverseMatrix[2][axis]);
 
   bool referenceGeometryAxisInverted = inverseMatrix[dominantAxis][axis] < 0;
   bool rendererZAxisInverted = rendererGeometry->GetAxisVector(2)[axis] < 0;
 
   m_SliceNavigationWidget->SetInverseDirection(referenceGeometryAxisInverted != rendererZAxisInverted);
 }
 
 void QmitkRenderWindowUtilityWidget::ChangeViewDirection(const QString& viewDirection)
 {
   m_RenderWindowViewDirectionController->SetViewDirectionOfRenderer(viewDirection.toStdString());
 }
 
 void QmitkRenderWindowUtilityWidget::UpdateViewPlaneSelection()
 {
   const auto sliceNavigationController = m_BaseRenderer->GetSliceNavigationController();
   const auto viewDirection = sliceNavigationController->GetDefaultViewDirection();
   switch (viewDirection)
   {
   case mitk::AnatomicalPlane::Axial:
     m_ViewDirectionSelector->setCurrentIndex(0);
     break;
   case mitk::AnatomicalPlane::Coronal:
     m_ViewDirectionSelector->setCurrentIndex(1);
     break;
   case mitk::AnatomicalPlane::Sagittal:
     m_ViewDirectionSelector->setCurrentIndex(2);
     break;
   default:
     break;
   }
 }
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
index 8c7d54c727..730adb3ea7 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
@@ -1,322 +1,333 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkRenderWindowWidget.h"
 
 // vtk
 #include <vtkCornerAnnotation.h>
 #include <vtkTextProperty.h>
 
 QmitkRenderWindowWidget::QmitkRenderWindowWidget(QWidget* parent/* = nullptr*/,
                                                  const QString& widgetName/* = ""*/,
                                                  mitk::DataStorage* dataStorage/* = nullptr*/)
   : QFrame(parent)
   , m_WidgetName(widgetName)
   , m_DataStorage(dataStorage)
   , m_RenderWindow(nullptr)
   , m_CrosshairManager(nullptr)
 {
   this->InitializeGUI();
 }
 
 QmitkRenderWindowWidget::~QmitkRenderWindowWidget()
 {
   auto sliceNavigationController = this->GetSliceNavigationController();
   if (nullptr != sliceNavigationController)
   {
     sliceNavigationController->SetCrosshairEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkRenderWindowWidget, const mitk::Point3D &>(
         this, &QmitkRenderWindowWidget::SetCrosshairPosition));
   }
   this->DisableCrosshair();
 }
 
 void QmitkRenderWindowWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (dataStorage == m_DataStorage)
   {
     return;
   }
 
   m_DataStorage = dataStorage;
   if (nullptr != m_RenderWindow)
   {
     mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow())->SetDataStorage(dataStorage);
   }
 }
 
 mitk::SliceNavigationController* QmitkRenderWindowWidget::GetSliceNavigationController() const
 {
   return m_RenderWindow->GetSliceNavigationController();
 }
 
 void QmitkRenderWindowWidget::RequestUpdate()
 {
   mitk::RenderingManager::GetInstance()->RequestUpdate(m_RenderWindow->renderWindow());
 }
 
 void QmitkRenderWindowWidget::ForceImmediateUpdate()
 {
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(m_RenderWindow->renderWindow());
 }
 
 void QmitkRenderWindowWidget::AddUtilityWidget(QWidget* utilityWidget)
 {
   m_Layout->insertWidget(0, utilityWidget);
 }
 
+QmitkRenderWindowUtilityWidget* QmitkRenderWindowWidget::GetUtilityWidget()
+{
+  auto layoutItem = m_Layout->itemAt(0)->widget();
+  auto utilityWidget = dynamic_cast<QmitkRenderWindowUtilityWidget*>(layoutItem);
+  if (utilityWidget != nullptr)
+  {
+    return utilityWidget;
+  }
+  return nullptr;
+}
+
 void QmitkRenderWindowWidget::SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower)
 {
   vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
   if (nullptr == vtkRenderer)
   {
     return;
   }
 
   m_GradientBackgroundColors.first = upper;
   m_GradientBackgroundColors.second = lower;
   vtkRenderer->SetBackground(lower[0], lower[1], lower[2]);
   vtkRenderer->SetBackground2(upper[0], upper[1], upper[2]);
 
   ShowGradientBackground(true);
 }
 
 void QmitkRenderWindowWidget::ShowGradientBackground(bool show)
 {
   m_RenderWindow->GetRenderer()->GetVtkRenderer()->SetGradientBackground(show);
 }
 
 bool QmitkRenderWindowWidget::IsGradientBackgroundOn() const
 {
   return m_RenderWindow->GetRenderer()->GetVtkRenderer()->GetGradientBackground();
 }
 
 void QmitkRenderWindowWidget::SetDecorationColor(const mitk::Color& color)
 {
   m_DecorationColor = color;
   m_CornerAnnotation->GetTextProperty()->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
 
   QColor hexColor(m_DecorationColor[0] * 255, m_DecorationColor[1] * 255, m_DecorationColor[2] * 255);
   setStyleSheet("QmitkRenderWindowWidget { border: 2px solid " + hexColor.name(QColor::HexRgb) + "; }");
 }
 
 void QmitkRenderWindowWidget::ShowColoredRectangle(bool show)
 {
   if (show)
   {
     setFrameStyle(QFrame::Box | QFrame::Plain);
   }
   else
   {
     setFrameStyle(NoFrame);
   }
 }
 
 bool QmitkRenderWindowWidget::IsColoredRectangleVisible() const
 {
   return frameStyle() > 0;
 }
 
 void QmitkRenderWindowWidget::ShowCornerAnnotation(bool show)
 {
   m_CornerAnnotation->SetVisibility(show);
 }
 
 bool QmitkRenderWindowWidget::IsCornerAnnotationVisible() const
 {
   return m_CornerAnnotation->GetVisibility() > 0;
 }
 
 void QmitkRenderWindowWidget::SetCornerAnnotationText(const std::string& cornerAnnotation)
 {
   m_CornerAnnotation->SetText(0, cornerAnnotation.c_str());
 }
 
 std::string QmitkRenderWindowWidget::GetCornerAnnotationText() const
 {
   return std::string(m_CornerAnnotation->GetText(0));
 }
 
 bool QmitkRenderWindowWidget::IsRenderWindowMenuActivated() const
 {
   return m_RenderWindow->GetActivateMenuWidgetFlag();
 }
 
 void QmitkRenderWindowWidget::SetCrosshairVisibility(bool visible)
 {
   m_CrosshairManager->SetCrosshairVisibility(visible, m_RenderWindow->GetRenderer());
   this->RequestUpdate();
 }
 
 bool QmitkRenderWindowWidget::GetCrosshairVisibility()
 {
   return m_CrosshairManager->GetCrosshairVisibility(m_RenderWindow->GetRenderer());
 }
 
 void QmitkRenderWindowWidget::SetCrosshairGap(unsigned int gapSize)
 {
   m_CrosshairManager->SetCrosshairGap(gapSize);
 }
 
 void QmitkRenderWindowWidget::EnableCrosshair()
 {
   m_CrosshairManager->AddCrosshairNodeToDataStorage(m_DataStorage);
 }
 
 void QmitkRenderWindowWidget::DisableCrosshair()
 {
   m_CrosshairManager->RemoveCrosshairNodeFromDataStorage(m_DataStorage);
 }
 
 void QmitkRenderWindowWidget::InitializeGUI()
 {
   m_Layout = new QVBoxLayout(this);
   m_Layout->setContentsMargins({});
   setLayout(m_Layout);
   setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   setContentsMargins(0, 0, 0, 0);
 
   if (nullptr == m_DataStorage)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->SetDataStorage(m_DataStorage);
 
   // create render window for this render window widget
   m_RenderWindow = new QmitkRenderWindow(this, m_WidgetName, nullptr);
   m_RenderWindow->SetLayoutIndex(mitk::AnatomicalPlane::Sagittal);
   connect(m_RenderWindow, &QmitkRenderWindow::ResetGeometry,
     this, &QmitkRenderWindowWidget::OnResetGeometry);
 
   auto* sliceNavigationController = this->GetSliceNavigationController();
   sliceNavigationController->SetDefaultViewDirection(mitk::AnatomicalPlane::Sagittal);
 
   m_Layout->addWidget(m_RenderWindow);
 
   // set colors and corner annotation
   InitializeDecorations();
 
   // use crosshair manager
   m_CrosshairManager = mitk::CrosshairManager::New(m_RenderWindow->GetRenderer());
   sliceNavigationController->SetCrosshairEvent.AddListener(
     mitk::MessageDelegate1<QmitkRenderWindowWidget, const mitk::Point3D &>(
       this, &QmitkRenderWindowWidget::SetCrosshairPosition));
 
   // finally add observer, after all relevant objects have been created / initialized
   sliceNavigationController->ConnectGeometrySendEvent(this);
   sliceNavigationController->ConnectGeometrySliceEvent(this);
 
   mitk::TimeGeometry::ConstPointer timeGeometry = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeView(m_RenderWindow->GetVtkRenderWindow(), timeGeometry);
 }
 
 void QmitkRenderWindowWidget::InitializeDecorations()
 {
   vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
   if (nullptr == vtkRenderer)
   {
     return;
   }
 
   // initialize background color gradients
   float black[3] = { 0.0f, 0.0f, 0.0f };
   SetGradientBackgroundColors(black, black);
 
   // initialize annotation text and decoration color
   setFrameStyle(QFrame::Box | QFrame::Plain);
 
   m_CornerAnnotation = vtkSmartPointer<vtkCornerAnnotation>::New();
   m_CornerAnnotation->SetText(0, "Sagittal");
   m_CornerAnnotation->SetMaximumFontSize(12);
   if (0 == vtkRenderer->HasViewProp(m_CornerAnnotation))
   {
     vtkRenderer->AddViewProp(m_CornerAnnotation);
   }
 
   float white[3] = { 1.0f, 1.0f, 1.0f };
   SetDecorationColor(mitk::Color(white));
 }
 
 void QmitkRenderWindowWidget::SetCrosshairPosition(const mitk::Point3D& newPosition)
 {
   m_CrosshairManager->SetCrosshairPosition(newPosition);
   this->RequestUpdate();
 }
 
 mitk::Point3D QmitkRenderWindowWidget::GetCrosshairPosition() const
 {
   return m_CrosshairManager->GetCrosshairPosition();
 }
 
 void QmitkRenderWindowWidget::SetGeometry(const itk::EventObject& event)
 {
   if (!mitk::SliceNavigationController::GeometrySendEvent(nullptr, 0).CheckEvent(&event))
   {
     return;
   }
 
   const auto* planeGeometry = this->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   if (nullptr == planeGeometry)
   {
     mitkThrow() << "No valid plane geometry set. Render window is in an invalid state.";
   }
 
   return SetCrosshairPosition(planeGeometry->GetCenter());
 }
 
 void QmitkRenderWindowWidget::SetGeometrySlice(const itk::EventObject& event)
 {
   if (!mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0).CheckEvent(&event))
   {
     return;
   }
 
   const auto* sliceNavigationController = this->GetSliceNavigationController();
   m_CrosshairManager->UpdateCrosshairPosition(sliceNavigationController);
 }
 
 void QmitkRenderWindowWidget::OnResetGeometry()
 {
   const auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow());
   const auto* interactionReferenceGeometry = baseRenderer->GetInteractionReferenceGeometry();
   this->ResetGeometry(interactionReferenceGeometry);
   m_RenderWindow->ShowOverlayMessage(false);
 }
 
 void QmitkRenderWindowWidget::ResetGeometry(const mitk::TimeGeometry* referenceGeometry)
 {
   if (nullptr == referenceGeometry)
   {
     return;
   }
 
   mitk::TimeStepType imageTimeStep = 0;
 
   // store the current position to set it again later, if the camera should not be reset
   mitk::Point3D currentPosition = this->GetCrosshairPosition();
 
   // store the current time step to set it again later, if the camera should not be reset
   auto* renderingManager = mitk::RenderingManager::GetInstance();
   const mitk::TimePointType currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
   if (referenceGeometry->IsValidTimePoint(currentTimePoint))
   {
     imageTimeStep = referenceGeometry->TimePointToTimeStep(currentTimePoint);
   }
 
   const auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow());
   renderingManager->InitializeView(baseRenderer->GetRenderWindow(), referenceGeometry, false);
 
   // reset position and time step
   this->GetSliceNavigationController()->SelectSliceByPoint(currentPosition);
   renderingManager->GetTimeNavigationController()->GetStepper()->SetPos(imageTimeStep);
 }
diff --git a/Modules/QtWidgets/src/QmitkSynchronizedNodeSelectionWidget.cpp b/Modules/QtWidgets/src/QmitkSynchronizedNodeSelectionWidget.cpp
index aae35e9ac6..f1d8bbbc7a 100644
--- a/Modules/QtWidgets/src/QmitkSynchronizedNodeSelectionWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkSynchronizedNodeSelectionWidget.cpp
@@ -1,709 +1,708 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 // mitk qt widgets module
 #include <QmitkSynchronizedNodeSelectionWidget.h>
 #include <QmitkCustomVariants.h>
 #include <QmitkEnums.h>
 #include <QmitkNodeSelectionDialog.h>
 
 // mitk core module
 #include <mitkImage.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkRenderWindowLayerUtilities.h>
 
 QmitkSynchronizedNodeSelectionWidget::QmitkSynchronizedNodeSelectionWidget(QWidget* parent)
   : QmitkAbstractNodeSelectionWidget(parent)
 {
   m_Controls.setupUi(this);
 
   m_StorageModel = std::make_unique<QmitkRenderWindowDataNodeTableModel>(this);
 
   m_Controls.tableView->setModel(m_StorageModel.get());
   m_Controls.tableView->horizontalHeader()->setVisible(false);
   m_Controls.tableView->verticalHeader()->setVisible(false);
   m_Controls.tableView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.tableView->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_Controls.tableView->setContextMenuPolicy(Qt::CustomContextMenu);
+  m_Controls.tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+  m_Controls.tableView->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
 
   this->SetUpConnections();
   this->Initialize();
 }
 
 QmitkSynchronizedNodeSelectionWidget::~QmitkSynchronizedNodeSelectionWidget()
 {
   bool isSynchronized = this->IsSynchronized();
   if (isSynchronized)
   {
     emit DeregisterSynchronization();
     return;
   }
 
   auto baseRenderer = m_BaseRenderer.Lock();
   if (baseRenderer.IsNull())
   {
     return;
   }
 
   auto dataStorage = m_DataStorage.Lock();
   if (dataStorage.IsNull())
   {
     return;
   }
 
   // If the model is not synchronized,
   // we know that renderer-specific properties exist for all nodes.
   // These properties need to be removed from the nodes.
   auto allNodes = dataStorage->GetAll();
   for (auto& node : *allNodes)
   {
     // Delete the relevant renderer-specific properties for the node using the current base renderer.
     mitk::RenderWindowLayerUtilities::DeleteRenderWindowProperties(node, baseRenderer);
   }
 }
 
 void QmitkSynchronizedNodeSelectionWidget::SetBaseRenderer(mitk::BaseRenderer* baseRenderer)
 {
   if (m_BaseRenderer == baseRenderer)
   {
     // no need to do something
     return;
   }
 
   if (nullptr == baseRenderer)
   {
     return;
   }
 
   auto oldBaseRenderer = m_BaseRenderer.Lock();
   m_BaseRenderer = baseRenderer;
 
   auto dataStorage = m_DataStorage.Lock();
   if (dataStorage.IsNull())
   {
     return;
   }
 
   bool isSynchronized = this->IsSynchronized();
   if (isSynchronized)
   {
     // If the model is synchronized,
     // all nodes use global / default properties.
     // No renderer-specific property lists should exist
     // so there is no need to transfer any property values.
   }
   else
   {
     // If the model is not synchronized,
     // we know that renderer-specific properties exist for all nodes.
     // These properties need to be removed from the nodes and
     // we need to transfer their values to new renderer-specific properties.
     auto allNodes = dataStorage->GetAll();
     for (auto& node : *allNodes)
     {
       // Set the relevant renderer-specific properties for the node using the new base renderer.
       // By transferring the values from the old property list,
       // the same property-state is kept when switching to another base renderer.
       mitk::RenderWindowLayerUtilities::TransferRenderWindowProperties(node, baseRenderer, oldBaseRenderer);
       // Delete the relevant renderer-specific properties for the node using the old base renderer.
       mitk::RenderWindowLayerUtilities::DeleteRenderWindowProperties(node, oldBaseRenderer);
     }
   }
 
   this->Initialize();
 }
 
 void QmitkSynchronizedNodeSelectionWidget::SetSelectAll(bool selectAll)
 {
   if (selectAll == m_Controls.selectionModeCheckBox->isChecked())
   {
     // no need to do something
     return;
   }
 
   m_Controls.selectionModeCheckBox->setChecked(selectAll);
 }
 
 bool QmitkSynchronizedNodeSelectionWidget::GetSelectAll() const
 {
   return m_Controls.selectionModeCheckBox->isChecked();
 }
 
 void QmitkSynchronizedNodeSelectionWidget::SetSynchronized(bool synchronize)
 {
   if (synchronize == this->IsSynchronized())
   {
     // no need to do something
     return;
   }
 
   auto baseRenderer = m_BaseRenderer.Lock();
   if (baseRenderer.IsNull())
   {
     return;
   }
 
   auto dataStorage = m_DataStorage.Lock();
   if (dataStorage.IsNull())
   {
     return;
   }
 
   if (synchronize)
   {
     // set the base renderer of the model to nullptr, such that global properties are used
     m_StorageModel->SetCurrentRenderer(nullptr);
 
     // If the model is synchronized,
     // we know that the model was not synchronized before.
     // That means that all nodes use renderer-specific properties,
     // but now all nodes need global properties.
     // Thus we need to remove the renderer-specific properties of all nodes of the
     // datastorage.
     auto allNodes = dataStorage->GetAll();
     for (auto& node : *allNodes)
     {
       // For helper / hidden nodes:
       // If the node predicate does not match, do not remove the renderer-specific property
       // This is relevant for the crosshair data nodes, which are only visible inside their
       // corresponding render window.
       if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node))
       {
         // Delete the relevant renderer-specific properties for the node using the current base renderer.
         mitk::RenderWindowLayerUtilities::DeleteRenderWindowProperties(node, baseRenderer);
       }
     }
   }
   else
   {
     // set the base renderer of the model to current base renderer, such that renderer-specific properties are used
     m_StorageModel->SetCurrentRenderer(baseRenderer);
 
     // If the model is not synchronized anymore,
     // we know that the model was synchronized before.
     // That means that all nodes use global / default properties,
     // but now all nodes need renderer-specific properties.
     // Thus we need to modify the renderer-specific properties of all nodes of the
     // datastorage:
     //  - hide those nodes, which are not part of the newly selected nodes.
     //  - keep the property values of those nodes, which are part of the new selection AND
     //    have been selected before
     auto currentNodeSelection = this->GetCurrentInternalSelection();
     auto allNodes = dataStorage->GetAll();
     for (auto& node : *allNodes)
     {
       // check if the node is part of the current selection
       auto finding = std::find(std::begin(currentNodeSelection), std::end(currentNodeSelection), node);
       if (finding != std::end(currentNodeSelection)) // node found / part of the current selection
       {
         // Set the relevant renderer-specific properties for the node using the curent base renderer.
         // By transferring the values from the global / default property list,
         // the same property-state is kept when switching to non-synchronized mode.
         mitk::RenderWindowLayerUtilities::TransferRenderWindowProperties(node, baseRenderer, nullptr);
       }
       else
       {
         // If the node is not part of the selection, unset the relevant renderer-specific properties.
         // This will unset the "visible" and "layer" property for the renderer-specific property list and
         // hide the node for this renderer.
         // ATTENTION: This is required, since the synchronized property needs to be overwritten
         //            to make sure that the visibility is correctly set for the specific base renderer.
         this->DeselectNode(node);
       }
     }
   }
 
   // Since the synchronization might lead to a different node order depending on the layer properties, the render window
   // needs to be updated.
   // Explicitly request an update since a renderer-specific property change does not mark the node as modified.
   // see https://phabricator.mitk.org/T22322
   mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
 }
 
 bool QmitkSynchronizedNodeSelectionWidget::IsSynchronized() const
 {
   return m_StorageModel->GetCurrentRenderer().IsNull();
 }
 
-void QmitkSynchronizedNodeSelectionWidget::OnModelUpdated()
-{
-  m_Controls.tableView->resizeRowsToContents();
-  m_Controls.tableView->resizeColumnsToContents();
-}
-
 void QmitkSynchronizedNodeSelectionWidget::OnSelectionModeChanged(bool selectAll)
 {
   emit SelectionModeChanged(selectAll);
 
   if (selectAll)
   {
     this->SelectAll();
   }
 }
 
 void QmitkSynchronizedNodeSelectionWidget::OnEditSelection()
 {
   QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(this);
 
   dialog->SetDataStorage(m_DataStorage.Lock());
   dialog->SetNodePredicate(m_NodePredicate);
   dialog->SetCurrentSelection(m_StorageModel->GetCurrentSelection());
   dialog->SetSelectionMode(QAbstractItemView::MultiSelection);
 
   m_Controls.changeSelectionButton->setChecked(true);
   if (dialog->exec())
   {
     m_Controls.selectionModeCheckBox->setChecked(false);
     emit SelectionModeChanged(false);
 
     auto selectedNodes = dialog->GetSelectedNodes();
     this->HandleChangeOfInternalSelection(selectedNodes);
   }
 
   m_Controls.changeSelectionButton->setChecked(false);
 
   delete dialog;
 }
 
 void QmitkSynchronizedNodeSelectionWidget::OnTableClicked(const QModelIndex& index)
 {
   if (!index.isValid() || m_StorageModel.get() != index.model())
   {
     return;
   }
 
   auto baseRenderer = m_BaseRenderer.Lock();
   if (baseRenderer.IsNull())
   {
     return;
   }
 
   QVariant dataNodeVariant = index.data(QmitkDataNodeRole);
   auto dataNode = dataNodeVariant.value<mitk::DataNode::Pointer>();
 
   if (index.column() == 1) // node visibility column
   {
     bool visibiliy = index.data(Qt::EditRole).toBool();
     m_StorageModel->setData(index, QVariant(!visibiliy), Qt::EditRole);
     return;
   }
 
   if (index.column() == 2) // reinit node column
   {
     this->ReinitNode(dataNode);
     return;
   }
 
   if (index.column() == 3) // remove node column
   {
     this->RemoveFromInternalSelection(dataNode);
     return;
   }
 }
 
 void QmitkSynchronizedNodeSelectionWidget::SetUpConnections()
 {
-  connect(m_StorageModel.get(), &QmitkRenderWindowDataNodeTableModel::ModelUpdated,
-    this, &QmitkSynchronizedNodeSelectionWidget::OnModelUpdated);
-  
   connect(m_Controls.selectionModeCheckBox, &QCheckBox::clicked,
     this, &QmitkSynchronizedNodeSelectionWidget::OnSelectionModeChanged);
   connect(m_Controls.changeSelectionButton, &QPushButton::clicked,
     this, &QmitkSynchronizedNodeSelectionWidget::OnEditSelection);
 
   connect(m_Controls.tableView, &QTableView::clicked,
     this, &QmitkSynchronizedNodeSelectionWidget::OnTableClicked);
 }
 
+void QmitkSynchronizedNodeSelectionWidget::SetSelection(const NodeList& newSelection)
+{
+  this->HandleChangeOfInternalSelection(newSelection);
+  m_Controls.selectionModeCheckBox->setChecked(false);
+}
+
 void QmitkSynchronizedNodeSelectionWidget::Initialize()
 {
   auto baseRenderer = m_BaseRenderer.Lock();
   auto dataStorage = m_DataStorage.Lock();
   m_StorageModel->SetDataStorage(dataStorage);
   m_StorageModel->SetCurrentRenderer(baseRenderer);
 
   if (baseRenderer.IsNull() || dataStorage.IsNull())
   {
     m_Controls.selectionModeCheckBox->setEnabled(false);
     m_Controls.changeSelectionButton->setEnabled(false);
     // reset the model if no data storage is defined
     m_StorageModel->removeRows(0, m_StorageModel->rowCount());
     return;
   }
 
   // Use the new data storage / node predicate to correctly set the list of
   // currently selected data nodes for the model.
   // If a new data storage or node predicate has been defined,
   // we switch to the "selectAll" mode and synchronize the selection for simplicity.
   // enable UI
   m_Controls.selectionModeCheckBox->setEnabled(true);
   m_Controls.changeSelectionButton->setEnabled(true);
 
   m_Controls.selectionModeCheckBox->setChecked(true);
 
   // set the base renderer of the model to nullptr, such that global properties are used (synchronized mode)
   m_StorageModel->SetCurrentRenderer(nullptr);
 }
 
 void QmitkSynchronizedNodeSelectionWidget::UpdateInfo()
 {
 
 }
 
 void QmitkSynchronizedNodeSelectionWidget::OnDataStorageChanged()
 {
   this->Initialize();
 }
 
 void QmitkSynchronizedNodeSelectionWidget::OnNodePredicateChanged()
 {
   this->Initialize();
 }
 
 void QmitkSynchronizedNodeSelectionWidget::ReviseSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection)
 {
   auto baseRenderer = m_BaseRenderer.Lock();
   if (baseRenderer.IsNull())
   {
     return;
   }
 
   bool isSynchronized = this->IsSynchronized();
   if (isSynchronized)
   {
     this->ReviseSynchronizedSelectionChanged(oldInternalSelection, newInternalSelection);
   }
   else
   {
     this->ReviseDesynchronizedSelectionChanged(oldInternalSelection, newInternalSelection);
   }
 
   // Since a new selection might have a different rendering tree the render windows
   // need to be updated.
   // Explicitly request an update since a renderer-specific property change does not mark the node as modified.
   // see https://phabricator.mitk.org/T22322
   mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
 }
 
 void QmitkSynchronizedNodeSelectionWidget::OnInternalSelectionChanged()
 {
   m_StorageModel->SetCurrentSelection(this->GetCurrentInternalSelection());
 }
 
 bool QmitkSynchronizedNodeSelectionWidget::AllowEmissionOfSelection(const NodeList& /*emissionCandidates*/) const
 {
   return this->IsSynchronized();
 }
 
 void QmitkSynchronizedNodeSelectionWidget::OnNodeAddedToStorage(const mitk::DataNode* node)
 {
   auto baseRenderer = m_BaseRenderer.Lock();
   if (baseRenderer.IsNull())
   {
     return;
   }
 
   // For helper / hidden nodes
   if (m_NodePredicate.IsNotNull() && !m_NodePredicate->CheckNode(node))
   {
     // If the node predicate does not match, do not add the node to the current selection.
     // Leave the visibility as it is.
     return;
   }
 
   // The selection mode determines if we want to show all nodes from the data storage
   // or use a local selected list of nodes.
   // We need to hide each new incoming data node, if we use a local selection,
   // since we do not want to show / select newly added nodes immediately.
   // We need to add the incoming node to our selection, if the selection mode check box
   // is checked.
   // We want to add the incoming node to our selection, if the node is a child node
   // of an already selected node.
   // Nodes added to the selection will be made visible.
   if (m_Controls.selectionModeCheckBox->isChecked() || this->IsParentNodeSelected(node))
   {
     auto currentSelection = this->GetCurrentInternalSelection();
     // Check if the nodes is already part of the internal selection.
     // That can happen if another render window already added the new node and sent out the new, updated
     // selection to be synchronized.
     auto finding = std::find(std::begin(currentSelection), std::end(currentSelection), node);
     if (finding != std::end(currentSelection)) // node found
     {
       // node already part of the selection
       return;
     }
 
     currentSelection.append(const_cast<mitk::DataNode*>(node));
     // This function will call 'QmitkSynchronizedNodeSelectionWidget::ReviseSelectionChanged'
     // which will take care of the visibility-property for newly added node.
     this->HandleChangeOfInternalSelection(currentSelection);
   }
   else
   {
     // If the widget is in "local-selection" state (selectionModeCheckBox unchecked),
     // the new incoming node needs to be hid.
     // Here it depends on the synchronization-state which properties need
     // to be modified.
     if (this->IsSynchronized())
     {
       // If the node will not be part of the new selection, hide the node.
       const_cast<mitk::DataNode*>(node)->SetVisibility(false);
     }
     else
     {
       // If the widget is not synchronized, all nodes use renderer-specific properties.
       // Thus we need to modify the renderer-specific properties of the node:
       //  - hide the node, which is not part of the selection
       this->DeselectNode(const_cast<mitk::DataNode*>(node));
     }
   }
 }
 
 void QmitkSynchronizedNodeSelectionWidget::OnNodeModified(const itk::Object* caller, const itk::EventObject& event)
 {
   auto baseRenderer = m_BaseRenderer.Lock();
   if (baseRenderer.IsNull())
   {
     return;
   }
 
   if (!itk::ModifiedEvent().CheckEvent(&event))
   {
     return;
   }
 
   auto node = dynamic_cast<const mitk::DataNode*>(caller);
 
   if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node))
   {
     auto currentSelection = this->GetCurrentInternalSelection();
     // check if the node to be modified is part of the current selection
     auto finding = std::find(std::begin(currentSelection), std::end(currentSelection), node);
     if (finding == std::end(currentSelection)) // node not found
     {
       // node not part of the selection
       return;
     }
     
     // We know that the node is relevant, but we don't know if the node modification was relevant
     // for the rendering. We just request an update here.
     // Explicitly request an update since a renderer-specific property change does not mark the node as modified.
     // see https://phabricator.mitk.org/T22322
     mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
     m_StorageModel->UpdateModelData();
   }
 }
 
 void QmitkSynchronizedNodeSelectionWidget::ReviseSynchronizedSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection)
 {
   // If the model is synchronized, all nodes use global / default properties.
   // Thus we need to modify the global properties of the selection:
   //  - a) show those nodes, which are part of the new selection AND have not been
   //       selected before
   //  - b) keep the property values of those nodes, which are part of the new selection AND
   //       have been selected before
   //  - c) hide those nodes, which are part of the old selection AND
   //       have not been newly selected
   for (auto& node : newInternalSelection)
   {
     // check if the node is part of the old selection
     auto finding = std::find(std::begin(oldInternalSelection), std::end(oldInternalSelection), node);
     if (finding == std::end(oldInternalSelection)) // node not found
     {
       // If the node is part of the new selection and was not already part of the old selection,
       // set the relevant renderer-specific properties.
       // This will set the "visible" property for the global / default property list
       // and show the node for this renderer.
       node->SetVisibility(true); // item a)
     }
     // else: item b): node that was already selected before does not need to be modified
   }
 
   for (auto& node : oldInternalSelection)
   {
     // check if the node is part of the new selection
     auto finding = std::find(std::begin(newInternalSelection), std::end(newInternalSelection), node);
     if (finding == std::end(newInternalSelection)) // node not found
     {
       // If the node is not part of the new selection, hide the node.
       node->SetVisibility(false); // item c)
     }
     // else: item b): node that was already selected before does not need to be modified
   }
 }
 
 void QmitkSynchronizedNodeSelectionWidget::ReviseDesynchronizedSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection)
 {
   auto baseRenderer = m_BaseRenderer.Lock();
   if (baseRenderer.IsNull())
   {
     return;
   }
 
   // If the model is not synchronized, all nodes need renderer-specific properties.
   // Thus we need to modify the renderer-specific properties of the selection:
   //  - a) set the renderer-specific properties of those nodes, which are part of the new selection AND
   //       have not been selected before (see 'SelectNode')
   //  - b) show those nodes, which are part of the new selection AND have not been
   //       selected before
   //  - c) keep the property values of those nodes, which are part of the new selection AND
   //       have been selected before
   //  - d) hide those nodes, which are part of the old selection AND
   //       have not been newly selected
   //  - e) set the renderer-specific properties of those nodes, which are part of the old selection AND
   //       have not been newly selected, to denote which nodes are selected
   for (auto& node : newInternalSelection)
   {
     // check if the node is part of the old selection
     auto finding = std::find(std::begin(oldInternalSelection), std::end(oldInternalSelection), node);
     if (finding == std::end(oldInternalSelection)) // node not found
     {
       // If the node is part of the new selection and was not already part of the old selection,
       // set the relevant renderer-specific properties.
       // This will set the "visible" and "layer" property for the renderer-specific property list
       // such that the global / default property list values are overwritten
       mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(node, baseRenderer); // item a)
       // Explicitly set the visibility to true for selected nodes to show them in the render window.
       node->SetVisibility(true, baseRenderer); // item b)
     }
     // else: item c): node that was already selected before does not need to be modified
   }
 
   for (auto& node : oldInternalSelection)
   {
     // check if the node is part of the new selection
     auto finding = std::find(std::begin(newInternalSelection), std::end(newInternalSelection), node);
     if (finding == std::end(newInternalSelection)) // node not found
     {
       // If the node is not part of the new selection, unset the relevant renderer-specific properties.
       // This will unset the "visible" and "layer" property for the renderer-specific property list and
       // hide the node for this renderer.
       // ATTENTION: This is required, since the synchronized global property needs to be overwritten
       //            to make sure that the visibility is correctly set for the specific base renderer.
       this->DeselectNode(node); // item d) and e)
     }
     // else: item c): node that was already selected before does not need to be modified
   }
 }
 
 void QmitkSynchronizedNodeSelectionWidget::ReinitNode(const mitk::DataNode* dataNode)
 {
   auto baseRenderer = m_BaseRenderer.Lock();
   if (baseRenderer.IsNull())
   {
     return;
   }
 
   auto selectedImage = dynamic_cast<mitk::Image*>(dataNode->GetData());
   if (nullptr == selectedImage)
   {
     return;
   }
 
   auto boundingBoxPredicate = mitk::NodePredicateNot::New(
     mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false), baseRenderer));
   if (!boundingBoxPredicate->CheckNode(dataNode))
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), selectedImage->GetTimeGeometry());
 }
 
 void QmitkSynchronizedNodeSelectionWidget::RemoveFromInternalSelection(mitk::DataNode* dataNode)
 {
   auto baseRenderer = m_BaseRenderer.Lock();
   if (baseRenderer.IsNull())
   {
     return;
   }
 
   if (this->IsSynchronized())
   {
     // If the model is synchronized, all nodes use global / default properties.
     // Thus we need to modify the global property of the node.
     // Explicitly set the visibility to false for unselected nodes to hide them in the render window.
     dataNode->SetVisibility(false);
   }
 
   m_Controls.selectionModeCheckBox->setChecked(false);
   emit SelectionModeChanged(false);
 
   this->RemoveNodeFromSelection(dataNode);
 }
 
 bool QmitkSynchronizedNodeSelectionWidget::IsParentNodeSelected(const mitk::DataNode* dataNode) const
 {
   auto dataStorage = m_DataStorage.Lock();
   if (dataStorage.IsNull())
   {
     return false;
   }
 
   auto currentSelection = this->GetCurrentInternalSelection();
   auto parentNodes = dataStorage->GetSources(dataNode, m_NodePredicate, false);
   for (auto it = parentNodes->Begin(); it != parentNodes->End(); ++it)
   {
     const mitk::DataNode* parentNode = it->Value();
     auto finding = std::find(std::begin(currentSelection), std::end(currentSelection), parentNode);
     if (finding != std::end(currentSelection)) // parent node found
     {
       // at least one parent node is part of the selection
       return true;
     }
   }
 
   return false;
 }
 
 void QmitkSynchronizedNodeSelectionWidget::DeselectNode(mitk::DataNode* dataNode)
 {
   auto baseRenderer = m_BaseRenderer.Lock();
   if (baseRenderer.IsNull())
   {
     return;
   }
 
   if (nullptr == dataNode)
   {
     return;
   }
 
   if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(dataNode))
   {
     // If the node should not be part of the selection, set the relevant renderer-specific properties.
     // This will set the "visible" and "layer" property for the renderer-specific property list,
     // such that the global / default property list values are overwritten.
     mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(dataNode, baseRenderer);
     // Explicitly set the visibility to false for the node to hide them in the render window.
     dataNode->SetVisibility(false, baseRenderer);
   }
 }
 
 void QmitkSynchronizedNodeSelectionWidget::SelectAll()
 {
   auto dataStorage = m_DataStorage.Lock();
   if (dataStorage.IsNull())
   {
     return;
   }
 
   auto allNodes = m_NodePredicate ? dataStorage->GetSubset(m_NodePredicate) : dataStorage->GetAll();
   NodeList currentSelection;
   for (auto& node : *allNodes)
   {
     currentSelection.append(node);
   }
 
   this->HandleChangeOfInternalSelection(currentSelection);
 }
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
index fee5a07e50..968dd7a6a0 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
@@ -1,244 +1,247 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkMxNMultiWidgetEditor.h"
 
 #include <mitkCoreServices.h>
 #include <mitkIPreferencesService.h>
 #include <mitkIPreferences.h>
 
 #include <berryIWorkbenchPage.h>
 #include <berryIWorkbenchPartConstants.h>
 #include <berryUIException.h>
 
 // mxn multi widget editor plugin
 #include "QmitkMultiWidgetDecorationManager.h"
 
 // mitk qt widgets module
 #include <QmitkMxNMultiWidget.h>
 #include <QmitkInteractionSchemeToolBar.h>
 #include <QmitkMultiWidgetConfigurationToolBar.h>
 
 // qt
 #include <QHBoxLayout>
 
 const QString QmitkMxNMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.mxnmultiwidget";
 
 struct QmitkMxNMultiWidgetEditor::Impl final
 {
   Impl();
   ~Impl() = default;
 
   QmitkInteractionSchemeToolBar* m_InteractionSchemeToolBar;
   QmitkMultiWidgetConfigurationToolBar* m_ConfigurationToolBar;
 };
 
 QmitkMxNMultiWidgetEditor::Impl::Impl()
   : m_InteractionSchemeToolBar(nullptr)
   , m_ConfigurationToolBar(nullptr)
 {
   // nothing here
 }
 
 //////////////////////////////////////////////////////////////////////////
 // QmitkMxNMultiWidgetEditor
 //////////////////////////////////////////////////////////////////////////
 QmitkMxNMultiWidgetEditor::QmitkMxNMultiWidgetEditor()
   : QmitkAbstractMultiWidgetEditor()
   , m_Impl(std::make_unique<Impl>())
 {
   // nothing here
 }
 
 QmitkMxNMultiWidgetEditor::~QmitkMxNMultiWidgetEditor()
 {
   GetSite()->GetPage()->RemovePartListener(this);
 }
 
 berry::IPartListener::Events::Types QmitkMxNMultiWidgetEditor::GetPartEventTypes() const
 {
   return Events::CLOSED | Events::OPENED | Events::HIDDEN | Events::VISIBLE;
 }
 
 void QmitkMxNMultiWidgetEditor::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
     if (nullptr != multiWidget)
     {
       multiWidget->ActivateMenuWidget(false);
     }
   }
 }
 
 void QmitkMxNMultiWidgetEditor::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
     if (nullptr != multiWidget)
     {
       multiWidget->EnableCrosshair();
       multiWidget->ActivateMenuWidget(true);
     }
   }
 }
 
 void QmitkMxNMultiWidgetEditor::PartHidden(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
     if (nullptr != multiWidget)
     {
       multiWidget->ActivateMenuWidget(false);
     }
   }
 }
 
 void QmitkMxNMultiWidgetEditor::PartVisible(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
     if (nullptr != multiWidget)
     {
       multiWidget->ActivateMenuWidget(true);
     }
   }
 }
 
 void QmitkMxNMultiWidgetEditor::OnLayoutSet(int row, int column)
 {
   const auto &multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
   if (nullptr != multiWidget)
   {
     QmitkAbstractMultiWidgetEditor::OnLayoutSet(row, column);
     multiWidget->EnableCrosshair();
   }
 }
 
 void QmitkMxNMultiWidgetEditor::OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
 {
   const auto &multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return;
   }
 
   if (mitk::InteractionSchemeSwitcher::PACSStandard == scheme)
   {
     m_Impl->m_InteractionSchemeToolBar->setVisible(true);
   }
   else
   {
     m_Impl->m_InteractionSchemeToolBar->setVisible(false);
   }
 
   QmitkAbstractMultiWidgetEditor::OnInteractionSchemeChanged(scheme);
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidgetEditor::SetFocus()
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr != multiWidget)
   {
     multiWidget->setFocus();
   }
 }
 
 void QmitkMxNMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   QHBoxLayout *layout = new QHBoxLayout(parent);
   layout->setContentsMargins(0, 0, 0, 0);
 
   auto* preferences = this->GetPreferences();
 
   auto multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     multiWidget = new QmitkMxNMultiWidget(parent);
 
     // create left toolbar: interaction scheme toolbar to switch how the render window navigation behaves in PACS mode
     if (nullptr == m_Impl->m_InteractionSchemeToolBar)
     {
       m_Impl->m_InteractionSchemeToolBar = new QmitkInteractionSchemeToolBar(parent);
       layout->addWidget(m_Impl->m_InteractionSchemeToolBar);
     }
     m_Impl->m_InteractionSchemeToolBar->SetInteractionEventHandler(multiWidget->GetInteractionEventHandler());
 
     multiWidget->SetDataStorage(GetDataStorage());
     multiWidget->InitializeMultiWidget();
     SetMultiWidget(multiWidget);
     connect(static_cast<QmitkMxNMultiWidget*>(multiWidget), &QmitkMxNMultiWidget::LayoutChanged,
       this, &QmitkMxNMultiWidgetEditor::OnLayoutChanged);
   }
 
   layout->addWidget(multiWidget);
 
   // create right toolbar: configuration toolbar to change the render window widget layout
   if (nullptr == m_Impl->m_ConfigurationToolBar)
   {
     m_Impl->m_ConfigurationToolBar = new QmitkMultiWidgetConfigurationToolBar(multiWidget);
+    m_Impl->m_ConfigurationToolBar->SetDataStorage(GetDataStorage());
     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::SetDataBasedLayout,
+    static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::SetDataBasedLayout);
   connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::SaveLayout,
     static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::SaveLayout, Qt::DirectConnection);
   connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::LoadLayout,
     static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::LoadLayout);
 
   GetSite()->GetPage()->AddPartListener(this);
 
   OnPreferencesChanged(preferences);
 }
 
 void QmitkMxNMultiWidgetEditor::OnPreferencesChanged(const mitk::IPreferences* preferences)
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return;
   }
 
   // update decoration preferences
   //m_Impl->m_MultiWidgetDecorationManager->DecorationPreferencesChanged(preferences);
 
   int crosshairGapSize = preferences->GetInt("crosshair gap size", 32);
   multiWidget->SetCrosshairGap(crosshairGapSize);
 
   // zooming and panning preferences
   bool constrainedZooming = preferences->GetBool("Use constrained zooming and panning", true);
   mitk::RenderingManager::GetInstance()->SetConstrainedPanningZooming(constrainedZooming);
 
   bool PACSInteractionScheme = preferences->GetBool("PACS like mouse interaction", false);
   OnInteractionSchemeChanged(PACSInteractionScheme ?
     mitk::InteractionSchemeSwitcher::PACSStandard :
     mitk::InteractionSchemeSwitcher::MITKStandard);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkMxNMultiWidgetEditor::OnLayoutChanged()
 {
   FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
 }