diff --git a/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h b/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
index 1f89828df2..d83878a2be 100644
--- a/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
@@ -1,150 +1,150 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QMITKABSTRACTMULTIWIDGET_H
 #define QMITKABSTRACTMULTIWIDGET_H
 
 // mitk qt widgets module
 #include "MitkQtWidgetsExports.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkInteractionSchemeSwitcher.h>
 #include <mitkPoint.h>
 
 // qt
 #include <QWidget>
 
 // c++
 #include <map>
 #include <memory>
 
 class QmitkRenderWindow;
 class QmitkRenderWindowWidget;
 
 namespace mitk
 {
   class DataStorage;
   class InteractionEventHandler;
   class RenderingManager;
 }
 
 /**
 * @brief The 'QmitkAbstractMultiWidget' is a 'QWidget' that can be subclassed to display multiple render windows at once.
 *        Render windows can dynamically be added and removed to change the layout of the multi widget.
 *        A subclass of this multi widget can be used inside a 'QmitkAbstractMultiWidgetEditor'.
 *
 *        The class uses the 'DisplayActionEventBroadcast' and 'DisplayActionEventHandler' classes to
 *        load a state machine and set an event configuration.
 *
 *        Using the 'Synchronize' function the user can enable or disable the synchronization of display action events.
 *        See 'DisplayActionEventFunctions'-class for the different synchronized and non-synchronized functions used.
 */
 class MITKQTWIDGETS_EXPORT QmitkAbstractMultiWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
   using RenderWindowWidgetPointer = std::shared_ptr<QmitkRenderWindowWidget>;
   using RenderWindowWidgetMap = std::map<QString, std::shared_ptr<QmitkRenderWindowWidget>>;
   using RenderWindowHash = QHash<QString, QmitkRenderWindow*>;
 
   QmitkAbstractMultiWidget(QWidget* parent = 0,
                            Qt::WindowFlags f = 0,
                            mitk::RenderingManager* renderingManager = nullptr,
                            mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard,
                            const QString& multiWidgetName = "multiwidget");
 
   virtual ~QmitkAbstractMultiWidget();
   
   virtual void InitializeMultiWidget() = 0;
   virtual void MultiWidgetOpened() { }
   virtual void MultiWidgetClosed() { }
 
   virtual void SetDataStorage(mitk::DataStorage* dataStorage);
   mitk::DataStorage* GetDataStorage() const;
 
   int GetRowCount() const;
   int GetColumnCount() const;
   virtual void SetLayout(int row, int column);
 
   virtual void Synchronize(bool synchronized);
   virtual void SetInteractionScheme(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
 
   mitk::InteractionEventHandler* GetInteractionEventHandler();
 
   RenderWindowWidgetMap GetRenderWindowWidgets() const;
   RenderWindowWidgetPointer GetRenderWindowWidget(int row, int column) const;
   RenderWindowWidgetPointer GetRenderWindowWidget(const QString& widgetName) const;
   RenderWindowHash GetRenderWindows() const;
   QmitkRenderWindow* GetRenderWindow(int row, int column) const;
   QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const;
 
   virtual void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget);
   RenderWindowWidgetPointer GetActiveRenderWindowWidget() const;
   RenderWindowWidgetPointer GetFirstRenderWindowWidget() const;
   RenderWindowWidgetPointer GetLastRenderWindowWidget() const;
   
   virtual QString GetNameFromIndex(int row, int column) const;
   virtual QString GetNameFromIndex(size_t index) const;
 
   unsigned int GetNumberOfRenderWindowWidgets() const;
 
   void RequestUpdate(const QString& widgetName);
   void RequestUpdateAll();
   void ForceImmediateUpdate(const QString& widgetName);
   void ForceImmediateUpdateAll();
 
   virtual void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) = 0;
   virtual const mitk::Point3D GetSelectedPosition(const QString& widgetName) const = 0;
 
   virtual void SetCrosshairVisibility(bool visible) = 0;
-  virtual bool GetCrosshairVisibility() = 0;
+  virtual bool GetCrosshairVisibility() const = 0;
 
 Q_SIGNALS:
 
   void ActiveRenderWindowChanged();
 
 protected:
 
   virtual void AddRenderWindowWidget(const QString& widgetName, RenderWindowWidgetPointer renderWindowWidget);
   virtual void RemoveRenderWindowWidget();
 
 private:
 
   /**
   * @brief This function will be called by the function 'SetLayout' and
   *        can be implemented and customized in the subclasses.
   */
   virtual void SetLayoutImpl() = 0;
   /**
   * @brief This function will be called by the function 'Synchronize' and
   *        can be implemented and customized in the subclasses.
   */
   virtual void SynchronizeImpl() = 0;
   /**
   * @brief This function will be called by the function 'SetInteractionScheme' and
   *        can be implemented and customized in the subclasses.
   */
   virtual void SetInteractionSchemeImpl() = 0;
 
   struct Impl;
   std::unique_ptr<Impl> m_Impl;
 
 };
 
 #endif // QMITKABSTRACTMULTIWIDGET_H
diff --git a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
index 564a8cc38b..d1b225fee5 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,90 +1,85 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QMITKMXNMULTIWIDGET_H
 #define QMITKMXNMULTIWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkAbstractMultiWidget.h"
 
 class QGridLayout;
 
-namespace mitk
-{
-  class RenderingManager;
-}
-
 /**
 * @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 'ResetLayout'-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 = 0,
+  QmitkMxNMultiWidget(QWidget* parent = nullptr,
                       Qt::WindowFlags f = 0,
                       mitk::RenderingManager* renderingManager = nullptr,
                       mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard,
                       const QString& multiWidgetName = "mxnmulti");
 
   virtual ~QmitkMxNMultiWidget() = default;
 
   virtual void InitializeMultiWidget() override;
   virtual void MultiWidgetOpened() override;
   virtual void MultiWidgetClosed() override;
 
   virtual void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget) override;
 
   virtual void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
   virtual const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
 
   virtual void SetCrosshairVisibility(bool activate) override;
-  virtual bool GetCrosshairVisibility() override { return m_CrosshairVisibility; }
+  virtual bool GetCrosshairVisibility() const override { return m_CrosshairVisibility; }
 
 public Q_SLOTS:
 
   // mouse events
   virtual void wheelEvent(QWheelEvent* e) override;
   virtual void mousePressEvent(QMouseEvent* e) override;
   virtual void moveEvent(QMoveEvent* e) override;
 
 Q_SIGNALS:
 
   void WheelMoved(QWheelEvent *);
   void Moved();
 
 private:
 
   virtual void SetLayoutImpl() override;
   virtual void SynchronizeImpl() override { }
   virtual void SetInteractionSchemeImpl() override { }
 
   void InitializeLayout();
   void CreateRenderWindowWidget();
   void FillMultiWidgetLayout();
 
   QGridLayout* m_GridLayout;
   bool m_CrosshairVisibility;
 
 };
 
 #endif // QMITKMXNMULTIWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkAbstractMultiWidget.cpp b/Modules/QtWidgets/src/QmitkAbstractMultiWidget.cpp
index ba84f63462..3dbdbdc467 100644
--- a/Modules/QtWidgets/src/QmitkAbstractMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkAbstractMultiWidget.cpp
@@ -1,371 +1,372 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // mitk qt widgets module
 #include "QmitkAbstractMultiWidget.h"
+#include "QmitkLevelWindowWidget.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkDataStorage.h>
 #include <mitkDisplayActionEvents.h>
 #include <mitkDisplayActionEventBroadcast.h>
 #include <mitkDisplayActionEventFunctions.h>
 #include <mitkDisplayActionEventHandler.h>
 
 // qt
 #include <QMouseEvent>
 
 // c++
 #include <iomanip>
 
 struct QmitkAbstractMultiWidget::Impl final
 {
   Impl(mitk::RenderingManager* renderingManager,
        mitk::BaseRenderer::RenderingMode::Type renderingMode,
        const QString& multiWidgetName);
 
   void SetDataStorage(mitk::DataStorage* dataStorage)
   {
     if (dataStorage == m_DataStorage)
     {
       return;
     }
 
     m_DataStorage = dataStorage;
     // set new data storage for the render window widgets
     for (const auto& renderWindowWidget : m_RenderWindowWidgets)
     {
       renderWindowWidget.second->SetDataStorage(m_DataStorage);
     }
   }
 
   void Synchronize(bool synchronized)
   {
     auto allObserverTags = m_DisplayActionEventHandler->GetAllObserverTags();
     for (auto observerTag : allObserverTags)
     {
       m_DisplayActionEventHandler->DisconnectObserver(observerTag);
     }
 
     if (synchronized)
     {
       mitk::StdFunctionCommand::ActionFunction actionFunction = mitk::DisplayActionEventFunctions::MoveCameraSynchronizedAction();
       m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayMoveEvent(nullptr, mitk::Vector2D()), actionFunction);
 
       actionFunction = mitk::DisplayActionEventFunctions::SetCrosshairSynchronizedAction();
       m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplaySetCrosshairEvent(nullptr, mitk::Point3D()), actionFunction);
 
       actionFunction = mitk::DisplayActionEventFunctions::ZoomCameraSynchronizedAction();
       m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayZoomEvent(nullptr, 0.0, mitk::Point2D()), actionFunction);
 
       actionFunction = mitk::DisplayActionEventFunctions::ScrollSliceStepperSynchronizedAction();
       m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayScrollEvent(nullptr, 0), actionFunction);
     }
     else
     {
       mitk::StdFunctionCommand::ActionFunction actionFunction = mitk::DisplayActionEventFunctions::MoveSenderCameraAction();
       m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayMoveEvent(nullptr, mitk::Vector2D()), actionFunction);
 
       actionFunction = mitk::DisplayActionEventFunctions::SetCrosshairAction();
       m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplaySetCrosshairEvent(nullptr, mitk::Point3D()), actionFunction);
 
       actionFunction = mitk::DisplayActionEventFunctions::ZoomSenderCameraAction();
       m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayZoomEvent(nullptr, 0.0, mitk::Point2D()), actionFunction);
 
       actionFunction = mitk::DisplayActionEventFunctions::ScrollSliceStepperAction();
       m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayScrollEvent(nullptr, 0), actionFunction);
     }
 
     // use the standard 'set level window' action for both modes
     mitk::StdFunctionCommand::ActionFunction actionFunction = mitk::DisplayActionEventFunctions::SetLevelWindowAction();
     m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplaySetLevelWindowEvent(nullptr, mitk::ScalarType(), mitk::ScalarType()), actionFunction);
   }
 
   void InitializeDisplayActionEventHandling()
   {
     m_DisplayActionEventBroadcast = mitk::DisplayActionEventBroadcast::New();
     m_DisplayActionEventBroadcast->LoadStateMachine("DisplayInteraction.xml");
     m_DisplayActionEventBroadcast->SetEventConfig("DisplayConfigPACS.xml");
 
     m_DisplayActionEventHandler = std::make_unique<mitk::DisplayActionEventHandler>();
     m_DisplayActionEventHandler->SetObservableBroadcast(m_DisplayActionEventBroadcast);
 
     Synchronize(true);
   }
   
   mitk::DataStorage::Pointer m_DataStorage;
 
   mitk::RenderingManager* m_RenderingManager;
   mitk::BaseRenderer::RenderingMode::Type m_RenderingMode;
   QString m_MultiWidgetName;
 
   RenderWindowWidgetMap m_RenderWindowWidgets;
   RenderWindowWidgetPointer m_ActiveRenderWindowWidget;
 
   int m_MultiWidgetRows;
   int m_MultiWidgetColumns;
 
   // interaction
   mitk::DisplayActionEventBroadcast::Pointer m_DisplayActionEventBroadcast;
   std::unique_ptr<mitk::DisplayActionEventHandler> m_DisplayActionEventHandler;
 };
 
 QmitkAbstractMultiWidget::Impl::Impl(mitk::RenderingManager* renderingManager,
                                      mitk::BaseRenderer::RenderingMode::Type renderingMode,
                                      const QString& multiWidgetName)
   : m_DataStorage(nullptr)
   , m_RenderingManager(renderingManager)
   , m_RenderingMode(renderingMode)
   , m_MultiWidgetName(multiWidgetName)
   , m_MultiWidgetRows(0)
   , m_MultiWidgetColumns(0)
   , m_DisplayActionEventBroadcast(nullptr)
   , m_DisplayActionEventHandler(nullptr)
 {
   InitializeDisplayActionEventHandling();
 }
 
 QmitkAbstractMultiWidget::QmitkAbstractMultiWidget(QWidget* parent,
                                                    Qt::WindowFlags f/* = 0*/,
                                                    mitk::RenderingManager* renderingManager/* = nullptr*/,
                                                    mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/,
                                                    const QString& multiWidgetName/* = "multiwidget"*/)
   : QWidget(parent, f)
   , m_Impl(std::make_unique<Impl>(renderingManager, renderingMode, multiWidgetName))
 {
   // nothing here
 }
 
 QmitkAbstractMultiWidget::~QmitkAbstractMultiWidget() { }
 
 void QmitkAbstractMultiWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   m_Impl->SetDataStorage(dataStorage);
 }
 
 mitk::DataStorage* QmitkAbstractMultiWidget::GetDataStorage() const
 {
   return m_Impl->m_DataStorage;
 }
 
 int QmitkAbstractMultiWidget::GetRowCount() const
 {
   return m_Impl->m_MultiWidgetRows;
 }
 
 int QmitkAbstractMultiWidget::GetColumnCount() const
 {
   return m_Impl->m_MultiWidgetColumns;
 }
 
 void QmitkAbstractMultiWidget::SetLayout(int row, int column)
 {
   m_Impl->m_MultiWidgetRows = row;
   m_Impl->m_MultiWidgetColumns = column;
   SetLayoutImpl();
 }
 
 void QmitkAbstractMultiWidget::Synchronize(bool synchronized)
 {
   m_Impl->Synchronize(synchronized);
   SynchronizeImpl();
 }
 
 void QmitkAbstractMultiWidget::SetInteractionScheme(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
 {
   auto interactionSchemeSwitcher = mitk::InteractionSchemeSwitcher::New();
   auto interactionEventHandler = GetInteractionEventHandler();
   try
   {
     interactionSchemeSwitcher->SetInteractionScheme(interactionEventHandler, scheme);
   }
   catch (const mitk::Exception&)
   {
     return;
   }
 
   SetInteractionSchemeImpl();
 }
 
 mitk::InteractionEventHandler* QmitkAbstractMultiWidget::GetInteractionEventHandler()
 {
   return m_Impl->m_DisplayActionEventBroadcast.GetPointer();
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetMap QmitkAbstractMultiWidget::GetRenderWindowWidgets() const
 {
   return m_Impl->m_RenderWindowWidgets;
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetRenderWindowWidget(int row, int column) const
 {
   return GetRenderWindowWidget(GetNameFromIndex(row, column));
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetRenderWindowWidget(const QString& widgetName) const
 {
   RenderWindowWidgetMap::const_iterator it = m_Impl->m_RenderWindowWidgets.find(widgetName);
   if (it != m_Impl->m_RenderWindowWidgets.end())
   {
     return it->second;
   }
 
   return nullptr;
 }
 
 QmitkAbstractMultiWidget::RenderWindowHash QmitkAbstractMultiWidget::GetRenderWindows() const
 {
   RenderWindowHash result;
   // create QHash on demand
   auto renderWindowWidgets = GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     result.insert(renderWindowWidget.first, renderWindowWidget.second->GetRenderWindow());
   }
 
   return result;
 }
 
 QmitkRenderWindow* QmitkAbstractMultiWidget::GetRenderWindow(int row, int column) const
 {
   return GetRenderWindow(GetNameFromIndex(row, column));
 }
 
 QmitkRenderWindow* QmitkAbstractMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->GetRenderWindow();
   }
 
   return nullptr;
 }
 
 void QmitkAbstractMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
 {
   m_Impl->m_ActiveRenderWindowWidget = activeRenderWindowWidget;
   emit ActiveRenderWindowChanged();
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetActiveRenderWindowWidget() const
 {
   return m_Impl->m_ActiveRenderWindowWidget;
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetFirstRenderWindowWidget() const
 {
   if (!m_Impl->m_RenderWindowWidgets.empty())
   {
     return m_Impl->m_RenderWindowWidgets.begin()->second;
   }
   else
   {
     return nullptr;
   }
 }
 
 QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkAbstractMultiWidget::GetLastRenderWindowWidget() const
 {
   if (!m_Impl->m_RenderWindowWidgets.empty())
   {
     return m_Impl->m_RenderWindowWidgets.rbegin()->second;
   }
   else
   {
     return nullptr;
   }
 }
 
 QString QmitkAbstractMultiWidget::GetNameFromIndex(int row, int column) const
 {
   if (0 <= row && m_Impl->m_MultiWidgetRows > row && 0 <= column && m_Impl->m_MultiWidgetColumns > column)
   {
     return GetNameFromIndex(row * m_Impl->m_MultiWidgetColumns + column);
   }
 
   return QString();
 }
 
 QString QmitkAbstractMultiWidget::GetNameFromIndex(size_t index) const
 {
   if (index <= m_Impl->m_RenderWindowWidgets.size())
   {
     return m_Impl->m_MultiWidgetName + ".widget" + QString::number(index);
   }
 
   return QString();
 }
 
 unsigned int QmitkAbstractMultiWidget::GetNumberOfRenderWindowWidgets() const
 {
   return m_Impl->m_RenderWindowWidgets.size();
 }
 
 void QmitkAbstractMultiWidget::RequestUpdate(const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->RequestUpdate();
   }
 }
 
 void QmitkAbstractMultiWidget::RequestUpdateAll()
 {
   for (const auto& renderWindowWidget : m_Impl->m_RenderWindowWidgets)
   {
     renderWindowWidget.second->RequestUpdate();
   }
 }
 
 void QmitkAbstractMultiWidget::ForceImmediateUpdate(const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->ForceImmediateUpdate();
   }
 }
 
 void QmitkAbstractMultiWidget::ForceImmediateUpdateAll()
 {
   for (const auto& renderWindowWidget : m_Impl->m_RenderWindowWidgets)
   {
     renderWindowWidget.second->ForceImmediateUpdate();
   }
 }
 
 void QmitkAbstractMultiWidget::AddRenderWindowWidget(const QString& widgetName, RenderWindowWidgetPointer renderWindowWidget)
 {
   m_Impl->m_RenderWindowWidgets.insert(std::make_pair(widgetName, renderWindowWidget));
 }
 
 void QmitkAbstractMultiWidget::RemoveRenderWindowWidget()
 {
   auto iterator = m_Impl->m_RenderWindowWidgets.find(GetNameFromIndex(GetRenderWindowWidgets().size() - 1));
   if (iterator == m_Impl->m_RenderWindowWidgets.end())
   {
     return;
   }
 
   // disconnect each signal of this render window widget
   RenderWindowWidgetPointer renderWindowWidgetToRemove = iterator->second;
   disconnect(renderWindowWidgetToRemove.get(), 0, 0, 0);
 
   // erase the render window from the map
   m_Impl->m_RenderWindowWidgets.erase(iterator);
 }
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
index 1d2bee65ca..b87b1622fc 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
@@ -1,139 +1,139 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QMITKABSTRACTMULTIWIDGETEDITOR_H
 #define QMITKABSTRACTMULTIWIDGETEDITOR_H
 
 #include <org_mitk_gui_qt_common_Export.h>
 
 // org mitk gui qt common plugin
 #include <QmitkAbstractRenderEditor.h>
 
 // mitk core
 #include <mitkInteractionSchemeSwitcher.h>
 
 // berry
 #include <berryIPartListener.h>
 
 // c++
 #include <memory>
 
 class QmitkAbstractMultiWidget;
 class QmitkLevelWindowWidget;
 
 class MITK_QT_COMMON QmitkAbstractMultiWidgetEditor : public QmitkAbstractRenderEditor, public berry::IPartListener
 {
   Q_OBJECT
 
 public:
 
   berryObjectMacro(QmitkAbstractMultiWidgetEditor, QmitkAbstractRenderEditor, IPartListener)
 
   static const QString EDITOR_ID;
 
   QmitkAbstractMultiWidgetEditor();
   virtual ~QmitkAbstractMultiWidgetEditor() override;
 
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual QmitkRenderWindow* GetActiveQmitkRenderWindow() const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual QHash<QString, QmitkRenderWindow*> GetQmitkRenderWindows() const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual mitk::Point3D GetSelectedPosition(const QString& id = QString()) const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual bool IsDecorationEnabled(const QString& decoration) const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual QStringList GetDecorations() const override;
   /**
   * @brief Overridden from berry::IPartListener
   */
   virtual berry::IPartListener::Events::Types GetPartEventTypes() const override;
   /**
   * @brief Overridden from berry::IPartListener
   */
   virtual void PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef) override;
   /**
   * @brief Overridden from berry::IPartListener
   */
   virtual void PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef) override;
   /**
   * @brief Retrieve a QmitkRenderWindow by it's index.
   */
   virtual QmitkRenderWindow* GetQmitkRenderWindowByIndex(int index) const;
   /**
   * @brief Retrieve a QmitkRenderWindow by the row and column position.
   */
   virtual QmitkRenderWindow* GetQmitkRenderWindowByIndex(int row, int column) const;
   /**
   * @brief Set the current multi widget of this editor.
   */
   virtual void SetMultiWidget(QmitkAbstractMultiWidget* multiWidget);
   /**
   * @brief Return the current multi widget of this editor.
   */
   virtual QmitkAbstractMultiWidget* GetMultiWidget() const;
   /**
   * @brief Return the number of rows of the underlying multi widget.
   */
   virtual int GetRowCount() const;
   /**
   * @brief Return the number of columns of the underlying multi widget.
   */
   virtual int GetColumnCount() const;
 
-  virtual QmitkLevelWindowWidget GetLevelWindowWidget() const = 0;
+  virtual QmitkLevelWindowWidget* GetLevelWindowWidget() const = 0;
 
 public Q_SLOTS:
   /**
   * @brief A slot that can be called if the layout has been changed.
   *        This function will call the function 'SetLayout' of the multi widget where
   *        custom behavior can be implemented.
   *        Finally 'FirePropertyChange' is called to inform the workbench about an input change.
   */
   virtual void OnLayoutSet(int row, int column);
   virtual void OnSynchronize(bool synchronized);
   virtual void OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
 
 private:
 
   struct Impl;
   std::unique_ptr<Impl> m_Impl;
 
 };
 
 #endif // QMITKABSTRACTMULTIWIDGETEDITOR_H
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
index c4095ea091..480cfdbb39 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
@@ -1,152 +1,152 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkMxNMultiWidgetEditor.h"
 
 #include <berryIPreferencesService.h>
 #include <berryIPreferences.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()
   : m_Impl(std::make_unique<Impl>())
 {}
 
 QmitkMxNMultiWidgetEditor::~QmitkMxNMultiWidgetEditor()
 {
   GetSite()->GetPage()->RemovePartListener(this);
 }
 
 void QmitkMxNMultiWidgetEditor::OnLayoutSet(int row, int column)
 {
   const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
   if (nullptr != multiWidget)
   {
     multiWidget->SetLayout(row, column);
     multiWidget->SetCrosshairVisibility(true);
     FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
   }
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidgetEditor::SetFocus()
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr != multiWidget)
   {
     multiWidget->setFocus();
   }
 }
 
 void QmitkMxNMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   auto multiWidget = GetMultiWidget();
-  if (nullptr == multiWidget|| nullptr == dynamic_cast<QmitkMxNMultiWidgetEditor*>(multiWidget))
+  if (nullptr == multiWidget)
   {
     QHBoxLayout* layout = new QHBoxLayout(parent);
     layout->setContentsMargins(0, 0, 0, 0);
 
     berry::IBerryPreferences* preferences = dynamic_cast<berry::IBerryPreferences*>(GetPreferences().GetPointer());
     mitk::BaseRenderer::RenderingMode::Type renderingMode = static_cast<mitk::BaseRenderer::RenderingMode::Type>(preferences->GetInt("Rendering Mode", 0));
 
-    multiWidget = new QmitkMxNMultiWidget(parent, 0, 0, renderingMode);
+    multiWidget = new QmitkMxNMultiWidget(parent, 0, nullptr, renderingMode);
 
     // create left toolbar: interaction scheme toolbar to switch how the render window navigation behaves
     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());
 
     // add center widget: the mxn multi widget
     layout->addWidget(multiWidget);
 
     multiWidget->SetDataStorage(GetDataStorage());
     multiWidget->InitializeMultiWidget();
     SetMultiWidget(multiWidget);
 
     // create right toolbar: configuration toolbar to change the render window widget layout
     if (nullptr == m_Impl->m_ConfigurationToolBar)
     {
       m_Impl->m_ConfigurationToolBar = new QmitkMultiWidgetConfigurationToolBar(multiWidget);
       layout->addWidget(m_Impl->m_ConfigurationToolBar);
     }
 
     connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::LayoutSet, this, &QmitkMxNMultiWidgetEditor::OnLayoutSet);
     connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::Synchronized, this, &QmitkMxNMultiWidgetEditor::OnSynchronize);
 
     //m_Impl->m_MultiWidgetDecorationManager = std::make_unique<QmitkMultiWidgetDecorationManager>(multiWidget);
 
     GetSite()->GetPage()->AddPartListener(this);
 
     OnPreferencesChanged(preferences);
   }
 }
 
 void QmitkMxNMultiWidgetEditor::OnPreferencesChanged(const berry::IBerryPreferences* preferences)
 {
   const auto& multiWidget = GetMultiWidget();
   if (nullptr == multiWidget)
   {
     return;
   }
 
   // update decoration preferences
   //m_Impl->m_MultiWidgetDecorationManager->DecorationPreferencesChanged(preferences);
 
   // zooming and panning preferences
   bool constrainedZooming = preferences->GetBool("Use constrained zooming and panning", true);
   mitk::RenderingManager::GetInstance()->SetConstrainedPanningZooming(constrainedZooming);
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(GetDataStorage());
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.h b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.h
index 9703c5ec36..9588d11492 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.h
@@ -1,64 +1,66 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QMITKMXNMULTIWIDGETEDITOR_H
 #define QMITKMXNMULTIWIDGETEDITOR_H
 
 #include <QmitkAbstractMultiWidgetEditor.h>
 
 #include <org_mitk_gui_qt_mxnmultiwidgeteditor_Export.h>
 
 // berry
 #include <berryIPartListener.h>
 
 // c++
 #include <memory>
 
 class QmitkMxNMultiWidget;
 
 class MXNMULTIWIDGETEDITOR_EXPORT QmitkMxNMultiWidgetEditor final : public QmitkAbstractMultiWidgetEditor
 {
   Q_OBJECT
 
 public:
 
   static const QString EDITOR_ID;
 
   QmitkMxNMultiWidgetEditor();
   virtual ~QmitkMxNMultiWidgetEditor() override;
 
+  virtual QmitkLevelWindowWidget* GetLevelWindowWidget() const override { return nullptr; }
+
   virtual void OnLayoutSet(int row, int column) override;
 
 private:
   /**
   * @brief Overridden from QmitkAbstractRenderEditor
   */
   virtual void SetFocus() override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor
   */
   virtual void CreateQtPartControl(QWidget* parent) override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor
   */
   virtual void OnPreferencesChanged(const berry::IBerryPreferences* preferences) override;
 
   struct Impl;
   std::unique_ptr<Impl> m_Impl;
 
 };
 
 #endif // QMITKMXNMULTIWIDGETEDITOR_H