diff --git a/Modules/QtWidgets/include/QmitkAbstractDataStorageModel.h b/Modules/QtWidgets/include/QmitkAbstractDataStorageModel.h
index 30faaec032..4ee22a0e26 100644
--- a/Modules/QtWidgets/include/QmitkAbstractDataStorageModel.h
+++ b/Modules/QtWidgets/include/QmitkAbstractDataStorageModel.h
@@ -1,92 +1,92 @@
 /*===================================================================
 
 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 QMITKABSTRACTDATASTORAGEMODEL_H
 #define QMITKABSTRACTDATASTORAGEMODEL_H
 
 #include <MitkQtWidgetsExports.h>
 
 // mitk core
 #include <mitkDataStorage.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkWeakPointer.h>
 
 // qt
 #include <QAbstractItemModel>
 
 /*
 * @brief This abstract class extends the 'QAbstractItemModel' to accept an 'mitk::DataStorage' and a 'mitk::NodePredicateBase'.
 *   It registers itself as a node event listener of the data storage.
 *   The 'QmitkAbstractDataStorageModel' provides three empty functions, 'NodeAdded', 'NodeChanged' and 'NodeRemoved', that
 *   may be implemented by subclasses. These functions allow to react to the 'AddNodeEvent', 'ChangedNodeEvent' and
 *   'RemoveNodeEvent' of the data storage. This might be useful to force an update on a custom view to correctly
 *   represent the content of the data storage.
 *
 *   A concrete implementation of this class is used to store the temporarily shown data nodes of the data storage.
 *   These nodes may be a subset of all the nodes inside the data storage, if a specific node predicate is set.
 *
 *   A model that implements this class has to return mitk::DataNode::Pointer objects for model indexes when the
 *   role is QmitkDataNodeRole.
 */
 class MITKQTWIDGETS_EXPORT QmitkAbstractDataStorageModel : public QAbstractItemModel
 {
   Q_OBJECT
 
 public:
 
   virtual ~QmitkAbstractDataStorageModel();
   /*
   * @brief Sets the data storage and adds listener for node events.
   *
   * @param dataStorage      A pointer to the data storage to set.
   */
   void SetDataStorage(mitk::DataStorage* dataStorage);
 
-  mitk::DataStorage* GetDataStorage() { return m_DataStorage.Lock().GetPointer(); }
+  mitk::DataStorage* GetDataStorage() const;
   /*
   * @brief Sets the node predicate and updates the model data, according to the node predicate.
   *
   * @param nodePredicate    A pointer to node predicate.
   */
   void SetNodePredicate(mitk::NodePredicateBase* nodePredicate);
 
-  mitk::NodePredicateBase* GetNodePredicate() { return m_NodePredicate; }
+  mitk::NodePredicateBase* GetNodePredicate() const { return m_NodePredicate; }
 
 protected:
 
   virtual void DataStorageChanged() = 0;
   virtual void NodePredicateChanged() = 0;
 
   virtual void NodeAdded(const mitk::DataNode* node) = 0;
   virtual void NodeChanged(const mitk::DataNode* node) = 0;
   virtual void NodeRemoved(const mitk::DataNode* node) = 0;
 
   QmitkAbstractDataStorageModel(QObject* parent = nullptr);
   QmitkAbstractDataStorageModel(mitk::DataStorage* dataStorage, QObject* parent = nullptr);
 
   mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
   mitk::NodePredicateBase::Pointer m_NodePredicate;
 
 private:
 
   /** Helper triggered on the storage delete event */
   void SetDataStorageDeleted();
 
   unsigned long m_DataStorageDeletedTag;
 
 };
 
 #endif // QMITKABSTRACTDATASTORAGEMODEL_H
diff --git a/Modules/QtWidgets/src/QmitkAbstractDataStorageModel.cpp b/Modules/QtWidgets/src/QmitkAbstractDataStorageModel.cpp
index 9afb4d48f6..7d16ab842f 100644
--- a/Modules/QtWidgets/src/QmitkAbstractDataStorageModel.cpp
+++ b/Modules/QtWidgets/src/QmitkAbstractDataStorageModel.cpp
@@ -1,115 +1,125 @@
 /*===================================================================
 
 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 <QmitkAbstractDataStorageModel.h>
 
 QmitkAbstractDataStorageModel::QmitkAbstractDataStorageModel(QObject* parent/* = nullptr*/)
   : QAbstractItemModel(parent)
   , m_DataStorage(nullptr)
   , m_NodePredicate(nullptr)
 {
   // nothing here
 }
 
 QmitkAbstractDataStorageModel::QmitkAbstractDataStorageModel(mitk::DataStorage* dataStorage, QObject* parent/* = nullptr*/)
   : QAbstractItemModel(parent)
   , m_DataStorage(nullptr)
   , m_NodePredicate(nullptr)
 {
   SetDataStorage(dataStorage);
 }
 
 QmitkAbstractDataStorageModel::~QmitkAbstractDataStorageModel()
 {
   if (!m_DataStorage.IsExpired())
   {
     auto dataStorage = m_DataStorage.Lock();
 
     // remove Listener for the data storage itself
     dataStorage->RemoveObserver(m_DataStorageDeletedTag);
 
     // remove listener from data storage
     dataStorage->AddNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
     dataStorage->RemoveNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
     dataStorage->ChangedNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
   }
 }
 
 void QmitkAbstractDataStorageModel::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage == dataStorage)
   {
     return;
   }
 
   if (!m_DataStorage.IsExpired())
   {
     auto dataStorage = m_DataStorage.Lock();
 
     // remove Listener for the data storage itself
     dataStorage->RemoveObserver(m_DataStorageDeletedTag);
 
     // remove listener from old data storage
     dataStorage->AddNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
     dataStorage->RemoveNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
     dataStorage->ChangedNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
   }
 
   m_DataStorage = dataStorage;
 
   if (!m_DataStorage.IsExpired())
   {
     auto dataStorage = m_DataStorage.Lock();
 
     // add Listener for the data storage itself
     auto command = itk::SimpleMemberCommand<QmitkAbstractDataStorageModel>::New();
     command->SetCallbackFunction(this, &QmitkAbstractDataStorageModel::SetDataStorageDeleted);
     m_DataStorageDeletedTag = dataStorage->AddObserver(itk::DeleteEvent(), command);
 
     // add listener for new data storage
     dataStorage->AddNodeEvent.AddListener(
       mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
     dataStorage->RemoveNodeEvent.AddListener(
       mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
     dataStorage->ChangedNodeEvent.AddListener(
       mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
   }
   // update model if the data storage has been changed
   DataStorageChanged();
 }
 
+mitk::DataStorage* QmitkAbstractDataStorageModel::GetDataStorage() const
+{
+  if (m_DataStorage.IsExpired())
+  {
+    return nullptr;
+  }
+
+  return m_DataStorage.Lock().GetPointer();
+}
+
 void QmitkAbstractDataStorageModel::SetDataStorageDeleted()
 {
   this->SetDataStorage(nullptr);
 }
 
 void QmitkAbstractDataStorageModel::SetNodePredicate(mitk::NodePredicateBase* nodePredicate)
 {
   if (m_NodePredicate == nodePredicate)
   {
     return;
   }
 
   m_NodePredicate = nodePredicate;
   // update model if the node predicate has been changed
   NodePredicateChanged();
 }
diff --git a/Modules/RenderWindowManagerUI/include/QmitkDataStorageRenderWindowListModel.h b/Modules/RenderWindowManagerUI/include/QmitkDataStorageRenderWindowListModel.h
index 76340f4474..f044b1fc88 100644
--- a/Modules/RenderWindowManagerUI/include/QmitkDataStorageRenderWindowListModel.h
+++ b/Modules/RenderWindowManagerUI/include/QmitkDataStorageRenderWindowListModel.h
@@ -1,109 +1,109 @@
 /*===================================================================
 
 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 QMITKDATASTORAGERENDERWINDOWLISTMODEL_H
 #define QMITKDATASTORAGERENDERWINDOWLISTMODEL_H
 
 // render window manager UI model
 #include "MitkRenderWindowManagerUIExports.h"
 
 // render window manager module
 #include "mitkRenderWindowLayerController.h"
 #include "mitkRenderWindowLayerUtilities.h"
 
 //mitk core
 #include <mitkBaseRenderer.h>
 
 // qt widgets module
 #include <QmitkAbstractDataStorageModel.h>
 
 /*
 * @brief The 'QmitkDataStorageRenderWindowListModel' is a list model derived from the 'QmitkAbstractDataStorageModel'.
 */
 class MITKRENDERWINDOWMANAGERUI_EXPORT QmitkDataStorageRenderWindowListModel : public QmitkAbstractDataStorageModel
 {
   Q_OBJECT
 
 public:
 
   QmitkDataStorageRenderWindowListModel(QObject* parent = nullptr);
   ~QmitkDataStorageRenderWindowListModel() override;
 
   // override from 'QmitkAbstractDataStorageModel'
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void DataStorageChanged() override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodePredicateChanged() override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeAdded(const mitk::DataNode* node) override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeChanged(const mitk::DataNode* node) override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeRemoved(const mitk::DataNode* node) override;
 
   // override from 'QAbstractItemModel'
   QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
   QModelIndex parent(const QModelIndex& child) const override;
 
   int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   int columnCount(const QModelIndex& parent = QModelIndex()) const override;
 
   QVariant data(const QModelIndex& index, int role) const override;
   bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
 
   Qt::ItemFlags flags(const QModelIndex& index) const override;
 
   Qt::DropActions supportedDropActions() const override;
   Qt::DropActions supportedDragActions() const override;
   QStringList mimeTypes() const override;
   QMimeData* mimeData(const QModelIndexList& indexes) const override;
 
   bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override;
 
   void SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer);
 
   void SetCurrentRenderer(mitk::BaseRenderer* baseRenderer);
-  mitk::BaseRenderer* GetCurrentRenderer() const { return m_BaseRenderer.GetPointer(); }
+  mitk::BaseRenderer* GetCurrentRenderer() const;
 
   /**
   * @brief Use the RenderWindowLayerController to insert the given data node into all controlled render windows.
   *        The new node is placed on top of all existing layer nodes in the render window.
   *
   * @param dataNode   The data node that should be inserted.
   */
   void AddDataNodeToAllRenderer(mitk::DataNode* dataNode);
 
 private:
 
   void UpdateModelData();
 
   std::unique_ptr<mitk::RenderWindowLayerController> m_RenderWindowLayerController;
-  mitk::BaseRenderer::Pointer m_BaseRenderer;
+  mitk::WeakPointer<mitk::BaseRenderer> m_BaseRenderer;
   mitk::RenderWindowLayerUtilities::LayerStack m_LayerStack;
 
 };
 
 #endif // QMITKDATASTORAGERENDERWINDOWLISTMODEL_H
diff --git a/Modules/RenderWindowManagerUI/src/QmitkDataStorageRenderWindowListModel.cpp b/Modules/RenderWindowManagerUI/src/QmitkDataStorageRenderWindowListModel.cpp
index a4b68f678d..4b2592ab09 100644
--- a/Modules/RenderWindowManagerUI/src/QmitkDataStorageRenderWindowListModel.cpp
+++ b/Modules/RenderWindowManagerUI/src/QmitkDataStorageRenderWindowListModel.cpp
@@ -1,327 +1,364 @@
 /*===================================================================
 
 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 UI module
 #include "QmitkDataStorageRenderWindowListModel.h"
 
 // qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 #include "QmitkMimeTypes.h"
 #include "QmitkNodeDescriptorManager.h"
 
 QmitkDataStorageRenderWindowListModel::QmitkDataStorageRenderWindowListModel(QObject* parent /*= nullptr*/)
   : QmitkAbstractDataStorageModel(parent)
 {
   m_RenderWindowLayerController = std::make_unique<mitk::RenderWindowLayerController>();
 }
 
 QmitkDataStorageRenderWindowListModel::~QmitkDataStorageRenderWindowListModel()
 {
   // nothing here
 }
 
 void QmitkDataStorageRenderWindowListModel::DataStorageChanged()
 {
   m_RenderWindowLayerController->SetDataStorage(m_DataStorage.Lock());
   UpdateModelData();
 }
 
 void QmitkDataStorageRenderWindowListModel::NodePredicateChanged()
 {
   UpdateModelData();
 }
 
 void QmitkDataStorageRenderWindowListModel::NodeAdded(const mitk::DataNode* node)
 {
   // add a node to each render window specific list (or to a global list initially)
   AddDataNodeToAllRenderer(const_cast<mitk::DataNode*>(node));
   UpdateModelData();
 }
 
 void QmitkDataStorageRenderWindowListModel::NodeChanged(const mitk::DataNode* /*node*/)
 {
   // nothing here, since the "'NodeChanged'-event is currently sent far too often
   //UpdateModelData();
 }
 
 void QmitkDataStorageRenderWindowListModel::NodeRemoved(const mitk::DataNode* /*node*/)
 {
   // update model data to create a new list without the removed data node
   UpdateModelData();
 }
 
 QModelIndex QmitkDataStorageRenderWindowListModel::index(int row, int column, const QModelIndex& parent) const
 {
   bool hasIndex = this->hasIndex(row, column, parent);
   if (hasIndex)
   {
     return this->createIndex(row, column);
   }
 
   return QModelIndex();
 }
 
 QModelIndex QmitkDataStorageRenderWindowListModel::parent(const QModelIndex& /*child*/) const
 {
   return QModelIndex();
 }
 
 int QmitkDataStorageRenderWindowListModel::rowCount(const QModelIndex& parent /*= QModelIndex()*/) const
 {
   if (parent.isValid())
   {
     return 0;
   }
 
   return static_cast<int>(m_LayerStack.size());
 }
 
 int QmitkDataStorageRenderWindowListModel::columnCount(const QModelIndex& parent /*= QModelIndex()*/) const
 {
   if (parent.isValid())
   {
     return 0;
   }
 
   return 1;
 }
 
 QVariant QmitkDataStorageRenderWindowListModel::data(const QModelIndex& index, int role) const
 {
+  if (m_BaseRenderer.IsExpired())
+  {
+    return QVariant();
+  }
+
+  auto baseRenderer = m_BaseRenderer.Lock();
+
   if (!index.isValid() || this != index.model())
   {
     return QVariant();
   }
 
   if (index.row() < 0 || index.row() >= static_cast<int>(m_LayerStack.size()))
   {
     return QVariant();
   }
 
   mitk::RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIt = m_LayerStack.begin();
   std::advance(layerStackIt, index.row());
   mitk::DataNode* dataNode = layerStackIt->second;
 
   if (Qt::CheckStateRole == role)
   {
     bool visibility = false;
-    dataNode->GetVisibility(visibility, m_BaseRenderer);
+    dataNode->GetVisibility(visibility, baseRenderer);
     if (visibility)
     {
       return Qt::Checked;
     }
     else
     {
       return Qt::Unchecked;
     }
   }
   else if (Qt::DisplayRole == role)
   {
     return QVariant(QString::fromStdString(dataNode->GetName()));
   }
   else if (Qt::ToolTipRole == role)
   {
     return QVariant("Name of the data node.");
   }
   else if (Qt::DecorationRole == role)
   {
     QmitkNodeDescriptor* nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
     return nodeDescriptor->GetIcon(dataNode);
   }
   else if (Qt::UserRole == role || QmitkDataNodeRawPointerRole == role)
   {
     // user role always returns a reference to the data node,
     // which can be used to modify the data node in the data storage
     return QVariant::fromValue<mitk::DataNode*>(dataNode);
   }
   else if (QmitkDataNodeRole == role)
   {
     return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
   }
 
   return QVariant();
 }
 
 bool QmitkDataStorageRenderWindowListModel::setData(const QModelIndex& index, const QVariant& value, int role /*= Qt::EditRole*/)
 {
+  if (m_BaseRenderer.IsExpired())
+  {
+    return false;
+  }
+
+  auto baseRenderer = m_BaseRenderer.Lock();
+
   if (!index.isValid() || this != index.model())
   {
     return false;
   }
 
   if (index.row() < 0 || index.row() >= static_cast<int>(m_LayerStack.size()))
   {
     return false;
   }
 
   mitk::RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIt = m_LayerStack.begin();
   std::advance(layerStackIt, index.row());
   mitk::DataNode* dataNode = layerStackIt->second;
   if (Qt::CheckStateRole == role)
   {
     Qt::CheckState newCheckState = static_cast<Qt::CheckState>(value.toInt());
     bool isVisible = newCheckState;
-    dataNode->SetVisibility(isVisible, m_BaseRenderer);
+    dataNode->SetVisibility(isVisible, baseRenderer);
 
     emit dataChanged(index, index);
-    mitk::RenderingManager::GetInstance()->RequestUpdate(m_BaseRenderer->GetRenderWindow());
+    mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
     return true;
   }
   return false;
 }
 
 Qt::ItemFlags QmitkDataStorageRenderWindowListModel::flags(const QModelIndex &index) const
 {
   if (this != index.model())
   {
     return Qt::NoItemFlags;
   }
 
   if (!index.isValid())
   {
     return Qt::ItemIsDropEnabled;
   }
 
   return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
 }
 
 Qt::DropActions QmitkDataStorageRenderWindowListModel::supportedDropActions() const
 {
   return Qt::CopyAction | Qt::MoveAction;
 }
 
 Qt::DropActions QmitkDataStorageRenderWindowListModel::supportedDragActions() const
 {
   return Qt::CopyAction | Qt::MoveAction;
 }
 
 QStringList QmitkDataStorageRenderWindowListModel::mimeTypes() const
 {
   QStringList types = QAbstractItemModel::mimeTypes();
   types << QmitkMimeTypes::DataNodePtrs;
   return types;
 }
 
 QMimeData* QmitkDataStorageRenderWindowListModel::mimeData(const QModelIndexList& indexes) const
 {
   QMimeData* mimeData = new QMimeData();
   QByteArray encodedData;
 
   QDataStream stream(&encodedData, QIODevice::WriteOnly);
 
   for (const auto& index : indexes)
   {
     if (index.isValid())
     {
       auto dataNode = data(index, QmitkDataNodeRawPointerRole).value<mitk::DataNode*>();
       stream << reinterpret_cast<quintptr>(dataNode);
     }
   }
 
   mimeData->setData(QmitkMimeTypes::DataNodePtrs, encodedData);
   return mimeData;
 }
 
 bool QmitkDataStorageRenderWindowListModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)
 {
+  if (m_BaseRenderer.IsExpired())
+  {
+    return false;
+  }
+
+  auto baseRenderer = m_BaseRenderer.Lock();
+
   if (action == Qt::IgnoreAction)
   {
     return true;
   }
 
   if (!data->hasFormat(QmitkMimeTypes::DataNodePtrs))
   {
     return false;
   }
 
   if (column > 0)
   {
     return false;
   }
 
   if (parent.isValid())
   {
     int layer = -1;
     auto dataNode = this->data(parent, QmitkDataNodeRawPointerRole).value<mitk::DataNode*>();
     if (nullptr != dataNode)
     {
-      dataNode->GetIntProperty("layer", layer, m_BaseRenderer);
+      dataNode->GetIntProperty("layer", layer, baseRenderer);
     }
 
     auto dataNodeList = QmitkMimeTypes::ToDataNodePtrList(data);
     for (const auto& dataNode : dataNodeList)
     {
-      m_RenderWindowLayerController->MoveNodeToPosition(dataNode, layer, m_BaseRenderer);
+      m_RenderWindowLayerController->MoveNodeToPosition(dataNode, layer, baseRenderer);
     }
 
     UpdateModelData();
     return true;
   }
 
   return false;
 }
 
 void QmitkDataStorageRenderWindowListModel::SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer)
 {
   m_RenderWindowLayerController->SetControlledRenderer(controlledRenderer);
 
   if (!m_DataStorage.IsExpired())
   {
     auto dataStorage = m_DataStorage.Lock();
     mitk::DataStorage::SetOfObjects::ConstPointer allDataNodes = dataStorage->GetAll();
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = allDataNodes->Begin(); it != allDataNodes->End(); ++it)
     {
       mitk::DataNode::Pointer dataNode = it->Value();
       if (dataNode.IsNull())
       {
         continue;
       }
 
       AddDataNodeToAllRenderer(dataNode);
     }
   }
 }
 
 void QmitkDataStorageRenderWindowListModel::SetCurrentRenderer(mitk::BaseRenderer* baseRenderer)
 {
-  if (m_BaseRenderer != baseRenderer)
+  if (m_BaseRenderer == baseRenderer)
+  {
+    return;
+  }
+
+  m_BaseRenderer = baseRenderer;
+  if (!m_BaseRenderer.IsExpired())
   {
-    m_BaseRenderer = baseRenderer;
     UpdateModelData();
   }
 }
 
+mitk::BaseRenderer* QmitkDataStorageRenderWindowListModel::GetCurrentRenderer() const
+{
+  if (m_BaseRenderer.IsExpired())
+  {
+    return nullptr;
+  }
+
+  return m_BaseRenderer.Lock().GetPointer();
+}
+
 void QmitkDataStorageRenderWindowListModel::AddDataNodeToAllRenderer(mitk::DataNode* dataNode)
 {
   m_RenderWindowLayerController->InsertLayerNode(dataNode);
 }
 
 void QmitkDataStorageRenderWindowListModel::UpdateModelData()
 {
   if (!m_DataStorage.IsExpired())
   {
     auto dataStorage = m_DataStorage.Lock();
-    if (m_BaseRenderer.IsNotNull())
+    if (!m_BaseRenderer.IsExpired())
     {
+      auto baseRenderer = m_BaseRenderer.Lock();
       // update the model, so that it will be filled with the nodes of the new data storage
       beginResetModel();
       // get the current layer stack of the given base renderer
-      m_LayerStack = mitk::RenderWindowLayerUtilities::GetLayerStack(dataStorage, m_BaseRenderer, true);
+      m_LayerStack = mitk::RenderWindowLayerUtilities::GetLayerStack(dataStorage, baseRenderer, true);
       endResetModel();
     }
   }
 }
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 e1b67d83d0..a3d0fe7818 100644
--- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp
@@ -1,127 +1,127 @@
 /*===================================================================
 
 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>
 
 // qt
 #include <QGlobal.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)
 {
   // create GUI widgets
   m_Controls.setupUi(parent);
 
   // add custom render window manager UI widget to the 'renderWindowManagerTab'
   m_RenderWindowInspector = new QmitkDataStorageRenderWindowInspector(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 objects
   connect(m_Controls.comboBoxRenderWindowSelection, QOverload<const QString&>::of(&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)
 {
   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();
 }