diff --git a/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h b/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
index 89afbcd99a..9d6de15170 100644
--- a/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
+++ b/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
@@ -1,191 +1,199 @@
 /*===================================================================
 
 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 MITKIRENDERWINDOWPART_H
 #define MITKIRENDERWINDOWPART_H
 
 #include <QString>
 #include <QStringList>
 #include <QHash>
 #include <QtPlugin>
 
 #include <mitkNumericTypes.h>
 #include <mitkRenderingManager.h>
 
 #include <org_mitk_gui_common_Export.h>
 
 class QmitkRenderWindow;
 
 namespace mitk {
 
 struct IRenderingManager;
 class SliceNavigationController;
 
 /**
  * \ingroup org_mitk_gui_common
  *
  * \brief Interface for a MITK Workbench Part providing a render window.
  *
  * This interface allows generic access to Workbench parts which provide some
  * kind of render window. The interface is intended to be implemented by
  * subclasses of berry::IWorkbenchPart. Usually, the interface is implemented
  * by a Workbench editor.
  *
  * A IRenderWindowPart provides zero or more QmitkRenderWindow instances which can
  * be controlled via this interface. QmitkRenderWindow instances have an associated
  * \e id, which is implementation specific. However, implementations should consider
  * to use one of the following ids for certain QmitkRenderWindow instances to maximize
  * reusability (they are free to map multiple ids to one QmitkRenderWindow internally):
  * <ul>
  * <li>axial</li>
  * <li>sagittal</li>
  * <li>coronal</li>
  * <li>3d</li>
  * </ul>
  *
  * \see ILinkedRenderWindowPart
  * \see IRenderWindowPartListener
  * \see QmitkAbstractRenderEditor
  */
 struct MITK_GUI_COMMON_PLUGIN IRenderWindowPart {
 
   static const QString DECORATION_BORDER; // = "border"
   static const QString DECORATION_LOGO; // = "logo"
   static const QString DECORATION_MENU; // = "menu"
   static const QString DECORATION_BACKGROUND; // = "background"
   static const QString DECORATION_CORNER_ANNOTATION; // = "corner annotation"
 
   virtual ~IRenderWindowPart();
 
   /**
    * Get the currently active (focused) render window.
    * Focus handling is implementation specific.
    *
    * \return The active QmitkRenderWindow instance; <code>nullptr</code>
    *         if no render window is active.
    */
   virtual QmitkRenderWindow* GetActiveQmitkRenderWindow() const = 0;
 
+  /**
+  * Set the currently active (focused) render window.
+  * Focus handling is implementation specific.
+  *
+  * \param id The new active render window id.
+  */
+  virtual void SetActiveQmitkRenderWindow(const QString& id) = 0;
+
   /**
    * Get all render windows with their ids.
    *
    * \return A hash map mapping the render window id to the QmitkRenderWindow instance.
    */
   virtual QHash<QString,QmitkRenderWindow*> GetQmitkRenderWindows() const  = 0;
 
   /**
    * Get a render window with a specific id.
    *
    * \param id The render window id.
    * \return The QmitkRenderWindow instance for <code>id</code>
    */
   virtual QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const = 0;
 
   /**
    * Get the rendering manager used by this render window part.
    *
    * \return The current IRenderingManager instance or <code>nullptr</code>
    *         if no rendering manager is used.
    */
   virtual mitk::IRenderingManager* GetRenderingManager() const = 0;
 
   /**
    * Request an update of all render windows.
    *
    * \param requestType Specifies the type of render windows for which an update
    *        will be requested.
    */
   virtual void RequestUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL) = 0;
 
   /**
    * Force an immediate update of all render windows.
    *
    * \param requestType Specifies the type of render windows for which an immediate update
    *        will be requested.
    */
   virtual void ForceImmediateUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL) = 0;
 
   /**
    * Get the SliceNavigationController for controlling time positions.
    *
    * \return A SliceNavigationController if the render window supports this
    *         operation; otherwise returns <code>nullptr</code>.
    */
   virtual mitk::SliceNavigationController* GetTimeNavigationController() const = 0;
 
   /**
    * Get the selected position in the render window with id <code>id</code>
    * or in the active render window if <code>id</code> is nullptr.
    *
    * \param id The render window id.
    * \return The currently selected position in world coordinates.
    */
   virtual mitk::Point3D GetSelectedPosition(const QString& id = QString()) const = 0;
 
   /**
    * Set the selected position in the render window with id <code>id</code>
    * or in the active render window if <code>id</code> is nullptr.
    *
    * \param pos The position in world coordinates which should be selected.
    * \param id The render window id in which the selection should take place.
    */
   virtual void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) = 0;
 
   /**
    * Enable \e decorations like colored borders, menu widgets, logos, text annotations, etc.
    *
    * Decorations are implementation specific. A set of standardized decoration names is listed
    * in GetDecorations().
    *
    * \param enable If <code>true</code> enable the decorations specified in <code>decorations</code>,
    *        otherwise disable them.
    * \param decorations A list of decoration names. If empty, all supported decorations are affected.
    *
    * \see GetDecorations()
    */
   virtual void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) = 0;
 
   /**
    * Return if a specific decoration is enabled.
    *
    * \return <code>true</code> if the decoration is enabled, <code>false</code> if it is disabled
    *         or unknown.
    *
    * \see GetDecorations()
    */
   virtual bool IsDecorationEnabled(const QString& decoration) const = 0;
 
   /**
    * Get a list of supported decorations.
    *
    * The following decoration names are standardized and should not be used for other decoration types:
    * <ul>
    * <li>\e DECORATION_BORDER Any border decorations like colored rectangles, etc.
    * <li>\e DECORATION_MENU Menus associated with render windows
    * <li>\e DECORATION_BACKGROUND All kinds of backgrounds (patterns, gradients, etc.) except for solid colored backgrounds
    * <li>\e DECORATION_LOGO Any kind of logo overlayed on the rendered scene
    * </ul>
    *
    * \return A list of supported decoration names.
    */
   virtual QStringList GetDecorations() const = 0;
 };
 
 }
 
 Q_DECLARE_INTERFACE(mitk::IRenderWindowPart, "org.mitk.ui.IRenderWindowPart")
 
 #endif // MITKIRENDERWINDOWPART_H
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
index bf802f1d33..9b86778e9b 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
@@ -1,248 +1,268 @@
 /*===================================================================
 
 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>
 
 const QString QmitkMxNMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.mxnmultiwidget";
 
 class QmitkMxNMultiWidgetEditor::Impl final
 {
 
 public:
 
   Impl();
   ~Impl() = default;
 
   QmitkMxNMultiWidget* m_MxNMultiWidget;
   QmitkInteractionSchemeToolBar* m_InteractionSchemeToolBar;
   QmitkMultiWidgetConfigurationToolBar* m_ConfigurationToolBar;
 
   std::unique_ptr<QmitkMultiWidgetDecorationManager> m_MultiWidgetDecorationManager;
 };
 
 QmitkMxNMultiWidgetEditor::Impl::Impl()
   : m_MxNMultiWidget(nullptr)
   , m_InteractionSchemeToolBar(nullptr)
   , m_ConfigurationToolBar(nullptr)
 {
   // nothing here
 }
 
 //////////////////////////////////////////////////////////////////////////
 // QmitkMxNMultiWidgetEditor
 //////////////////////////////////////////////////////////////////////////
 QmitkMxNMultiWidgetEditor::QmitkMxNMultiWidgetEditor()
   : m_Impl(new Impl())
 {}
 
 QmitkMxNMultiWidgetEditor::~QmitkMxNMultiWidgetEditor()
 {
   GetSite()->GetPage()->RemovePartListener(this);
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidgetEditor::GetActiveQmitkRenderWindow() const
 {
   if (nullptr != m_Impl->m_MxNMultiWidget)
   {
     auto activeRenderWindowWidget = m_Impl->m_MxNMultiWidget->GetActiveRenderWindowWidget();
     if (nullptr != activeRenderWindowWidget)
     {
       return activeRenderWindowWidget->GetRenderWindow();
     }
   }
 
   return nullptr;
 }
 
+void QmitkMxNMultiWidgetEditor::SetActiveQmitkRenderWindow(const QString& id)
+{
+  auto newActiveRenderWindow = GetQmitkRenderWindow(id);
+  if (nullptr != m_Impl->m_MxNMultiWidget)
+  {
+    // retrieve all render window widgets and find the one that holds the given render window
+    auto allRenderWindowWidgets = m_Impl->m_MxNMultiWidget->GetRenderWindowWidgets();
+    for (const auto& renderWindowWidget : allRenderWindowWidgets)
+    {
+      if (renderWindowWidget.second->GetRenderWindow() == newActiveRenderWindow)
+      {
+        // found the corresponding render window widget
+        m_Impl->m_MxNMultiWidget->SetActiveRenderWindowWidget(renderWindowWidget.second);
+        return;
+      }
+    }
+
+  }
+}
+
 QHash<QString, QmitkRenderWindow*> QmitkMxNMultiWidgetEditor::GetQmitkRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow*> result;
   if (nullptr == m_Impl->m_MxNMultiWidget)
   {
     return result;
   }
 
   result = m_Impl->m_MxNMultiWidget->GetRenderWindows();
   return result;
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidgetEditor::GetQmitkRenderWindow(const QString& id) const
 {
   if (nullptr == m_Impl->m_MxNMultiWidget)
   {
     return nullptr;
   }
 
   return m_Impl->m_MxNMultiWidget->GetRenderWindow(id);
 }
 
 mitk::Point3D QmitkMxNMultiWidgetEditor::GetSelectedPosition(const QString& id) const
 {
   if (nullptr == m_Impl->m_MxNMultiWidget)
   {
     return mitk::Point3D();
   }
 
   return m_Impl->m_MxNMultiWidget->GetSelectedPosition(id);
 }
 
 void QmitkMxNMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D& pos, const QString& id)
 {
   if (nullptr != m_Impl->m_MxNMultiWidget)
   {
     m_Impl->m_MxNMultiWidget->SetSelectedPosition(id, pos);
   }
 }
 
 void QmitkMxNMultiWidgetEditor::EnableDecorations(bool enable, const QStringList& decorations)
 {
   m_Impl->m_MultiWidgetDecorationManager->ShowDecorations(enable, decorations);
 }
 
 bool QmitkMxNMultiWidgetEditor::IsDecorationEnabled(const QString& decoration) const
 {
   return m_Impl->m_MultiWidgetDecorationManager->IsDecorationVisible(decoration);
 }
 
 QStringList QmitkMxNMultiWidgetEditor::GetDecorations() const
 {
   return m_Impl->m_MultiWidgetDecorationManager->GetDecorations();
 }
 
 berry::IPartListener::Events::Types QmitkMxNMultiWidgetEditor::GetPartEventTypes() const
 {
   return Events::CLOSED | Events::OPENED;
 }
 
 void QmitkMxNMultiWidgetEditor::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     m_Impl->m_MxNMultiWidget->ActivateAllCrosshairs(true);
   }
 }
 
 void QmitkMxNMultiWidgetEditor::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     m_Impl->m_MxNMultiWidget->ActivateAllCrosshairs(false);
   }
 }
 
 QmitkMxNMultiWidget* QmitkMxNMultiWidgetEditor::GetMxNMultiWidget()
 {
   return m_Impl->m_MxNMultiWidget;
 }
 
 void QmitkMxNMultiWidgetEditor::OnLayoutSet(int row, int column)
 {
   m_Impl->m_MxNMultiWidget->ResetLayout(row, column);
   m_Impl->m_MxNMultiWidget->ActivateAllCrosshairs(true);
   FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
 }
 
 void QmitkMxNMultiWidgetEditor::OnSynchronize(bool synchronized)
 {
   m_Impl->m_MxNMultiWidget->Synchronize(synchronized);
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidgetEditor::SetFocus()
 {
   if (nullptr != m_Impl->m_MxNMultiWidget)
   {
     m_Impl->m_MxNMultiWidget->setFocus();
   }
 }
 
 void QmitkMxNMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   if (nullptr == m_Impl->m_MxNMultiWidget)
   {
     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_MxNMultiWidget = new QmitkMxNMultiWidget(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_MxNMultiWidget->GetInteractionEventHandler());
 
     // add center widget: the mxn multi widget
     layout->addWidget(m_Impl->m_MxNMultiWidget);
 
     m_Impl->m_MxNMultiWidget->SetDataStorage(GetDataStorage());
     m_Impl->m_MxNMultiWidget->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();
       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>(m_Impl->m_MxNMultiWidget);
 
     GetSite()->GetPage()->AddPartListener(this);
 
     OnPreferencesChanged(preferences);
   }
 }
 
 void QmitkMxNMultiWidgetEditor::OnPreferencesChanged(const berry::IBerryPreferences* preferences)
 {
   if (m_Impl->m_MxNMultiWidget->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.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.h b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.h
index ea9db18593..e0c53999ec 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.h
@@ -1,118 +1,122 @@
 /*===================================================================
 
 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 <QmitkAbstractRenderEditor.h>
 #include <mitkILinkedRenderWindowPart.h>
 
 #include <org_mitk_gui_qt_mxnmultiwidgeteditor_Export.h>
 
 // berry
 #include <berryIPartListener.h>
 
 #include <memory>
 
 class QmitkMxNMultiWidget;
 
 class MXNMULTIWIDGETEDITOR_EXPORT QmitkMxNMultiWidgetEditor final : public QmitkAbstractRenderEditor, public berry::IPartListener
 {
   Q_OBJECT
 
 public:
 
   berryObjectMacro(QmitkMxNMultiWidgetEditor)
 
   static const QString EDITOR_ID;
 
   QmitkMxNMultiWidgetEditor();
   virtual ~QmitkMxNMultiWidgetEditor();
 
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
   virtual QmitkRenderWindow* GetActiveQmitkRenderWindow() const override;
   /**
   * @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
   */
+  void SetActiveQmitkRenderWindow(const QString& id) 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 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 MxN multi widget of this editor.
   */
   QmitkMxNMultiWidget* GetMxNMultiWidget();
 
 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 // QMITKMXNMULTIWIDGETEDITOR_H
diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp
index d5cdc23bca..89754598de 100644
--- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp
@@ -1,125 +1,130 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // render window manager plugin
 #include "QmitkRenderWindowManagerView.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDataNode.h>
 #include <QmitkRenderWindow.h>
 
 const std::string QmitkRenderWindowManagerView::VIEW_ID = "org.mitk.views.renderwindowmanager";
 
 void QmitkRenderWindowManagerView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart != renderWindowPart)
   {
     m_RenderWindowPart = renderWindowPart;
     SetControlledRenderer();
   }
 }
 
 void QmitkRenderWindowManagerView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart == renderWindowPart)
   {
     m_RenderWindowPart = nullptr;
     SetControlledRenderer();
   }
 }
 
 void QmitkRenderWindowManagerView::RenderWindowPartInputChanged(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart == renderWindowPart)
   {
     SetControlledRenderer();
   }
 }
 
 void QmitkRenderWindowManagerView::SetFocus()
 {
   // nothing here
 }
 
 void QmitkRenderWindowManagerView::CreateQtPartControl(QWidget* parent)
 {
   m_Parent = parent;
   // create GUI widgets
   m_Controls.setupUi(parent);
 
   // add custom render window manager UI widget to the 'renderWindowManagerTab'
   m_RenderWindowInspector = new QmitkRenderWindowDataStorageInspector(parent);
   m_RenderWindowInspector->SetDataStorage(GetDataStorage());
   m_RenderWindowInspector->setObjectName(QStringLiteral("m_RenderWindowManipulatorWidget"));
   m_Controls.verticalLayout->addWidget(m_RenderWindowInspector);
 
   // data node context menu and menu actions
   m_InspectorView = m_RenderWindowInspector->GetView();
   m_DataNodeContextMenu = new QmitkDataNodeContextMenu(GetSite(), m_InspectorView);
   m_DataNodeContextMenu->SetDataStorage(GetDataStorage());
   //m_DataNodeContextMenu->SetSurfaceDecimation(m_SurfaceDecimation);
 
   // connect objects
   connect(m_Controls.comboBoxRenderWindowSelection, static_cast<void(QComboBox::*)(const QString&)>(&QComboBox::currentIndexChanged), this, &QmitkRenderWindowManagerView::OnRenderWindowSelectionChanged);
   connect(m_InspectorView, &QAbstractItemView::customContextMenuRequested, m_DataNodeContextMenu, &QmitkDataNodeContextMenu::OnContextMenuRequested);
 
   m_RenderWindowPart = GetRenderWindowPart();
   // also sets the controlled renderer
   SetControlledRenderer();
 }
 
 void QmitkRenderWindowManagerView::SetControlledRenderer()
 {
   QHash<QString, QmitkRenderWindow*> renderWindows;
   if (m_RenderWindowPart != nullptr)
   {
     renderWindows = m_RenderWindowPart->GetQmitkRenderWindows();
   }
 
   mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer;
   QStringList rendererNames;
   m_Controls.comboBoxRenderWindowSelection->clear();
   mitk::BaseRenderer* baseRenderer = nullptr;
   for (const auto& renderWindow : renderWindows.values())
   {
     baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow());
     if (nullptr != baseRenderer)
     {
       controlledRenderer.push_back(baseRenderer);
       rendererNames.append(baseRenderer->GetName());
     }
   }
 
   m_RenderWindowInspector->SetControlledRenderer(controlledRenderer);
   rendererNames.sort();
   m_Controls.comboBoxRenderWindowSelection->addItems(rendererNames);
 }
 
 void QmitkRenderWindowManagerView::OnRenderWindowSelectionChanged(const QString& renderWindowId)
 {
+  if (nullptr != m_RenderWindowPart)
+  {
+    m_RenderWindowPart->SetActiveQmitkRenderWindow(renderWindowId);
+  }
+
   m_RenderWindowInspector->SetActiveRenderWindow(renderWindowId);
   mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(renderWindowId.toStdString());
   if (nullptr != selectedRenderer)
   {
     m_DataNodeContextMenu->SetBaseRenderer(selectedRenderer);
   }
 }
 
 QItemSelectionModel* QmitkRenderWindowManagerView::GetDataNodeSelectionModel() const
 {
   return m_InspectorView->selectionModel();
 }
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
index 5504695e80..2646ad4329 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
@@ -1,557 +1,568 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkStdMultiWidgetEditor.h"
 
 #include <berryUIException.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPartListener.h>
 #include <berryIPreferences.h>
 
 #include <QWidget>
 
 #include <mitkColorProperty.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 #include <mitkDataStorageEditorInput.h>
 #include <mitkIDataStorageService.h>
 
 #include <QmitkMouseModeSwitcher.h>
 #include <QmitkStdMultiWidget.h>
 
 class QmitkStdMultiWidgetEditorPrivate
 {
 public:
 
   QmitkStdMultiWidgetEditorPrivate();
   ~QmitkStdMultiWidgetEditorPrivate();
 
   QmitkStdMultiWidget* m_StdMultiWidget;
   QmitkMouseModeSwitcher* m_MouseModeToolbar;
   /**
   * @brief Members for the MultiWidget decorations.
   */
   QString m_WidgetBackgroundColor1[4];
   QString m_WidgetBackgroundColor2[4];
   QString m_WidgetDecorationColor[4];
   QString m_WidgetAnnotation[4];
   bool m_MenuWidgetsEnabled;
   QScopedPointer<berry::IPartListener> m_PartListener;
 
   QHash<QString, QmitkRenderWindow*> m_RenderWindows;
 
 };
 
 struct QmitkStdMultiWidgetPartListener : public berry::IPartListener
 {
   QmitkStdMultiWidgetPartListener(QmitkStdMultiWidgetEditorPrivate* dd)
     : d(dd)
   {}
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::CLOSED | Events::HIDDEN | Events::VISIBLE | Events::OPENED;
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef) override
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->RemovePlanesFromDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(false);
       }
     }
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& partRef) override
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         stdMultiWidgetEditor->RequestActivateMenuWidget(false);
       }
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& partRef) override
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         stdMultiWidgetEditor->RequestActivateMenuWidget(true);
       }
     }
   }
 
   void PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef) override
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->AddPlanesToDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(true);
       }
     }
   }
 
 private:
 
   QmitkStdMultiWidgetEditorPrivate* const d;
 
 };
 
 QmitkStdMultiWidgetEditorPrivate::QmitkStdMultiWidgetEditorPrivate()
-  : m_StdMultiWidget(nullptr), m_MouseModeToolbar(nullptr)
+  : m_StdMultiWidget(nullptr)
+  , m_MouseModeToolbar(nullptr)
   , m_MenuWidgetsEnabled(false)
   , m_PartListener(new QmitkStdMultiWidgetPartListener(this))
 {}
 
 QmitkStdMultiWidgetEditorPrivate::~QmitkStdMultiWidgetEditorPrivate()
 {
 }
 
 const QString QmitkStdMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.stdmultiwidget";
 
 QmitkStdMultiWidgetEditor::QmitkStdMultiWidgetEditor()
   : d(new QmitkStdMultiWidgetEditorPrivate)
 {
 }
 
 QmitkStdMultiWidgetEditor::~QmitkStdMultiWidgetEditor()
 {
   this->GetSite()->GetPage()->RemovePartListener(d->m_PartListener.data());
 }
 
 QmitkStdMultiWidget* QmitkStdMultiWidgetEditor::GetStdMultiWidget()
 {
   return d->m_StdMultiWidget;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetActiveQmitkRenderWindow() const
 {
-  if (d->m_StdMultiWidget) return d->m_StdMultiWidget->GetRenderWindow1();
+  if (nullptr != d->m_StdMultiWidget)
+  {
+    return d->m_StdMultiWidget->GetRenderWindow1();
+  }
+
   return nullptr;
 }
 
+void QmitkStdMultiWidgetEditor::SetActiveQmitkRenderWindow(const QString &id)
+{
+  // not allowed to set the active render window
+  // 'GetActiveQmitkRenderWindow' will always return the render window 1
+}
+
 QHash<QString, QmitkRenderWindow *> QmitkStdMultiWidgetEditor::GetQmitkRenderWindows() const
 {
   return d->m_RenderWindows;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetQmitkRenderWindow(const QString &id) const
 {
   if (d->m_RenderWindows.contains(id))
     return d->m_RenderWindows[id];
 
   return nullptr;
 }
 
 mitk::Point3D QmitkStdMultiWidgetEditor::GetSelectedPosition(const QString & /*id*/) const
 {
   return d->m_StdMultiWidget->GetCrossPosition();
 }
 
 void QmitkStdMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D &pos, const QString &/*id*/)
 {
   d->m_StdMultiWidget->MoveCrossToPosition(pos);
 }
 
 void QmitkStdMultiWidgetEditor::EnableDecorations(bool enable, const QStringList &decorations)
 {
   if (decorations.isEmpty() || decorations.contains(DECORATION_BORDER))
   {
     enable ? d->m_StdMultiWidget->EnableColoredRectangles()
            : d->m_StdMultiWidget->DisableColoredRectangles();
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_LOGO))
   {
     enable ? d->m_StdMultiWidget->EnableDepartmentLogo()
            : d->m_StdMultiWidget->DisableDepartmentLogo();
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_MENU))
   {
     d->m_StdMultiWidget->ActivateMenuWidget(enable);
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_BACKGROUND))
   {
     enable ? d->m_StdMultiWidget->EnableGradientBackground()
            : d->m_StdMultiWidget->DisableGradientBackground();
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_CORNER_ANNOTATION))
   {
     enable ? d->m_StdMultiWidget->SetCornerAnnotationVisibility(true)
            : d->m_StdMultiWidget->SetCornerAnnotationVisibility(false);
   }
 }
 
 bool QmitkStdMultiWidgetEditor::IsDecorationEnabled(const QString &decoration) const
 {
   if (decoration == DECORATION_BORDER)
   {
     return d->m_StdMultiWidget->IsColoredRectanglesEnabled();
   }
   else if (decoration == DECORATION_LOGO)
   {
     return d->m_StdMultiWidget->IsColoredRectanglesEnabled();
   }
   else if (decoration == DECORATION_MENU)
   {
     return d->m_StdMultiWidget->IsMenuWidgetEnabled();
   }
   else if (decoration == DECORATION_BACKGROUND)
   {
     return d->m_StdMultiWidget->GetGradientBackgroundFlag();
   }
   else if (decoration == DECORATION_CORNER_ANNOTATION)
   {
     return d->m_StdMultiWidget->IsCornerAnnotationVisible();
   }
 
   return false;
 }
 
 QStringList QmitkStdMultiWidgetEditor::GetDecorations() const
 {
   QStringList decorations;
   decorations << DECORATION_BORDER << DECORATION_LOGO << DECORATION_MENU << DECORATION_BACKGROUND << DECORATION_CORNER_ANNOTATION;
   return decorations;
 }
 
 void QmitkStdMultiWidgetEditor::EnableSlicingPlanes(bool enable)
 {
   d->m_StdMultiWidget->SetWidgetPlanesVisibility(enable);
 }
 
 bool QmitkStdMultiWidgetEditor::IsSlicingPlanesEnabled() const
 {
   mitk::DataNode::Pointer node = this->d->m_StdMultiWidget->GetWidgetPlane1();
   if (node.IsNotNull())
   {
     bool visible = false;
     node->GetVisibility(visible, nullptr);
     return visible;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkStdMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   if (d->m_StdMultiWidget == nullptr)
   {
     QHBoxLayout* layout = new QHBoxLayout(parent);
     layout->setContentsMargins(0,0,0,0);
 
     if (d->m_MouseModeToolbar == nullptr)
     {
       d->m_MouseModeToolbar = new QmitkMouseModeSwitcher(parent); // delete by Qt via parent
       layout->addWidget(d->m_MouseModeToolbar);
     }
 
     berry::IPreferences::Pointer prefs = this->GetPreferences();
 
     mitk::BaseRenderer::RenderingMode::Type renderingMode = static_cast<mitk::BaseRenderer::RenderingMode::Type>(prefs->GetInt( "Rendering Mode" , 0 ));
 
     d->m_StdMultiWidget = new QmitkStdMultiWidget(parent,nullptr,nullptr,renderingMode);
     d->m_RenderWindows.insert("axial", d->m_StdMultiWidget->GetRenderWindow1());
     d->m_RenderWindows.insert("sagittal", d->m_StdMultiWidget->GetRenderWindow2());
     d->m_RenderWindows.insert("coronal", d->m_StdMultiWidget->GetRenderWindow3());
     d->m_RenderWindows.insert("3d", d->m_StdMultiWidget->GetRenderWindow4());
 
     d->m_MouseModeToolbar->setMouseModeSwitcher( d->m_StdMultiWidget->GetMouseModeSwitcher() );
 
     layout->addWidget(d->m_StdMultiWidget);
 
     mitk::DataStorage::Pointer ds = this->GetDataStorage();
 
     // Tell the multiWidget which (part of) the tree to render
     d->m_StdMultiWidget->SetDataStorage(ds);
 
     // Initialize views as axial, sagittal, coronar to all data objects in DataStorage
     // (from top-left to bottom)
     auto geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
     mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 
     // Initialize bottom-right view as 3D view
     d->m_StdMultiWidget->GetRenderWindow4()->GetRenderer()->SetMapperID(
       mitk::BaseRenderer::Standard3D );
 
     // Enable standard handler for levelwindow-slider
     d->m_StdMultiWidget->EnableStandardLevelWindow();
 
     // Add the displayed views to the tree to see their positions
     // in 2D and 3D
     d->m_StdMultiWidget->AddDisplayPlaneSubTree();
 
     //d->m_StdMultiWidget->EnableNavigationControllerEventListening();
 
     // Store the initial visibility status of the menu widget.
     d->m_MenuWidgetsEnabled = d->m_StdMultiWidget->IsMenuWidgetEnabled();
 
     this->GetSite()->GetPage()->AddPartListener(d->m_PartListener.data());
 
     berry::IBerryPreferences* berryprefs = dynamic_cast<berry::IBerryPreferences*>(prefs.GetPointer());
     InitializePreferences(berryprefs);
     this->OnPreferencesChanged(berryprefs);
 
     this->RequestUpdate();
   }
 }
 
 void QmitkStdMultiWidgetEditor::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   // Enable change of logo. If no DepartmentLogo was set explicitly, MBILogo is used.
   // Set new department logo by prefs->Set("DepartmentLogo", "PathToImage");
 
   // If no logo was set for this plug-in specifically, walk the parent preference nodes
   // and lookup a logo value there.
 
   //We need to disable the logo first, otherwise setting a new logo will have no effect due to how mitkManufacturerLogo works
   d->m_StdMultiWidget->DisableDepartmentLogo();
   d->m_StdMultiWidget->SetDepartmentLogo(qPrintable(":/org.mitk.gui.qt.stdmultiwidgeteditor/defaultWatermark.png"));
   d->m_StdMultiWidget->EnableDepartmentLogo();
 
   const berry::IPreferences* currentNode = prefs;
 
   while(currentNode)
   {
     bool logoFound = false;
     foreach (const QString& key, currentNode->Keys())
     {
       if( key == "DepartmentLogo")
       {
         QString departmentLogoLocation = currentNode->Get("DepartmentLogo", "");
 
         if (departmentLogoLocation.isEmpty())
         {
           d->m_StdMultiWidget->DisableDepartmentLogo();
         }
         else
         {
           // we need to disable the logo first, otherwise setting a new logo will have
           // no effect due to how mitkManufacturerLogo works...
           d->m_StdMultiWidget->DisableDepartmentLogo();
           d->m_StdMultiWidget->SetDepartmentLogo(qPrintable(departmentLogoLocation));
           d->m_StdMultiWidget->EnableDepartmentLogo();
         }
         logoFound = true;
         break;
       }
     }
 
     if (logoFound) break;
     currentNode = currentNode->Parent().GetPointer();
   }
 
   //Update internal members
   this->FillMembersWithCurrentDecorations();
   this->GetPreferenceDecorations(prefs);
   //Now the members can be used to modify the stdmultiwidget
   mitk::Color upper = HexColorToMitkColor(d->m_WidgetBackgroundColor1[0]);
   mitk::Color lower = HexColorToMitkColor(d->m_WidgetBackgroundColor2[0]);
   d->m_StdMultiWidget->SetGradientBackgroundColorForRenderWindow(upper, lower, 0);
   upper = HexColorToMitkColor(d->m_WidgetBackgroundColor1[1]);
   lower = HexColorToMitkColor(d->m_WidgetBackgroundColor2[1]);
   d->m_StdMultiWidget->SetGradientBackgroundColorForRenderWindow(upper, lower, 1);
   upper = HexColorToMitkColor(d->m_WidgetBackgroundColor1[2]);
   lower = HexColorToMitkColor(d->m_WidgetBackgroundColor2[2]);
   d->m_StdMultiWidget->SetGradientBackgroundColorForRenderWindow(upper, lower, 2);
   upper = HexColorToMitkColor(d->m_WidgetBackgroundColor1[3]);
   lower = HexColorToMitkColor(d->m_WidgetBackgroundColor2[3]);
   d->m_StdMultiWidget->SetGradientBackgroundColorForRenderWindow(upper, lower, 3);
   d->m_StdMultiWidget->EnableGradientBackground();
 
   // preferences for renderWindows
   mitk::Color colorDecorationWidget1 = HexColorToMitkColor(d->m_WidgetDecorationColor[0]);
   mitk::Color colorDecorationWidget2 = HexColorToMitkColor(d->m_WidgetDecorationColor[1]);
   mitk::Color colorDecorationWidget3 = HexColorToMitkColor(d->m_WidgetDecorationColor[2]);
   mitk::Color colorDecorationWidget4 = HexColorToMitkColor(d->m_WidgetDecorationColor[3]);
   d->m_StdMultiWidget->SetDecorationColor(0, colorDecorationWidget1);
   d->m_StdMultiWidget->SetDecorationColor(1, colorDecorationWidget2);
   d->m_StdMultiWidget->SetDecorationColor(2, colorDecorationWidget3);
   d->m_StdMultiWidget->SetDecorationColor(3, colorDecorationWidget4);
 
   for(unsigned int i = 0; i < 4; ++i)
   {
     d->m_StdMultiWidget->SetDecorationProperties(d->m_WidgetAnnotation[i].toStdString(),
                                              HexColorToMitkColor(d->m_WidgetDecorationColor[i]), i);
   }
   //The crosshair gap
   int crosshairgapsize = prefs->GetInt("crosshair gap size", 32);
   d->m_StdMultiWidget->GetWidgetPlane1()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize);
   d->m_StdMultiWidget->GetWidgetPlane2()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize);
   d->m_StdMultiWidget->GetWidgetPlane3()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize);
 
   //refresh colors of rectangles
   d->m_StdMultiWidget->EnableColoredRectangles();
 
   // Set preferences respecting zooming and panning
   bool constrainedZooming = prefs->GetBool("Use constrained zooming and panning", true);
 
   mitk::RenderingManager::GetInstance()->SetConstrainedPanningZooming(constrainedZooming);
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   // level window setting
   bool showLevelWindowWidget = prefs->GetBool("Show level/window widget", true);
   if (showLevelWindowWidget)
   {
     d->m_StdMultiWidget->EnableStandardLevelWindow();
   }
   else
   {
     d->m_StdMultiWidget->DisableStandardLevelWindow();
   }
 
   // mouse modes toolbar
   bool newMode = prefs->GetBool("PACS like mouse interaction", false);
   d->m_MouseModeToolbar->setVisible( newMode );
   d->m_StdMultiWidget->GetMouseModeSwitcher()->SetInteractionScheme( newMode ? mitk::MouseModeSwitcher::PACS : mitk::MouseModeSwitcher::MITK );
 }
 
 mitk::Color QmitkStdMultiWidgetEditor::HexColorToMitkColor(const QString& widgetColorInHex)
 {
   QColor qColor(widgetColorInHex);
   mitk::Color returnColor;
   float colorMax = 255.0f;
   if (widgetColorInHex.isEmpty()) // default value
   {
     returnColor[0] = 1.0;
     returnColor[1] = 1.0;
     returnColor[2] = 1.0;
     MITK_ERROR << "Using default color for unknown widget " << qPrintable(widgetColorInHex);
   }
   else
   {
     returnColor[0] = qColor.red() / colorMax;
     returnColor[1] = qColor.green() / colorMax;
     returnColor[2] = qColor.blue() / colorMax;
   }
   return returnColor;
 }
 
 QString QmitkStdMultiWidgetEditor::MitkColorToHex(const mitk::Color& color)
 {
   QColor returnColor;
   float colorMax = 255.0f;
   returnColor.setRed(static_cast<int>(color[0]* colorMax + 0.5));
   returnColor.setGreen(static_cast<int>(color[1]* colorMax + 0.5));
   returnColor.setBlue(static_cast<int>(color[2]* colorMax + 0.5));
   return returnColor.name();
 }
 
 void QmitkStdMultiWidgetEditor::FillMembersWithCurrentDecorations()
 {
   //fill members with current values (or default values) from the std multi widget
   for(unsigned int i = 0; i < 4; ++i)
   {
     d->m_WidgetDecorationColor[i] = MitkColorToHex(d->m_StdMultiWidget->GetDecorationColor(i));
     d->m_WidgetBackgroundColor1[i] = MitkColorToHex(d->m_StdMultiWidget->GetGradientColors(i).first);
     d->m_WidgetBackgroundColor2[i] = MitkColorToHex(d->m_StdMultiWidget->GetGradientColors(i).second);
     d->m_WidgetAnnotation[i] = QString::fromStdString(d->m_StdMultiWidget->GetCornerAnnotationText(i));
   }
 }
 
 void QmitkStdMultiWidgetEditor::GetPreferenceDecorations(const berry::IBerryPreferences * preferences)
 {
   //overwrite members with values from the preferences, if they the prefrence is defined
   d->m_WidgetBackgroundColor1[0] = preferences->Get("widget1 first background color", d->m_WidgetBackgroundColor1[0]);
   d->m_WidgetBackgroundColor2[0] = preferences->Get("widget1 second background color", d->m_WidgetBackgroundColor2[0]);
   d->m_WidgetBackgroundColor1[1] = preferences->Get("widget2 first background color", d->m_WidgetBackgroundColor1[1]);
   d->m_WidgetBackgroundColor2[1] = preferences->Get("widget2 second background color", d->m_WidgetBackgroundColor2[1]);
   d->m_WidgetBackgroundColor1[2] = preferences->Get("widget3 first background color", d->m_WidgetBackgroundColor1[2]);
   d->m_WidgetBackgroundColor2[2] = preferences->Get("widget3 second background color", d->m_WidgetBackgroundColor2[2]);
   d->m_WidgetBackgroundColor1[3] = preferences->Get("widget4 first background color", d->m_WidgetBackgroundColor1[3]);
   d->m_WidgetBackgroundColor2[3] = preferences->Get("widget4 second background color", d->m_WidgetBackgroundColor2[3]);
 
   d->m_WidgetDecorationColor[0] = preferences->Get("widget1 decoration color", d->m_WidgetDecorationColor[0]);
   d->m_WidgetDecorationColor[1] = preferences->Get("widget2 decoration color", d->m_WidgetDecorationColor[1]);
   d->m_WidgetDecorationColor[2] = preferences->Get("widget3 decoration color", d->m_WidgetDecorationColor[2]);
   d->m_WidgetDecorationColor[3] = preferences->Get("widget4 decoration color", d->m_WidgetDecorationColor[3]);
 
   d->m_WidgetAnnotation[0] = preferences->Get("widget1 corner annotation", d->m_WidgetAnnotation[0]);
   d->m_WidgetAnnotation[1] = preferences->Get("widget2 corner annotation", d->m_WidgetAnnotation[1]);
   d->m_WidgetAnnotation[2] = preferences->Get("widget3 corner annotation", d->m_WidgetAnnotation[2]);
   d->m_WidgetAnnotation[3] = preferences->Get("widget4 corner annotation", d->m_WidgetAnnotation[3]);
 }
 
 void QmitkStdMultiWidgetEditor::InitializePreferences(berry::IBerryPreferences * preferences)
 {
   this->FillMembersWithCurrentDecorations(); //fill members
   this->GetPreferenceDecorations(preferences); //overwrite if preferences are defined
 
   //create new preferences
   preferences->Put("widget1 corner annotation", d->m_WidgetAnnotation[0]);
   preferences->Put("widget2 corner annotation", d->m_WidgetAnnotation[1]);
   preferences->Put("widget3 corner annotation", d->m_WidgetAnnotation[2]);
   preferences->Put("widget4 corner annotation", d->m_WidgetAnnotation[3]);
 
   preferences->Put("widget1 decoration color", d->m_WidgetDecorationColor[0]);
   preferences->Put("widget2 decoration color", d->m_WidgetDecorationColor[1]);
   preferences->Put("widget3 decoration color", d->m_WidgetDecorationColor[2]);
   preferences->Put("widget4 decoration color", d->m_WidgetDecorationColor[3]);
 
   preferences->Put("widget1 first background color", d->m_WidgetBackgroundColor1[0]);
   preferences->Put("widget2 first background color", d->m_WidgetBackgroundColor1[1]);
   preferences->Put("widget3 first background color", d->m_WidgetBackgroundColor1[2]);
   preferences->Put("widget4 first background color", d->m_WidgetBackgroundColor1[3]);
   preferences->Put("widget1 second background color", d->m_WidgetBackgroundColor2[0]);
   preferences->Put("widget2 second background color", d->m_WidgetBackgroundColor2[1]);
   preferences->Put("widget3 second background color", d->m_WidgetBackgroundColor2[2]);
   preferences->Put("widget4 second background color", d->m_WidgetBackgroundColor2[3]);
 }
 
 void QmitkStdMultiWidgetEditor::SetFocus()
 {
   if (d->m_StdMultiWidget != nullptr)
     d->m_StdMultiWidget->setFocus();
 }
 
 void QmitkStdMultiWidgetEditor::RequestActivateMenuWidget(bool on)
 {
   if (d->m_StdMultiWidget)
   {
     if (on)
     {
       d->m_StdMultiWidget->ActivateMenuWidget(d->m_MenuWidgetsEnabled);
     }
     else
     {
       d->m_MenuWidgetsEnabled = d->m_StdMultiWidget->IsMenuWidgetEnabled();
       d->m_StdMultiWidget->ActivateMenuWidget(false);
     }
   }
 }
 
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h
index 9c46ae9539..c1ec240e1a 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h
@@ -1,149 +1,154 @@
 /*===================================================================
 
 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 QmitkStdMultiWidgetEditor_h
 #define QmitkStdMultiWidgetEditor_h
 
 #include <QmitkAbstractRenderEditor.h>
 
 #include <mitkILinkedRenderWindowPart.h>
 
 #include <org_mitk_gui_qt_stdmultiwidgeteditor_Export.h>
 
 class QmitkStdMultiWidget;
 class QmitkMouseModeSwitcher;
 class QmitkStdMultiWidgetEditorPrivate;
 
 /**
  * \ingroup org_mitk_gui_qt_stdmultiwidgeteditor
  */
 class ORG_MITK_GUI_QT_STDMULTIWIDGETEDITOR QmitkStdMultiWidgetEditor
     : public QmitkAbstractRenderEditor, public mitk::ILinkedRenderWindowPart
 {
   Q_OBJECT
 
 public:
 
   berryObjectMacro(QmitkStdMultiWidgetEditor)
 
   static const QString EDITOR_ID;
 
   QmitkStdMultiWidgetEditor();
   ~QmitkStdMultiWidgetEditor() override;
 
   QmitkStdMultiWidget* GetStdMultiWidget();
 
   /// \brief If on=true will request the QmitkStdMultiWidget set the Menu widget to
   /// whatever was the last known enabled state, and if on=false will turn the Menu widget off.
   void RequestActivateMenuWidget(bool on);
 
   // -------------------  mitk::IRenderWindowPart  ----------------------
 
   /**
    * \see mitk::IRenderWindowPart::GetActiveQmitkRenderWindow()
    */
   QmitkRenderWindow* GetActiveQmitkRenderWindow() const override;
 
+  /**
+  * \see mitk::IRenderWindowPart::SetActiveQmitkRenderWindow()
+  */
+  void SetActiveQmitkRenderWindow(const QString& id) override;
+
   /**
    * \see mitk::IRenderWindowPart::GetQmitkRenderWindows()
    */
   QHash<QString,QmitkRenderWindow*> GetQmitkRenderWindows() const override;
 
   /**
    * \see mitk::IRenderWindowPart::GetQmitkRenderWindow(QString)
    */
   QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const override;
 
   /**
    * \see mitk::IRenderWindowPart::GetSelectionPosition()
    */
   mitk::Point3D GetSelectedPosition(const QString& id = QString()) const override;
 
   /**
    * \see mitk::IRenderWindowPart::SetSelectedPosition()
    */
   void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) override;
 
   /**
    * \see mitk::IRenderWindowPart::EnableDecorations()
    */
   void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) override;
 
   /**
    * \see mitk::IRenderWindowPart::IsDecorationEnabled()
    */
   bool IsDecorationEnabled(const QString& decoration) const override;
 
   /**
    * \see mitk::IRenderWindowPart::GetDecorations()
    */
   QStringList GetDecorations() const override;
 
   // -------------------  mitk::ILinkedRenderWindowPart  ----------------------
 
   void EnableSlicingPlanes(bool enable) override;
   bool IsSlicingPlanesEnabled() const override;
 
 
 protected:
 
   /**
    * @brief FillMembersWithCurrentDecorations Helper method to fill internal members with
    * current values of the std multi widget.
    */
   void FillMembersWithCurrentDecorations();
 
   /**
    * @brief GetPreferenceDecorations Getter to fill internal members with values of preferences.
    * @param preferences The berry preferences.
    *
    * If a preference is set, the value will overwrite the current value. If it does not exist,
    * the value will not change.
    */
   void GetPreferenceDecorations(const berry::IBerryPreferences *preferences);
 
   void SetFocus() override;
 
   void OnPreferencesChanged(const berry::IBerryPreferences*) override;
 
   void CreateQtPartControl(QWidget* parent) override;
 
   /**
    * @brief GetColorForWidget helper method to convert a saved color string to mitk::Color.
    * @param widgetColorInHex color in hex format (#12356) where each diget is in the form (0-F).
    * @return the color in mitk format.
    */
   mitk::Color HexColorToMitkColor(const QString& widgetColorInHex);
   /**
    * @brief MitkColorToHex Convert an mitk::Color to hex string.
    * @param color mitk format.
    * @return String in hex (#RRGGBB).
    */
   QString MitkColorToHex(const mitk::Color& color);
 
   /**
    * @brief InitializePreferences Internal helper method to set default preferences.
    * This method is used to show the current preferences in the first call of
    * the preference page (the GUI).
    *
    * @param preferences berry preferences.
    */
   void InitializePreferences(berry::IBerryPreferences *preferences);
 
 private:
   const QScopedPointer<QmitkStdMultiWidgetEditorPrivate> d;
 };
 #endif /*QmitkStdMultiWidgetEditor_h*/