diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
index 2ca0acb543..8124d9e6be 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
@@ -1,96 +1,106 @@
 /*===================================================================
 
 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 <QmitkAbstractDataNodeAction.h>
 
 #include "mitkIRenderWindowPart.h"
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // berry
 #include <berryIWorkbenchPage.h>
 
 QmitkAbstractDataNodeAction::QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer workbenchPartSite)
 {
   m_WorkbenchPartSite = workbenchPartSite;
 }
 
 QmitkAbstractDataNodeAction::QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite* workbenchPartSite)
 {
   m_WorkbenchPartSite = berry::IWorkbenchPartSite::Pointer(workbenchPartSite);
 }
 
 QmitkAbstractDataNodeAction::~QmitkAbstractDataNodeAction()
 {
   // nothing here
 }
 
 void QmitkAbstractDataNodeAction::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage != dataStorage)
   {
     // set the new data storage
     m_DataStorage = dataStorage;
   }
 }
 
 void QmitkAbstractDataNodeAction::SetBaseRenderer(mitk::BaseRenderer* baseRenderer)
 {
   if (m_BaseRenderer != baseRenderer)
   {
     // set the new base renderer
     m_BaseRenderer = baseRenderer;
   }
 }
 
+mitk::BaseRenderer::Pointer QmitkAbstractDataNodeAction::GetBaseRenderer()
+{
+  mitk::BaseRenderer::Pointer baseRenderer;
+  if (!m_BaseRenderer.IsExpired())
+  {
+    baseRenderer = m_BaseRenderer.Lock();
+  }
+  return baseRenderer;
+}
+
 QList<mitk::DataNode::Pointer> QmitkAbstractDataNodeAction::GetSelectedNodes()
 {
   QList<mitk::DataNode::Pointer> selectedNodes;
   if (m_WorkbenchPartSite.Expired())
   {
     return selectedNodes;
   }
 
   berry::ISelection::ConstPointer selection = m_WorkbenchPartSite.Lock()->GetWorkbenchWindow()->GetSelectionService()->GetSelection();
   mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
 
   if (currentSelection.IsNull() || currentSelection->IsEmpty())
   {
     return selectedNodes;
   }
 
   selectedNodes = QList<mitk::DataNode::Pointer>::fromStdList(currentSelection->GetSelectedDataNodes());
   return selectedNodes;
 }
 
 mitk::DataNode::Pointer QmitkAbstractDataNodeAction::GetSelectedNode()
 {
   QList<mitk::DataNode::Pointer> selectedNodes = GetSelectedNodes();
   if (selectedNodes.empty())
   {
     return nullptr;
   }
 
   // no batch action; should only be called with a single node
   mitk::DataNode::Pointer dataNode = selectedNodes.front();
   if (nullptr == dataNode)
   {
     return nullptr;
   }
 
   return dataNode;
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.h b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.h
index b8e8986a9e..05280298d1 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.h
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.h
@@ -1,60 +1,70 @@
 /*===================================================================
 
 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 QMITKABSTRACTDATANODEACTION_H
 #define QMITKABSTRACTDATANODEACTION_H
 
 #include <org_mitk_gui_qt_application_Export.h>
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDataStorage.h>
 #include <mitkWeakPointer.h>
 
 // berry
 #include <berryIWorkbenchPartSite.h>
 
 // qt
 #include <QList>
 
 class MITK_QT_APP QmitkAbstractDataNodeAction
 {
 
 public:
 
   QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer workbenchPartSite);
   QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite* workbenchPartSite);
 
   virtual ~QmitkAbstractDataNodeAction();
 
   void SetDataStorage(mitk::DataStorage* dataStorage);
   void SetBaseRenderer(mitk::BaseRenderer* baseRenderer);
 
   virtual void InitializeWithDataNode(const mitk::DataNode*) { }
 
 protected:
 
   virtual void InitializeAction() = 0;
+
+  /**
+  * @brief Grants access to the base renderer stored for the action.
+  *        Will return nullptr if renderer was never set or has become invalid
+  */
+  mitk::BaseRenderer::Pointer GetBaseRenderer();
+
   mitk::DataNode::Pointer GetSelectedNode();
   QList<mitk::DataNode::Pointer> GetSelectedNodes();
 
   berry::IWorkbenchPartSite::WeakPtr m_WorkbenchPartSite;
   mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
+
+private:
+
   mitk::WeakPointer<mitk::BaseRenderer> m_BaseRenderer;
 
 };
 
 #endif // QMITKABSTRACTDATANODEACTION_H
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeColorAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeColorAction.cpp
index fa7241c84d..03485b2e0e 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeColorAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeColorAction.cpp
@@ -1,162 +1,146 @@
 /*===================================================================
 
 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 <QmitkDataNodeColorAction.h>
 
 // mitk core
 #include <mitkRenderingManager.h>
 
 // qt
 #include <QColorDialog>
 #include <QHBoxLayout>
 #include <QLabel>
 
 QmitkDataNodeColorAction::QmitkDataNodeColorAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QWidgetAction(parent)
   , QmitkAbstractDataNodeAction(workbenchPartSite)
 {
   InitializeAction();
 }
 
 QmitkDataNodeColorAction::QmitkDataNodeColorAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QWidgetAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   InitializeAction();
 }
 
 QmitkDataNodeColorAction::~QmitkDataNodeColorAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeColorAction::InitializeAction()
 {
   m_ColorButton = new QPushButton;
   m_ColorButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
   connect(m_ColorButton, &QPushButton::clicked, this, &QmitkDataNodeColorAction::OnColorChanged);
 
   QLabel* colorLabel = new QLabel(tr("Color: "));
   colorLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
   QHBoxLayout* colorWidgetLayout = new QHBoxLayout;
   colorWidgetLayout->setContentsMargins(4, 4, 4, 4);
   colorWidgetLayout->addWidget(colorLabel);
   colorWidgetLayout->addWidget(m_ColorButton);
 
   QWidget* colorWidget = new QWidget;
   colorWidget->setLayout(colorWidgetLayout);
 
   setDefaultWidget(colorWidget);
 
   connect(this, &QmitkDataNodeColorAction::changed, this, &QmitkDataNodeColorAction::OnActionChanged);
 }
 
 void QmitkDataNodeColorAction::InitializeWithDataNode(const mitk::DataNode* dataNode)
 {
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   float rgb[3];
   if (dataNode->GetColor(rgb, baseRenderer))
   {
     QColor color(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255);
     QString styleSheet = QString("background-color: ") + color.name(QColor::HexRgb);
     m_ColorButton->setAutoFillBackground(true);
     m_ColorButton->setStyleSheet(styleSheet);
   }
 }
 
 void QmitkDataNodeColorAction::OnColorChanged()
 {
   auto dataNodes = GetSelectedNodes();
   if (dataNodes.isEmpty())
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   bool selectedColor = false;
   QColor newColor;
 
   for (auto& dataNode : dataNodes)
   {
     if (dataNode.IsNull())
     {
       continue;
     }
 
     float rgb[3];
     if (dataNode->GetColor(rgb, baseRenderer))
     {
       if (!selectedColor)
       {
         QColor initial(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255);
         newColor = QColorDialog::getColor(initial, nullptr, QString(tr("Change color")));
 
         if (newColor.isValid())
         {
           selectedColor = true;
         }
         else
         {
           return;
         }
       }
 
       dataNode->SetProperty("color", mitk::ColorProperty::New(newColor.redF(), newColor.greenF(), newColor.blueF()), baseRenderer);
       if (dataNode->GetProperty("binaryimage.selectedcolor", baseRenderer))
       {
         dataNode->SetProperty("binaryimage.selectedcolor", mitk::ColorProperty::New(newColor.redF(), newColor.greenF(), newColor.blueF()), baseRenderer);
       }
     }
   }
 
   if (nullptr == baseRenderer)
   {
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else
   {
     mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
   }
 }
 
 void QmitkDataNodeColorAction::OnActionChanged()
 {
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
   InitializeWithDataNode(dataNode);
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeColorMapAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeColorMapAction.cpp
index 93210a4fb5..82893068be 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeColorMapAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeColorMapAction.cpp
@@ -1,168 +1,152 @@
 /*===================================================================
 
 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 <QmitkDataNodeColorMapAction.h>
 
 // mitk core
 #include <mitkDataNode.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkLookupTable.h>
 #include <mitkRenderingManager.h>
 #include <mitkRenderingModeProperty.h>
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // berry
 #include <berryISelectionService.h>
 
 // qt
 #include <QMenu>
 
 QmitkDataNodeColorMapAction::QmitkDataNodeColorMapAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Colormap"));
   InitializeAction();
 }
 
 QmitkDataNodeColorMapAction::QmitkDataNodeColorMapAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Colormap"));
   InitializeAction();
 }
 
 QmitkDataNodeColorMapAction::~QmitkDataNodeColorMapAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeColorMapAction::InitializeAction()
 {
   setCheckable(true);
 
   setMenu(new QMenu);
   connect(menu(), &QMenu::aboutToShow, this, &QmitkDataNodeColorMapAction::OnMenuAboutShow);
 }
 
 void QmitkDataNodeColorMapAction::OnMenuAboutShow()
 {
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   mitk::LookupTableProperty::Pointer lookupTableProperty = dynamic_cast<mitk::LookupTableProperty*>(dataNode->GetProperty("LookupTable", baseRenderer));
   if (lookupTableProperty.IsNull())
   {
     mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
     lookupTableProperty = mitk::LookupTableProperty::New();
     lookupTableProperty->SetLookupTable(mitkLut);
     dataNode->SetProperty("LookupTable", lookupTableProperty, baseRenderer);
   }
 
   mitk::LookupTable::Pointer lookupTable = lookupTableProperty->GetValue();
   if (lookupTable.IsNull())
   {
     return;
   }
 
   menu()->clear();
 
   QAction* lutAction;
   for (const auto& lutTypeString : lookupTable->typenameList)
   {
     lutAction = menu()->addAction(QString::fromStdString(lutTypeString));
     lutAction->setCheckable(true);
 
     if (lutTypeString == lookupTable->GetActiveTypeAsString())
     {
       lutAction->setChecked(true);
     }
 
     connect(lutAction, &QAction::triggered, this, &QmitkDataNodeColorMapAction::OnActionTriggered);
   }
 }
 
 void QmitkDataNodeColorMapAction::OnActionTriggered(bool /*checked*/)
 {
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   mitk::LookupTableProperty::Pointer lookupTableProperty = dynamic_cast<mitk::LookupTableProperty*>(dataNode->GetProperty("LookupTable", baseRenderer));
   if (lookupTableProperty.IsNull())
   {
     return;
   }
 
   mitk::LookupTable::Pointer lookupTable = lookupTableProperty->GetValue();
   if (lookupTable.IsNull())
   {
     return;
   }
 
   mitk::LookupTable::Pointer renderWindowSpecificLutTab = lookupTable->Clone();
 
   QAction* senderAction = qobject_cast<QAction*>(QObject::sender());
   if (nullptr == senderAction)
   {
     return;
   }
 
   // set lookup table type defined by the action string
   std::string activatedItem = senderAction->text().toStdString();
   renderWindowSpecificLutTab->SetType(activatedItem);
   dataNode->SetProperty("LookupTable", mitk::LookupTableProperty::New(renderWindowSpecificLutTab), baseRenderer);
 
   mitk::RenderingModeProperty::Pointer renderingMode = dynamic_cast<mitk::RenderingModeProperty*>(dataNode->GetProperty("Image Rendering.Mode", baseRenderer));
   renderingMode->SetValue(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR);
 
   if (nullptr == baseRenderer)
   {
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else
   {
     mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeComponentAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeComponentAction.cpp
index e58a6b2931..ea5bbb26d8 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeComponentAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeComponentAction.cpp
@@ -1,121 +1,113 @@
 /*===================================================================
 
 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 <QmitkDataNodeComponentAction.h>
 
 // mitk core
 #include <mitkDataNode.h>
 #include <mitkImage.h>
 #include <mitkRenderingManager.h>
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // berry
 #include <berryISelectionService.h>
 
 // qt
 #include <QHBoxLayout>
 #include <QLabel>
 
 QmitkDataNodeComponentAction::QmitkDataNodeComponentAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QWidgetAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   InitializeAction();
 }
 
 QmitkDataNodeComponentAction::QmitkDataNodeComponentAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QWidgetAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   InitializeAction();
 }
 
 QmitkDataNodeComponentAction::~QmitkDataNodeComponentAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeComponentAction::InitializeAction()
 {
   setCheckable(true);
 
   m_ComponentSlider = new QmitkNumberPropertySlider;
   m_ComponentSlider->setOrientation(Qt::Horizontal);
 
   QLabel* componentLabel = new QLabel(tr("Component: "));
   QHBoxLayout* componentWidgetLayout = new QHBoxLayout;
   componentWidgetLayout->setContentsMargins(4, 4, 4, 4);
   componentWidgetLayout->addWidget(componentLabel);
   componentWidgetLayout->addWidget(m_ComponentSlider);
   QLabel* componentValueLabel = new QLabel();
   componentWidgetLayout->addWidget(componentValueLabel);
   connect(m_ComponentSlider, &QmitkNumberPropertySlider::valueChanged, componentValueLabel, static_cast<void (QLabel::*)(int)>(&QLabel::setNum));
 
   QWidget* componentWidget = new QWidget;
   componentWidget->setLayout(componentWidgetLayout);
 
   setDefaultWidget(componentWidget);
 
   connect(this, &QmitkDataNodeComponentAction::changed, this, &QmitkDataNodeComponentAction::OnActionChanged);
 }
 
 void QmitkDataNodeComponentAction::InitializeWithDataNode(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     m_ComponentSlider->SetProperty(static_cast<mitk::IntProperty*>(nullptr));
     return;
   }
 
   mitk::Image* img = dynamic_cast<mitk::Image*>(dataNode->GetData());
   if (nullptr == img)
   {
     m_ComponentSlider->SetProperty(static_cast<mitk::IntProperty*>(nullptr));
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   int numComponents = 0;
   numComponents = img->GetPixelType().GetNumberOfComponents();
   mitk::IntProperty* componentProperty = dynamic_cast<mitk::IntProperty*>(dataNode->GetProperty("Image.Displayed Component", baseRenderer));
   if (numComponents <= 1 || nullptr == componentProperty)
   {
     m_ComponentSlider->SetProperty(static_cast<mitk::IntProperty*>(nullptr));
     return;
   }
 
   m_ComponentSlider->SetProperty(componentProperty);
   m_ComponentSlider->setMinValue(0);
   m_ComponentSlider->setMaxValue(numComponents - 1);
 }
 
 void QmitkDataNodeComponentAction::OnActionChanged()
 {
   auto dataNode = GetSelectedNode();
 
   InitializeWithDataNode(dataNode);
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeHideAllNodesAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeHideAllNodesAction.cpp
index a35785432f..2007d974be 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeHideAllNodesAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeHideAllNodesAction.cpp
@@ -1,82 +1,74 @@
 /*===================================================================
 
 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 <QmitkDataNodeHideAllNodesAction.h>
 
 // mitk core
 #include <mitkRenderingManager.h>
 
 QmitkDataNodeHideAllNodesAction::QmitkDataNodeHideAllNodesAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Hide all nodes"));
   InitializeAction();
 }
 
 QmitkDataNodeHideAllNodesAction::QmitkDataNodeHideAllNodesAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Hide all nodes"));
   InitializeAction();
 }
 
 QmitkDataNodeHideAllNodesAction::~QmitkDataNodeHideAllNodesAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeHideAllNodesAction::InitializeAction()
 {
   connect(this, &QmitkDataNodeHideAllNodesAction::triggered, this, &QmitkDataNodeHideAllNodesAction::OnActionTriggered);
 }
 
 void QmitkDataNodeHideAllNodesAction::OnActionTriggered(bool /*checked*/)
 {
   if (m_DataStorage.IsExpired())
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   auto nodeset = m_DataStorage.Lock()->GetAll();
   for (auto& node : *nodeset)
   {
     if (node.IsNotNull())
     {
       node->SetVisibility(false, baseRenderer);
     }
   }
 
   if (nullptr == baseRenderer)
   {
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else
   {
     mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeOpacityAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeOpacityAction.cpp
index ed788ff314..f3311b4b72 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeOpacityAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeOpacityAction.cpp
@@ -1,132 +1,116 @@
 /*===================================================================
 
 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 <QmitkDataNodeOpacityAction.h>
 
 // mitk core
 #include <mitkRenderingManager.h>
 
 // qt
 #include <QHBoxLayout>
 #include <QLabel>
 
 QmitkDataNodeOpacityAction::QmitkDataNodeOpacityAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QWidgetAction(parent)
   , QmitkAbstractDataNodeAction(workbenchPartSite)
 {
   InitializeAction();
 }
 
 QmitkDataNodeOpacityAction::QmitkDataNodeOpacityAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QWidgetAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   InitializeAction();
 }
 
 QmitkDataNodeOpacityAction::~QmitkDataNodeOpacityAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeOpacityAction::InitializeAction()
 {
   m_OpacitySlider = new QSlider;
   m_OpacitySlider->setMinimum(0);
   m_OpacitySlider->setMaximum(100);
   m_OpacitySlider->setOrientation(Qt::Horizontal);
   connect(m_OpacitySlider, &QSlider::valueChanged, this, &QmitkDataNodeOpacityAction::OnOpacityChanged);
 
   QLabel* opacityLabel = new QLabel(tr("Opacity: "));
   QHBoxLayout* opacityWidgetLayout = new QHBoxLayout;
   opacityWidgetLayout->setContentsMargins(4, 4, 4, 4);
   opacityWidgetLayout->addWidget(opacityLabel);
   opacityWidgetLayout->addWidget(m_OpacitySlider);
 
   QWidget* opacityWidget = new QWidget;
   opacityWidget->setLayout(opacityWidgetLayout);
 
   setDefaultWidget(opacityWidget);
 
   connect(this, &QAction::changed, this, &QmitkDataNodeOpacityAction::OnActionChanged);
 }
 
 void QmitkDataNodeOpacityAction::InitializeWithDataNode(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     m_OpacitySlider->setValue(static_cast<int>(0));
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   float opacity = 0.0;
   if (dataNode->GetFloatProperty("opacity", opacity, baseRenderer))
   {
     m_OpacitySlider->setValue(static_cast<int>(opacity * 100));
   }
 }
 
 void QmitkDataNodeOpacityAction::OnOpacityChanged(int value)
 {
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   float opacity = static_cast<float>(value) / 100.0f;
   dataNode->SetFloatProperty("opacity", opacity, baseRenderer);
 
   if (nullptr == baseRenderer)
   {
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else
   {
     mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
   }
 }
 
 void QmitkDataNodeOpacityAction::OnActionChanged()
 {
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
   InitializeWithDataNode(dataNode);
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeReinitAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeReinitAction.cpp
index e98616dc68..00823fa5c4 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeReinitAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeReinitAction.cpp
@@ -1,140 +1,132 @@
 /*===================================================================
 
 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 <QmitkDataNodeReinitAction.h>
 
 // mitk core
 #include <mitkImage.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkRenderingManager.h>
 
 // mitk gui common plugin
 #include <mitkWorkbenchUtil.h>
 
 QmitkDataNodeReinitAction::QmitkDataNodeReinitAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Reinit"));
   InitializeAction();
 }
 
 QmitkDataNodeReinitAction::QmitkDataNodeReinitAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Reinit"));
   InitializeAction();
 }
 
 QmitkDataNodeReinitAction::~QmitkDataNodeReinitAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeReinitAction::InitializeAction()
 {
   connect(this, &QmitkDataNodeReinitAction::triggered, this, &QmitkDataNodeReinitAction::OnActionTriggered);
 }
 
 void QmitkDataNodeReinitAction::OnActionTriggered(bool /*checked*/)
 {
   if (m_WorkbenchPartSite.Expired())
   {
     return;
   }
 
   auto renderWindow = mitk::WorkbenchUtil::GetRenderWindowPart(m_WorkbenchPartSite.Lock()->GetPage(), mitk::WorkbenchUtil::NONE);
 
   if (nullptr == renderWindow)
   {
     renderWindow = mitk::WorkbenchUtil::OpenRenderWindowPart(m_WorkbenchPartSite.Lock()->GetPage(), false);
     if (nullptr == renderWindow)
     {
       // no render window available
       return;
     }
   }
 
   if (m_DataStorage.IsExpired())
   {
     return;
   }
 
   auto dataStorage = m_DataStorage.Lock();
 
   auto dataNodes = GetSelectedNodes();
   if (dataNodes.isEmpty())
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   auto boundingBoxPredicate = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false), baseRenderer));
 
   mitk::DataStorage::SetOfObjects::Pointer nodes = mitk::DataStorage::SetOfObjects::New();
   for (const auto& dataNode : dataNodes)
   {
     if (boundingBoxPredicate->CheckNode(dataNode))
     {
       nodes->InsertElement(nodes->Size(), dataNode);
     }
   }
 
   if (nodes->empty())
   {
     return;
   }
 
   if (1 == nodes->Size()) // Special case: If exactly one ...
   {
     auto image = dynamic_cast<mitk::Image*>(nodes->ElementAt(0)->GetData());
 
     if (nullptr != image) // ... image is selected, reinit is expected to rectify askew images.
     {
       if (nullptr == baseRenderer)
       {
         mitk::RenderingManager::GetInstance()->InitializeViews(image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
       }
       else
       {
         mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), image->GetTimeGeometry(), true);
       }
       return;
     }
   }
 
   auto boundingGeometry = dataStorage->ComputeBoundingGeometry3D(nodes, "visible", baseRenderer);
   if (nullptr == baseRenderer)
   {
     mitk::RenderingManager::GetInstance()->InitializeViews(boundingGeometry);
   }
   else
   {
     mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), boundingGeometry);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeShowSelectedNodesAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeShowSelectedNodesAction.cpp
index 36be10ab34..d5a8a76d67 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeShowSelectedNodesAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeShowSelectedNodesAction.cpp
@@ -1,83 +1,75 @@
 /*===================================================================
 
 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 <QmitkDataNodeShowSelectedNodesAction.h>
 
 // mitk core
 #include <mitkRenderingManager.h>
 
 QmitkDataNodeShowSelectedNodesAction::QmitkDataNodeShowSelectedNodesAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Show only selected nodes"));
   InitializeAction();
 }
 
 QmitkDataNodeShowSelectedNodesAction::QmitkDataNodeShowSelectedNodesAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Show only selected nodes"));
   InitializeAction();
 }
 
 QmitkDataNodeShowSelectedNodesAction::~QmitkDataNodeShowSelectedNodesAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeShowSelectedNodesAction::InitializeAction()
 {
   connect(this, &QmitkDataNodeShowSelectedNodesAction::triggered, this, &QmitkDataNodeShowSelectedNodesAction::OnActionTriggered);
 }
 
 void QmitkDataNodeShowSelectedNodesAction::OnActionTriggered(bool /*checked*/)
 {
   if (m_DataStorage.IsExpired())
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   auto dataNodes = GetSelectedNodes();
   auto nodeset = m_DataStorage.Lock()->GetAll();
   for (auto& node : *nodeset)
   {
     if (node.IsNotNull())
     {
       node->SetVisibility(dataNodes.contains(node), baseRenderer);
     }
   }
 
   if (nullptr == baseRenderer)
   {
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else
   {
     mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeSurfaceRepresentationAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeSurfaceRepresentationAction.cpp
index f10c209b7d..2c0a9cbc37 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeSurfaceRepresentationAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeSurfaceRepresentationAction.cpp
@@ -1,145 +1,129 @@
 /*===================================================================
 
 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 <QmitkDataNodeSurfaceRepresentationAction.h>
 
 // mitk core
 #include <mitkEnumerationProperty.h>
 #include <mitkRenderingManager.h>
 
 // qt
 #include <QMenu>
 
 QmitkDataNodeSurfaceRepresentationAction::QmitkDataNodeSurfaceRepresentationAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Surface Representation"));
   InitializeAction();
 }
 
 QmitkDataNodeSurfaceRepresentationAction::QmitkDataNodeSurfaceRepresentationAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Surface Representation"));
   InitializeAction();
 }
 
 QmitkDataNodeSurfaceRepresentationAction::~QmitkDataNodeSurfaceRepresentationAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeSurfaceRepresentationAction::InitializeAction()
 {
   setCheckable(true);
 
   setMenu(new QMenu);
   connect(menu(), &QMenu::aboutToShow, this, &QmitkDataNodeSurfaceRepresentationAction::OnMenuAboutShow);
 }
 
 void QmitkDataNodeSurfaceRepresentationAction::OnMenuAboutShow()
 {
   mitk::DataNode::Pointer dataNode = GetSelectedNode();
   if (nullptr == dataNode)
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   mitk::EnumerationProperty* representationProp = dynamic_cast<mitk::EnumerationProperty*>(dataNode->GetProperty("material.representation", baseRenderer));
   if (nullptr == representationProp)
   {
     return;
   }
 
   menu()->clear();
   QAction* tmp;
 
   for (mitk::EnumerationProperty::EnumConstIterator it = representationProp->Begin(); it != representationProp->End(); ++it)
   {
     tmp = menu()->addAction(QString::fromStdString(it->second));
     tmp->setCheckable(true);
 
     if (it->second == representationProp->GetValueAsString())
     {
       tmp->setChecked(true);
     }
 
     connect(tmp, &QAction::triggered, this, &QmitkDataNodeSurfaceRepresentationAction::OnActionTriggered);
   }
 }
 
 void QmitkDataNodeSurfaceRepresentationAction::OnActionTriggered(bool /*checked*/)
 {
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   mitk::EnumerationProperty* representationProp = dynamic_cast<mitk::EnumerationProperty*>(dataNode->GetProperty("material.representation", baseRenderer));
   if (nullptr == representationProp)
   {
     return;
   }
 
   QAction* senderAction = qobject_cast<QAction*>(QObject::sender());
   if (nullptr == senderAction)
   {
     return;
   }
 
   std::string activatedItem = senderAction->text().toStdString();
   if (activatedItem != representationProp->GetValueAsString())
   {
     if (representationProp->IsValidEnumerationValue(activatedItem))
     {
       representationProp->SetValue(activatedItem);
       representationProp->InvokeEvent(itk::ModifiedEvent());
       representationProp->Modified();
 
       if (nullptr == baseRenderer)
       {
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
       else
       {
         mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
       }
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeTextureInterpolationAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeTextureInterpolationAction.cpp
index 6a046dbb41..2cfd9cbe73 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeTextureInterpolationAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeTextureInterpolationAction.cpp
@@ -1,113 +1,97 @@
 /*===================================================================
 
 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 <QmitkDataNodeTextureInterpolationAction.h>
 
 // mitk core
 #include <mitkRenderingManager.h>
 
 QmitkDataNodeTextureInterpolationAction::QmitkDataNodeTextureInterpolationAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Texture Interpolation"));
   InitializeAction();
 }
 
 QmitkDataNodeTextureInterpolationAction::QmitkDataNodeTextureInterpolationAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Texture Interpolation"));
   InitializeAction();
 }
 
 QmitkDataNodeTextureInterpolationAction::~QmitkDataNodeTextureInterpolationAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeTextureInterpolationAction::InitializeAction()
 {
   setCheckable(true);
 
   connect(this, &QmitkDataNodeTextureInterpolationAction::toggled, this, &QmitkDataNodeTextureInterpolationAction::OnActionToggled);
   connect(this, &QmitkDataNodeTextureInterpolationAction::changed, this, &QmitkDataNodeTextureInterpolationAction::OnActionChanged);
 }
 
 void QmitkDataNodeTextureInterpolationAction::InitializeWithDataNode(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     setChecked(false);
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   bool textureInterpolation = false;
   dataNode->GetBoolProperty("texture interpolation", textureInterpolation, baseRenderer);
   setChecked(textureInterpolation);
 }
 
 void QmitkDataNodeTextureInterpolationAction::OnActionToggled(bool checked)
 {
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   dataNode->SetBoolProperty("texture interpolation", checked, baseRenderer);
 
   if (nullptr == baseRenderer)
   {
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else
   {
     mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
   }
 }
 
 void QmitkDataNodeTextureInterpolationAction::OnActionChanged()
 {
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
   InitializeWithDataNode(dataNode);
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeToggleVisibilityAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeToggleVisibilityAction.cpp
index e6025033f1..1a499113f8 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeToggleVisibilityAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeToggleVisibilityAction.cpp
@@ -1,116 +1,108 @@
 /*===================================================================
 
 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 <QmitkDataNodeToggleVisibilityAction.h>
 #include <QmitkDataNodeGlobalReinitAction.h>
 
 // mitk core
 #include <mitkRenderingManager.h>
 
 // berry
 #include <berryIPreferences.h>
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 // namespace that contains the concrete action
 namespace ToggleVisibilityAction
 {
   void Run(berry::IWorkbenchPartSite::Pointer workbenchPartSite, mitk::DataStorage::Pointer dataStorage, QList<mitk::DataNode::Pointer> selectedNodes /*= QList<mitk::DataNode::Pointer>()*/, mitk::BaseRenderer* baseRenderer /*= nullptr*/)
   {
     bool isVisible;
     for (auto& node : selectedNodes)
     {
       if (node.IsNotNull())
       {
         isVisible = false;
         node->GetBoolProperty("visible", isVisible, baseRenderer);
         node->SetVisibility(!isVisible, baseRenderer);
       }
     }
 
     berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
     berry::IPreferences::Pointer preferencesNode = prefService->GetSystemPreferences()->Node(QmitkDataNodeGlobalReinitAction::ACTION_ID);
 
     bool globalReinit = preferencesNode->GetBool("Call global reinit if node visibility is changed", false);
     if (globalReinit)
     {
       GlobalReinitAction::Run(workbenchPartSite, dataStorage);
     }
     else
     {
       if (nullptr == baseRenderer)
       {
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
       else
       {
         mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
       }
     }
   }
 }
 
 QmitkDataNodeToggleVisibilityAction::QmitkDataNodeToggleVisibilityAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Toggle visibility"));
   InitializeAction();
 }
 
 QmitkDataNodeToggleVisibilityAction::QmitkDataNodeToggleVisibilityAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Toggle visibility"));
   InitializeAction();
 }
 
 QmitkDataNodeToggleVisibilityAction::~QmitkDataNodeToggleVisibilityAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeToggleVisibilityAction::InitializeAction()
 {
   connect(this, &QmitkDataNodeToggleVisibilityAction::triggered, this, &QmitkDataNodeToggleVisibilityAction::OnActionTriggered);
 }
 
 void QmitkDataNodeToggleVisibilityAction::OnActionTriggered(bool /*checked*/)
 {
   if (m_WorkbenchPartSite.Expired())
   {
     return;
   }
 
   if (m_DataStorage.IsExpired())
   {
     return;
   }
 
-  mitk::BaseRenderer* baseRenderer;
-  if (m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = nullptr;
-  }
-  else
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
+  mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   auto dataNodes = GetSelectedNodes();
   ToggleVisibilityAction::Run(m_WorkbenchPartSite.Lock(), m_DataStorage.Lock(), dataNodes, baseRenderer);
 }