diff --git a/Modules/QtWidgets/include/QmitkCustomMultiWidget.h b/Modules/QtWidgets/include/QmitkCustomMultiWidget.h
index 13405c3103..c3608be5b8 100644
--- a/Modules/QtWidgets/include/QmitkCustomMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkCustomMultiWidget.h
@@ -1,157 +1,158 @@
 /*===================================================================
 
 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 QMITKCUSTOMMULTIWIDGET_H
 #define QMITKCUSTOMMULTIWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDataStorage.h>
 #include <mitkDisplayActionEventBroadcast.h>
 #include <mitkDisplayActionEventHandler.h>
 
 // qt
 #include <QWidget>
 
 class QHBoxLayout;
 class QVBoxLayout;
 class QGridLayout;
 class QSpacerItem;
 class QmitkRenderWindow;
 
 namespace mitk
 {
   class RenderingManager;
 }
 
 /**
 * @brief The 'QmitkCustomMultiWidget' is a 'QWidget' 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.
 */
 class MITKQTWIDGETS_EXPORT QmitkCustomMultiWidget : 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*>;
 
   QmitkCustomMultiWidget(QWidget* parent = 0,
                          Qt::WindowFlags f = 0,
                          mitk::RenderingManager* renderingManager = nullptr,
                          mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard,
                          const QString& multiWidgetName = "custommulti");
 
   virtual ~QmitkCustomMultiWidget();
   
   void SetDataStorage(mitk::DataStorage* dataStorage);
   void InitializeRenderWindowWidgets();
 
   mitk::InteractionEventHandler::Pointer GetInteractionEventHandler() { return m_DisplayActionEventBroadcast.GetPointer(); };
 
   void ResetLayout(int row, int column);
   void Synchronize(bool synchronized);
 
   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;
 
   void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget);
   RenderWindowWidgetPointer GetActiveRenderWindowWidget() const;
   RenderWindowWidgetPointer GetFirstRenderWindowWidget() const;
   RenderWindowWidgetPointer GetLastRenderWindowWidget() const;
   
   unsigned int GetNumberOfRenderWindowWidgets() const;
 
   void RequestUpdate(const QString& widgetName);
   void RequestUpdateAll();
   void ForceImmediateUpdate(const QString& widgetName);
   void ForceImmediateUpdateAll();
 
+  void ActivateAllCrosshairs(bool activate);
   const mitk::Point3D GetSelectedPosition(const QString& widgetName) const;
 
 public Q_SLOTS:
 
   void SetSelectedPosition(const QString& widgetName, const mitk::Point3D& newPosition);
 
   // mouse events
   void wheelEvent(QWheelEvent* e) override;
 
   void mousePressEvent(QMouseEvent* e) override;
 
   void moveEvent(QMoveEvent* e) override;
 
 Q_SIGNALS:
 
   void WheelMoved(QWheelEvent *);
   void Moved();
 
 public:
 
   enum
   {
     AXIAL,
     SAGITTAL,
     CORONAL,
     THREE_D
   };
 
 private:
 
   void InitializeGUI();
   void InitializeDisplayActionEventHandling();
 
   void CreateRenderWindowWidget(const std::string& cornerAnnotation = "");
   void DestroyRenderWindowWidget();
   void FillMultiWidgetLayout();
 
   QString GetNameFromIndex(int row, int column) const;
   QString GetNameFromIndex(size_t index) const;
 
   // #TODO: see T24173
   mitk::DataNode::Pointer GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
 
   QGridLayout* m_CustomMultiWidgetLayout;
   RenderWindowWidgetMap m_RenderWindowWidgets;
 
   RenderWindowWidgetPointer m_ActiveRenderWindowWidget;
 
   int m_MultiWidgetRows;
   int m_MultiWidgetColumns;
 
   int m_PlaneMode;
 
   mitk::RenderingManager* m_RenderingManager;
   mitk::BaseRenderer::RenderingMode::Type m_RenderingMode;
   QString m_MultiWidgetName;
 
   mitk::DisplayActionEventBroadcast::Pointer m_DisplayActionEventBroadcast;
   std::unique_ptr<mitk::DisplayActionEventHandler> m_DisplayActionEventHandler;
 
   mitk::DataStorage::Pointer m_DataStorage;
 };
 
 #endif // QMITKCUSTOMMULTIWIDGET_H
diff --git a/Modules/QtWidgets/include/QmitkRenderWindowWidget.h b/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
index 0aff8a696b..2df159424c 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
@@ -1,117 +1,119 @@
 /*===================================================================
 
 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 QMITKRENDERWINDOWWIDGET_H
 #define QMITKRENDERWINDOWWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkRenderWindow.h"
 
 // mitk core
 #include <mitkDataStorage.h>
 #include <mitkPointSet.h>
 #include <mitkRenderWindow.h>
 #include <vtkMitkRectangleProp.h>
 #include <vtkCornerAnnotation.h>
 
 // qt
 #include <QWidget>
 #include <QHBoxLayout>
 
 /**
 * @brief 
 *
 *
 */
 class MITKQTWIDGETS_EXPORT QmitkRenderWindowWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkRenderWindowWidget(
     QWidget* parent = nullptr,
     const QString& widgetName = "",
     mitk::DataStorage* dataStorage = nullptr,
     mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard
   );
 
   ~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 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;
 
   /**
   * @brief Create a corner annotation and a colored rectangle for this widget.
   *
   * @par text   The text of the corner annotation.
   * @par color  The color of the text and the rectangle.
   */
   void SetDecorationProperties(std::string text, mitk::Color color);
 
   bool IsRenderWindowMenuActivated() const;
 
+  void ActivateCrosshair(bool activate);
+
 private:
 
   void InitializeGUI();
   void InitializeDecorations();
 
   void SetCrosshair(mitk::Point3D selectedPoint);
 
   QString m_WidgetName;
   QHBoxLayout* m_Layout;
 
   mitk::DataStorage* m_DataStorage;
   QmitkRenderWindow* m_RenderWindow;
 
   mitk::DataNode::Pointer m_PointSetNode;
   mitk::PointSet::Pointer m_PointSet;
 
   mitk::RenderingManager::Pointer m_RenderingManager;
   mitk::BaseRenderer::RenderingMode::Type m_RenderingMode;
   mitk::SliceNavigationController *m_TimeNavigationController;
 
   std::pair<mitk::Color, mitk::Color> m_GradientBackgroundColors;
   mitk::Color m_DecorationColor;
   vtkSmartPointer<vtkMitkRectangleProp> m_RectangleProp;
   vtkSmartPointer<vtkCornerAnnotation> m_CornerAnnotation;
 };
 
 #endif // QMITKRENDERWINDOWWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkCustomMultiWidget.cpp b/Modules/QtWidgets/src/QmitkCustomMultiWidget.cpp
index 8997ab9def..af121674ca 100644
--- a/Modules/QtWidgets/src/QmitkCustomMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkCustomMultiWidget.cpp
@@ -1,455 +1,463 @@
 /*===================================================================
 
 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 "QmitkCustomMultiWidget.h"
 
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 #include <QVBoxLayout>
 
 // mitk core
 #include <mitkDisplayActionEventFunctions.h>
 #include <mitkDisplayActionEvents.h>
 
 #include <mitkUIDGenerator.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkCameraController.h>
 #include <mitkDataStorage.h>
 #include <mitkImage.h>
 #include <mitkInteractionConst.h>
 #include <mitkLine.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkProperties.h>
 #include <mitkStatusBar.h>
 #include <mitkVtkLayerController.h>
 #include <vtkSmartPointer.h>
 
 #include <iomanip>
 
 // qt
 #include <QGridLayout>
 
 QmitkCustomMultiWidget::QmitkCustomMultiWidget(QWidget* parent,
                                                Qt::WindowFlags f/* = 0*/,
                                                mitk::RenderingManager* renderingManager/* = nullptr*/,
                                                mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/,
                                                const QString& multiWidgetName/* = "custommulti"*/)
   : QWidget(parent, f)
   , m_CustomMultiWidgetLayout(nullptr)
   , m_MultiWidgetRows(0)
   , m_MultiWidgetColumns(0)
   , m_PlaneMode(0)
   , m_RenderingManager(renderingManager)
   , m_RenderingMode(renderingMode)
   , m_MultiWidgetName(multiWidgetName)
   , m_DisplayActionEventBroadcast(nullptr)
   , m_DisplayActionEventHandler(nullptr)
   , m_DataStorage(nullptr)
 {
   // create widget manually
   // create and set layout
   InitializeGUI();
   InitializeDisplayActionEventHandling();
   resize(QSize(364, 477).expandedTo(minimumSizeHint()));
 }
 
 QmitkCustomMultiWidget::~QmitkCustomMultiWidget()
 {
   // nothing here
 }
 
 void QmitkCustomMultiWidget::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 QmitkCustomMultiWidget::InitializeRenderWindowWidgets()
 {
   // create render window widget initially
   m_MultiWidgetRows = 1;
   m_MultiWidgetColumns = 1;
   CreateRenderWindowWidget("2015-01-14 - CT");
   InitializeGUI();
 }
 
 void QmitkCustomMultiWidget::ResetLayout(int row, int column)
 {
   m_MultiWidgetRows = row;
   m_MultiWidgetColumns = column;
 
   int requiredRenderWindowWidgets = m_MultiWidgetRows * m_MultiWidgetColumns;
   int existingRenderWindowWidgets = m_RenderWindowWidgets.size();
 
   int difference = requiredRenderWindowWidgets - existingRenderWindowWidgets;
   while(0 < difference)
   {
     // more render window widgets needed
     CreateRenderWindowWidget();
     --difference;
   }
   while(0 > difference)
   {
     // less render window widgets needed
     DestroyRenderWindowWidget();
     ++difference;
   }
 
   InitializeGUI();
 }
 
 void QmitkCustomMultiWidget::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);
 }
 
 QmitkCustomMultiWidget::RenderWindowWidgetMap QmitkCustomMultiWidget::GetRenderWindowWidgets() const
 {
   return m_RenderWindowWidgets;
 }
 
 QmitkCustomMultiWidget::RenderWindowWidgetPointer QmitkCustomMultiWidget::GetRenderWindowWidget(int row, int column) const
 {
   return GetRenderWindowWidget(GetNameFromIndex(row, column));
 }
 
 QmitkCustomMultiWidget::RenderWindowWidgetPointer QmitkCustomMultiWidget::GetRenderWindowWidget(const QString& widgetName) const
 {
   RenderWindowWidgetMap::const_iterator it = m_RenderWindowWidgets.find(widgetName);
   if (it != m_RenderWindowWidgets.end())
   {
     return it->second;
   }
 
   return nullptr;
 }
 
 QmitkCustomMultiWidget::RenderWindowHash QmitkCustomMultiWidget::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* QmitkCustomMultiWidget::GetRenderWindow(int row, int column) const
 {
   return GetRenderWindow(GetNameFromIndex(row, column));
 }
 
 QmitkRenderWindow* QmitkCustomMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->GetRenderWindow();
   }
 
   return nullptr;
 }
 
 void QmitkCustomMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
 {
   m_ActiveRenderWindowWidget = activeRenderWindowWidget;
 }
 
 QmitkCustomMultiWidget::RenderWindowWidgetPointer QmitkCustomMultiWidget::GetActiveRenderWindowWidget() const
 {
   return m_ActiveRenderWindowWidget;
 }
 
 QmitkCustomMultiWidget::RenderWindowWidgetPointer QmitkCustomMultiWidget::GetFirstRenderWindowWidget() const
 {
   if (!m_RenderWindowWidgets.empty())
   {
     return m_RenderWindowWidgets.begin()->second;
   }
   else
   {
     return nullptr;
   }
 }
 
 QmitkCustomMultiWidget::RenderWindowWidgetPointer QmitkCustomMultiWidget::GetLastRenderWindowWidget() const
 {
   if (!m_RenderWindowWidgets.empty())
   {
     return m_RenderWindowWidgets.rbegin()->second;
   }
   else
   {
     return nullptr;
   }
 }
 
 unsigned int QmitkCustomMultiWidget::GetNumberOfRenderWindowWidgets() const
 {
   return m_RenderWindowWidgets.size();
 }
 
 void QmitkCustomMultiWidget::RequestUpdate(const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->RequestUpdate();
   }
 }
 
 void QmitkCustomMultiWidget::RequestUpdateAll()
 {
   for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
     renderWindowWidget.second->RequestUpdate();
   }
 }
 
 void QmitkCustomMultiWidget::ForceImmediateUpdate(const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->ForceImmediateUpdate();
   }
 }
 
 void QmitkCustomMultiWidget::ForceImmediateUpdateAll()
 {
   for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
     renderWindowWidget.second->ForceImmediateUpdate();
   }
 }
 
+void QmitkCustomMultiWidget::ActivateAllCrosshairs(bool activate)
+{
+  for (const auto& renderWindowWidget : m_RenderWindowWidgets)
+  {
+    renderWindowWidget.second->ActivateCrosshair(activate);
+  }
+}
+
 const mitk::Point3D QmitkCustomMultiWidget::GetSelectedPosition(const QString& widgetName) const
 {
   /*
   const mitk::PlaneGeometry *plane1 = mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane2 = mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane3 = mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ((plane1 != NULL) && (plane2 != NULL) && (plane1->IntersectionLine(plane2, line)))
   {
   mitk::Point3D point;
   if ((plane3 != NULL) && (plane3->IntersectionPoint(line, point)))
   {
   return point;
   }
   }
   // TODO BUG POSITIONTRACKER;
   mitk::Point3D p;
   return p;
   // return m_LastLeftClickPositionSupplier->GetCurrentPoint();
   */
   return mitk::Point3D();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PUBLIC SLOTS
 //////////////////////////////////////////////////////////////////////////
 void QmitkCustomMultiWidget::SetSelectedPosition(const QString& widgetName, const mitk::Point3D& newPosition)
 {
   RenderWindowWidgetPointer renderWindowWidget;
   if (widgetName.isNull())
   {
     renderWindowWidget = GetActiveRenderWindowWidget();
   }
   else
   {
     renderWindowWidget = GetRenderWindowWidget(widgetName);
   }
 
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
     renderWindowWidget->RequestUpdate();
     return;
   }
 
   MITK_ERROR << "Position can not be set for an unknown render window widget.";
 }
 
 //////////////////////////////////////////////////////////////////////////
 // MOUSE EVENTS
 //////////////////////////////////////////////////////////////////////////
 void QmitkCustomMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkCustomMultiWidget::mousePressEvent(QMouseEvent* e)
 {
 }
 
 void QmitkCustomMultiWidget::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 QmitkCustomMultiWidget::InitializeGUI()
 {
   delete m_CustomMultiWidgetLayout;
   m_CustomMultiWidgetLayout = new QGridLayout(this);
   m_CustomMultiWidgetLayout->setContentsMargins(0, 0, 0, 0);
   setLayout(m_CustomMultiWidgetLayout);
 
   FillMultiWidgetLayout();
 }
 
 void QmitkCustomMultiWidget::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);
 }
 
 void QmitkCustomMultiWidget::CreateRenderWindowWidget(const std::string& cornerAnnotation/* = ""*/)
 {
   // create the render window widget and connect signals / slots
   QString renderWindowWidgetName = GetNameFromIndex(m_RenderWindowWidgets.size());
   RenderWindowWidgetPointer renderWindowWidget = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, m_DataStorage);
   renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString()/*cornerAnnotation*/);
 
   // store the newly created render window widget with the UID
   m_RenderWindowWidgets.insert(std::make_pair(renderWindowWidgetName, renderWindowWidget));
 }
 
 void QmitkCustomMultiWidget::DestroyRenderWindowWidget()
 {
   auto iterator = m_RenderWindowWidgets.find(GetNameFromIndex(m_RenderWindowWidgets.size() - 1));
   if (iterator == 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_RenderWindowWidgets.erase(iterator);
 }
 
 void QmitkCustomMultiWidget::FillMultiWidgetLayout()
 {
   for (int row = 0; row < m_MultiWidgetRows; ++row)
   {
     for (int column = 0; column < m_MultiWidgetColumns; ++column)
     {
       RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(row, column);
       if (nullptr != renderWindowWidget)
       {
         m_CustomMultiWidgetLayout->addWidget(renderWindowWidget.get(), row, column);
         SetActiveRenderWindowWidget(renderWindowWidget);
       }
     }
   }
 }
 
 QString QmitkCustomMultiWidget::GetNameFromIndex(int row, int column) const
 {
   if (0 <= row && m_MultiWidgetRows > row && 0 <= column && m_MultiWidgetColumns > column)
   {
     return GetNameFromIndex(row * m_MultiWidgetColumns + column);
   }
 
   return QString();
 }
 
 QString QmitkCustomMultiWidget::GetNameFromIndex(size_t index) const
 {
   if (index <= m_RenderWindowWidgets.size())
   {
     return m_MultiWidgetName + ".widget" + QString::number(index);
   }
 
   return QString();
 }
 
 mitk::DataNode::Pointer QmitkCustomMultiWidget::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
 {
   // #TODO: see T24173
   return nodes->front();
 }
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
index 06c23b6c37..62d22d031b 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
@@ -1,225 +1,250 @@
 /*===================================================================
 
 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 "QmitkRenderWindowWidget.h"
 
 // mitk qt widgets
 #include <QmitkCustomMultiWidget.h>
 
 // vtk
 #include <vtkTextProperty.h>
 
 QmitkRenderWindowWidget::QmitkRenderWindowWidget(QWidget* parent/* = nullptr*/,
                                                  const QString& widgetName/* = ""*/,
                                                  mitk::DataStorage* dataStorage/* = nullptr*/,
                                                  mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/)
   : QWidget(parent)
   , m_WidgetName(widgetName)
   , m_DataStorage(dataStorage)
   , m_RenderingMode(renderingMode)
   , m_RenderWindow(nullptr)
   , m_PointSetNode(nullptr)
   , m_PointSet(nullptr)
 {
   InitializeGUI();
 }
 
 QmitkRenderWindowWidget::~QmitkRenderWindowWidget()
 {
   auto sliceNavigationController = m_RenderWindow->GetSliceNavigationController();
   if (nullptr != sliceNavigationController)
   {
     sliceNavigationController->SetCrosshairEvent.RemoveListener(mitk::MessageDelegate1<QmitkRenderWindowWidget, mitk::Point3D>(this, &QmitkRenderWindowWidget::SetCrosshair));
   }
   if (nullptr != m_DataStorage)
   {
     m_DataStorage->Remove(m_PointSetNode);
   }
 }
 
 void QmitkRenderWindowWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (dataStorage == m_DataStorage)
   {
     return;
   }
 
   m_DataStorage = dataStorage;
   if (nullptr != m_RenderWindow)
   {
     mitk::BaseRenderer::GetInstance(m_RenderWindow->GetRenderWindow())->SetDataStorage(dataStorage);
   }
 }
 
 mitk::SliceNavigationController* QmitkRenderWindowWidget::GetSliceNavigationController() const
 {
   return m_RenderWindow->GetSliceNavigationController();
 }
 
 void QmitkRenderWindowWidget::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(m_RenderWindow->GetRenderWindow());
 }
 
 void QmitkRenderWindowWidget::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(m_RenderWindow->GetRenderWindow());
 }
 
 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_RectangleProp->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
   m_CornerAnnotation->GetTextProperty()->SetColor(color[0], color[1], color[2]);
 }
 
 void QmitkRenderWindowWidget::ShowColoredRectangle(bool show)
 {
   m_RectangleProp->SetVisibility(show);
 }
 
 bool QmitkRenderWindowWidget::IsColoredRectangleVisible() const
 {
   return m_RectangleProp->GetVisibility() > 0;
 }
 
 void QmitkRenderWindowWidget::ShowCornerAnnotation(bool show)
 {
   m_CornerAnnotation->SetVisibility(show);
 }
 
 bool QmitkRenderWindowWidget::IsCornerAnnotationVisible() const
 {
   return m_CornerAnnotation->GetVisibility() > 0;
 }
 
 void QmitkRenderWindowWidget::SetCornerAnnotationText(const std::string& cornerAnnotation)
 {
   m_CornerAnnotation->SetText(0, cornerAnnotation.c_str());
 }
 
 std::string QmitkRenderWindowWidget::GetCornerAnnotationText() const
 {
   return std::string(m_CornerAnnotation->GetText(0));
 }
 
 bool QmitkRenderWindowWidget::IsRenderWindowMenuActivated() const
 {
   return m_RenderWindow->GetActivateMenuWidgetFlag();
 }
 
+void QmitkRenderWindowWidget::ActivateCrosshair(bool activate)
+{
+  if (nullptr == m_DataStorage)
+  {
+    return;
+  }
+
+  if (activate)
+  {
+    try
+    {
+      m_DataStorage->Add(m_PointSetNode);
+    }
+    catch(std::invalid_argument& /*e*/)
+    {
+      // crosshair already existing
+      return;
+    }
+  }
+  else
+  {
+    m_DataStorage->Remove(m_PointSetNode);
+  }
+}
+
 void QmitkRenderWindowWidget::InitializeGUI()
 {
   m_Layout = new QHBoxLayout(this);
   m_Layout->setMargin(0);
   setLayout(m_Layout);
   setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
   // create render window for this render window widget
   m_RenderingManager = mitk::RenderingManager::GetInstance();
   //m_RenderingManager = mitk::RenderingManager::New();
   m_RenderingManager->SetDataStorage(m_DataStorage);
 
   m_RenderWindow = new QmitkRenderWindow(this, m_WidgetName, nullptr, m_RenderingManager, m_RenderingMode);
   m_RenderWindow->SetLayoutIndex(QmitkCustomMultiWidget::SAGITTAL); // TODO: allow to change layout type later
   m_RenderWindow->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
   m_RenderWindow->GetSliceNavigationController()->SetRenderingManager(m_RenderingManager);
   m_RenderWindow->GetSliceNavigationController()->SetCrosshairEvent.AddListener(mitk::MessageDelegate1<QmitkRenderWindowWidget, mitk::Point3D>(this, &QmitkRenderWindowWidget::SetCrosshair));
 
   mitk::TimeGeometry::ConstPointer timeGeometry = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
   m_RenderingManager->InitializeViews(timeGeometry);
   m_Layout->addWidget(m_RenderWindow);
 
   // add point set as a crosshair
   m_PointSetNode = mitk::DataNode::New();
   m_PointSetNode->SetProperty("name", mitk::StringProperty::New("Crosshair of render window " + m_WidgetName.toStdString()));
   m_PointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true)); // crosshair-node should typically be invisible
 
   // set the crosshair only visible for this specific renderer
   m_PointSetNode->SetBoolProperty("fixedLayer", true, m_RenderWindow->GetRenderer());
   m_PointSetNode->SetVisibility(true, m_RenderWindow->GetRenderer());
   m_PointSetNode->SetVisibility(false);
 
   m_PointSet = mitk::PointSet::New();
   m_PointSetNode->SetData(m_PointSet);
 
   // set colors and corner annotation
   InitializeDecorations();
 }
 
 void QmitkRenderWindowWidget::InitializeDecorations()
 {
   vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
   if (nullptr == vtkRenderer)
   {
     return;
   }
 
   // initialize background color gradients
   float black[3] = { 0.0f, 0.0f, 0.0f };
   SetGradientBackgroundColors(black, black);
 
   // initialize decoration color, rectangle and annotation text
   float white[3] = { 1.0f, 1.0f, 1.0f };
   m_DecorationColor = white;
   m_RectangleProp = vtkSmartPointer<vtkMitkRectangleProp>::New();
   m_RectangleProp->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
   if (0 == vtkRenderer->HasViewProp(m_RectangleProp))
   {
     vtkRenderer->AddViewProp(m_RectangleProp);
   }
 
   m_CornerAnnotation = vtkSmartPointer<vtkCornerAnnotation>::New();
   m_CornerAnnotation->SetText(0, "Sagittal");
   m_CornerAnnotation->SetMaximumFontSize(12);
   m_CornerAnnotation->GetTextProperty()->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
   if (0 == vtkRenderer->HasViewProp(m_CornerAnnotation))
   {
     vtkRenderer->AddViewProp(m_CornerAnnotation);
   }
 }
 
 void QmitkRenderWindowWidget::SetCrosshair(mitk::Point3D selectedPoint)
 {
   m_PointSet->SetPoint(1, selectedPoint, 0);
   mitk::RenderingManager::GetInstance()->RequestUpdate(m_RenderWindow->GetRenderWindow());
 }
diff --git a/Plugins/org.mitk.gui.qt.custommultiwidgeteditor/src/QmitkCustomMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.custommultiwidgeteditor/src/QmitkCustomMultiWidgetEditor.cpp
index 4f73b5ca8a..aaa86bf499 100644
--- a/Plugins/org.mitk.gui.qt.custommultiwidgeteditor/src/QmitkCustomMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.custommultiwidgeteditor/src/QmitkCustomMultiWidgetEditor.cpp
@@ -1,231 +1,255 @@
 /*===================================================================
 
 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 "QmitkCustomMultiWidgetEditor.h"
 
 #include <berryIPreferencesService.h>
 #include <berryIPreferences.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIWorkbenchPartConstants.h>
 #include <berryUIException.h>
 
 // custom multi widget editor plugin
 #include "QmitkMultiWidgetDecorationManager.h"
 
 // mitk qt widgets module
 #include <QmitkCustomMultiWidget.h>
 #include <QmitkInteractionSchemeToolBar.h>
 #include <QmitkMultiWidgetConfigurationToolBar.h>
 
 const QString QmitkCustomMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.custommultiwidget";
 
 class QmitkCustomMultiWidgetEditor::Impl final
 {
 
 public:
 
   Impl();
   ~Impl();
 
   QmitkCustomMultiWidget* m_CustomMultiWidget;
   QmitkInteractionSchemeToolBar* m_InteractionSchemeToolBar;
   QmitkMultiWidgetConfigurationToolBar* m_ConfigurationToolBar;
 
   std::unique_ptr<QmitkMultiWidgetDecorationManager> m_MultiWidgetDecorationManager;
 };
 
 QmitkCustomMultiWidgetEditor::Impl::Impl()
   : m_CustomMultiWidget(nullptr)
   , m_InteractionSchemeToolBar(nullptr)
   , m_ConfigurationToolBar(nullptr)
 {
   // nothing here
 }
 
 QmitkCustomMultiWidgetEditor::Impl::~Impl()
 {
   // nothing here
 }
 
 //////////////////////////////////////////////////////////////////////////
 // QmitkCustomMultiWidgetEditor
 //////////////////////////////////////////////////////////////////////////
 QmitkCustomMultiWidgetEditor::QmitkCustomMultiWidgetEditor()
   : m_Impl(new Impl())
 {
   // nothing here
 }
 
 QmitkCustomMultiWidgetEditor::~QmitkCustomMultiWidgetEditor()
 {
-  // nothing here
+  GetSite()->GetPage()->RemovePartListener(this);
 }
 
 QmitkRenderWindow* QmitkCustomMultiWidgetEditor::GetActiveQmitkRenderWindow() const
 {
   if (nullptr != m_Impl->m_CustomMultiWidget)
   {
     auto activeRenderWindowWidget = m_Impl->m_CustomMultiWidget->GetActiveRenderWindowWidget();
     if (nullptr != activeRenderWindowWidget)
     {
       return activeRenderWindowWidget->GetRenderWindow();
     }
   }
 
   return nullptr;
 }
 
 QHash<QString, QmitkRenderWindow*> QmitkCustomMultiWidgetEditor::GetQmitkRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow*> result;
   if (nullptr == m_Impl->m_CustomMultiWidget)
   {
     return result;
   }
 
   result = m_Impl->m_CustomMultiWidget->GetRenderWindows();
   return result;
 }
 
 QmitkRenderWindow* QmitkCustomMultiWidgetEditor::GetQmitkRenderWindow(const QString& id) const
 {
   if (nullptr == m_Impl->m_CustomMultiWidget)
   {
     return nullptr;
   }
 
   return m_Impl->m_CustomMultiWidget->GetRenderWindow(id);
 }
 
 mitk::Point3D QmitkCustomMultiWidgetEditor::GetSelectedPosition(const QString& id) const
 {
   if (nullptr == m_Impl->m_CustomMultiWidget)
   {
     return mitk::Point3D();
   }
 
   return m_Impl->m_CustomMultiWidget->GetSelectedPosition(id);
 }
 
 void QmitkCustomMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D& pos, const QString& id)
 {
   if (nullptr != m_Impl->m_CustomMultiWidget)
   {
     m_Impl->m_CustomMultiWidget->SetSelectedPosition(id, pos);
   }
 }
 
 void QmitkCustomMultiWidgetEditor::EnableDecorations(bool enable, const QStringList& decorations)
 {
   m_Impl->m_MultiWidgetDecorationManager->ShowDecorations(enable, decorations);
 }
 
 bool QmitkCustomMultiWidgetEditor::IsDecorationEnabled(const QString& decoration) const
 {
   return m_Impl->m_MultiWidgetDecorationManager->IsDecorationVisible(decoration);
 }
 
 QStringList QmitkCustomMultiWidgetEditor::GetDecorations() const
 {
   return m_Impl->m_MultiWidgetDecorationManager->GetDecorations();
 }
 
+berry::IPartListener::Events::Types QmitkCustomMultiWidgetEditor::GetPartEventTypes() const
+{
+  return Events::CLOSED | Events::OPENED;
+}
+
+void QmitkCustomMultiWidgetEditor::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
+{
+  if (partRef->GetId() == QmitkCustomMultiWidgetEditor::EDITOR_ID)
+  {
+    m_Impl->m_CustomMultiWidget->ActivateAllCrosshairs(true);
+  }
+}
+
+void QmitkCustomMultiWidgetEditor::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
+{
+  if (partRef->GetId() == QmitkCustomMultiWidgetEditor::EDITOR_ID)
+  {
+    m_Impl->m_CustomMultiWidget->ActivateAllCrosshairs(false);
+  }
+}
+
 QmitkCustomMultiWidget* QmitkCustomMultiWidgetEditor::GetCustomMultiWidget()
 {
   return m_Impl->m_CustomMultiWidget;
 }
 
 void QmitkCustomMultiWidgetEditor::OnLayoutSet(int row, int column)
 {
   m_Impl->m_CustomMultiWidget->ResetLayout(row, column);
+  m_Impl->m_CustomMultiWidget->ActivateAllCrosshairs(true);
   FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
 }
 
 void QmitkCustomMultiWidgetEditor::OnSynchronize(bool synchronized)
 {
   m_Impl->m_CustomMultiWidget->Synchronize(synchronized);
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkCustomMultiWidgetEditor::SetFocus()
 {
   if (nullptr != m_Impl->m_CustomMultiWidget)
   {
     m_Impl->m_CustomMultiWidget->setFocus();
   }
 }
 
 void QmitkCustomMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   if (nullptr == m_Impl->m_CustomMultiWidget)
   {
     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));
 
     m_Impl->m_CustomMultiWidget = new QmitkCustomMultiWidget(parent, 0, 0, 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(m_Impl->m_CustomMultiWidget->GetInteractionEventHandler());
 
     // add center widget: the custom multi widget
     layout->addWidget(m_Impl->m_CustomMultiWidget);
 
     m_Impl->m_CustomMultiWidget->SetDataStorage(GetDataStorage());
     m_Impl->m_CustomMultiWidget->InitializeRenderWindowWidgets();
 
     // create right toolbar: configuration toolbar to change the render window widget layout
     if (nullptr == m_Impl->m_ConfigurationToolBar)
     {
       m_Impl->m_ConfigurationToolBar = new QmitkMultiWidgetConfigurationToolBar(m_Impl->m_CustomMultiWidget);
       layout->addWidget(m_Impl->m_ConfigurationToolBar);
     }
 
     connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::LayoutSet, this, &QmitkCustomMultiWidgetEditor::OnLayoutSet);
     connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::Synchronized, this, &QmitkCustomMultiWidgetEditor::OnSynchronize);
 
     m_Impl->m_MultiWidgetDecorationManager = std::make_unique<QmitkMultiWidgetDecorationManager>(m_Impl->m_CustomMultiWidget);
 
+    GetSite()->GetPage()->AddPartListener(this);
+
     OnPreferencesChanged(preferences);
   }
 }
 
 void QmitkCustomMultiWidgetEditor::OnPreferencesChanged(const berry::IBerryPreferences* preferences)
 {
   if (m_Impl->m_CustomMultiWidget->GetRenderWindowWidgets().empty())
   {
     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.custommultiwidgeteditor/src/QmitkCustomMultiWidgetEditor.h b/Plugins/org.mitk.gui.qt.custommultiwidgeteditor/src/QmitkCustomMultiWidgetEditor.h
index 200e70924f..c7851f5512 100644
--- a/Plugins/org.mitk.gui.qt.custommultiwidgeteditor/src/QmitkCustomMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.custommultiwidgeteditor/src/QmitkCustomMultiWidgetEditor.h
@@ -1,103 +1,119 @@
 /*===================================================================
 
 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 QMITKCUSTOMMULTIWIDGETEDITOR_H
 #define QMITKCUSTOMMULTIWIDGETEDITOR_H
 
 #include <QmitkAbstractRenderEditor.h>
 #include <mitkILinkedRenderWindowPart.h>
 
 // custom multi widget editor
 #include <org_mitk_gui_qt_custommultiwidgeteditor_Export.h>
 
+// berry
+#include <berryIPartListener.h>
+
 #include <memory>
 
 class QmitkCustomMultiWidget;
 
-class CUSTOMMULTIWIDGETEDITOR_EXPORT QmitkCustomMultiWidgetEditor final : public QmitkAbstractRenderEditor
+class CUSTOMMULTIWIDGETEDITOR_EXPORT QmitkCustomMultiWidgetEditor final : public QmitkAbstractRenderEditor, public berry::IPartListener
 {
   Q_OBJECT
 
 public:
 
   berryObjectMacro(QmitkCustomMultiWidgetEditor)
 
   static const QString EDITOR_ID;
 
   QmitkCustomMultiWidgetEditor();
   ~QmitkCustomMultiWidgetEditor();
 
   /**
   * @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
+  */
+  berry::IPartListener::Events::Types QmitkCustomMultiWidgetEditor::GetPartEventTypes() const override;
+  /**
+  * @brief Overridden from berry::IPartListener
+  */
+  void PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef) override;
+  /**
+  * @brief Overridden from berry::IPartListener
+  */
+  void PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef) override;
+
   /**
   * @brief Return the current custom multi widget of this editor.
   */
   QmitkCustomMultiWidget* GetCustomMultiWidget();
 
 private Q_SLOTS:
 
   void OnLayoutSet(int row, int column);
   void OnSynchronize(bool synchronized);
 
 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;
 
   class Impl;
   const std::unique_ptr<Impl> m_Impl;
 };
 
 #endif // QMITKCUSTOMMULTIWIDGETEDITOR_H