diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
index 4f99755c61..2ca0acb543 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
@@ -1,87 +1,96 @@
 /*===================================================================
 
 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;
+  }
+}
+
 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 e8ded7f3d5..894d61b696 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.h
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.h
@@ -1,57 +1,60 @@
 /*===================================================================
 
 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* dataNode) { }
 
 protected:
 
   virtual void InitializeAction() = 0;
   mitk::DataNode::Pointer GetSelectedNode();
   QList<mitk::DataNode::Pointer> GetSelectedNodes();
 
   berry::IWorkbenchPartSite::WeakPtr m_WorkbenchPartSite;
   mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
+  mitk::WeakPointer<mitk::BaseRenderer> m_BaseRenderer;
 
 };
 
 #endif // QMITKABSTRACTDATANODEACTION_H
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
index 6512b9616b..6bf724edea 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
@@ -1,538 +1,555 @@
 /*===================================================================
 
 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 "QmitkDataNodeContextMenu.h"
 
 // mitk gui qt application plugin
 #include "mitkIContextMenuAction.h"
 #include "QmitkFileSaveAction.h"
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // qt widgets module
 #include <QmitkCustomVariants.h>
 #include <QmitkNodeDescriptorManager.h>
 
 // berry
 #include <berryAbstractUICTKPlugin.h>
 #include <berryIContributor.h>
 #include <berryIExtensionRegistry.h>
 #include <berryISelectionService.h>
 #include <berryPlatform.h>
 
 QmitkDataNodeContextMenu::QmitkDataNodeContextMenu(berry::IWorkbenchPartSite::Pointer workbenchPartSite, QWidget* parent)
   : QMenu(parent)
 {
   m_Parent = parent;
   m_WorkbenchPartSite = workbenchPartSite;
 
   InitNodeDescriptors();
   InitDefaultActions();
   InitExtensionPointActions();
 }
 
 QmitkDataNodeContextMenu::~QmitkDataNodeContextMenu()
 {
   // remove the registered actions from each descriptor
   for (DescriptorActionListType::const_iterator it = m_DescriptorActionList.begin(); it != m_DescriptorActionList.end(); ++it)
   {
     (it->first)->RemoveAction(it->second);
   }
 }
 
 void QmitkDataNodeContextMenu::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage != dataStorage)
   {
     // set the new data storage - also for all actions
     m_DataStorage = dataStorage;
     for (DescriptorActionListType::const_iterator it = m_DescriptorActionList.begin(); it != m_DescriptorActionList.end(); ++it)
     {
       QmitkAbstractDataNodeAction* abstractDataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(it->second);
       if(nullptr != abstractDataNodeAction)
       {
         abstractDataNodeAction->SetDataStorage(m_DataStorage.Lock());
       }
     }
   }
 }
 
+void QmitkDataNodeContextMenu::SetBaseRenderer(mitk::BaseRenderer* baseRenderer)
+{
+  if (m_BaseRenderer != baseRenderer)
+  {
+    // set the new base renderer - also for all actions
+    m_BaseRenderer = baseRenderer;
+    for (DescriptorActionListType::const_iterator it = m_DescriptorActionList.begin(); it != m_DescriptorActionList.end(); ++it)
+    {
+      QmitkAbstractDataNodeAction* abstractDataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(it->second);
+      if (nullptr != abstractDataNodeAction)
+      {
+        abstractDataNodeAction->SetBaseRenderer(m_BaseRenderer.Lock());
+      }
+    }
+  }
+}
+
 void QmitkDataNodeContextMenu::SetSurfaceDecimation(bool surfaceDecimation)
 {
   m_SurfaceDecimation = surfaceDecimation;
 }
 
 void QmitkDataNodeContextMenu::InitNodeDescriptors()
 {
   m_UnknownDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetUnknownDataNodeDescriptor();
   m_ImageDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Image");
   m_MultiComponentImageDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("MultiComponentImage");
   m_DiffusionImageDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("DiffusionImage");
   m_FiberBundleDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("FiberBundle");
   m_PeakImageDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PeakImage");
   m_SegmentDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Segment");
   m_SurfaceDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Surface");
   m_PointSetNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PointSet");
   m_PlanarLineNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarLine");
   m_PlanarCircleNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarCircle");
   m_PlanarEllipseNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarEllipse");
   m_PlanarAngleNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarAngle");
   m_PlanarFourPointAngleNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarFourPointAngle");
   m_PlanarRectangleNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarRectangle");
   m_PlanarPolygonNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarPolygon");
   m_PlanarPathNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarPath");
   m_PlanarDoubleEllipseNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarDoubleEllipse");
   m_PlanarBezierCurveNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarBezierCurve");
   m_PlanarSubdivisionPolygonNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarSubdivisionPolygon");
 }
 
 void QmitkDataNodeContextMenu::InitDefaultActions()
 {
   m_GlobalReinitAction = new QmitkDataNodeGlobalReinitAction(m_Parent, m_WorkbenchPartSite.Lock());
   m_GlobalReinitAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_GlobalReinitAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_GlobalReinitAction));
 
   m_ReinitAction = new QmitkDataNodeReinitAction(m_Parent, m_WorkbenchPartSite.Lock());
   m_ReinitAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ReinitAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ReinitAction));
 
   QAction* saveAction = new QmitkFileSaveAction(QIcon(":/org.mitk.gui.qt.datamanager/Save_48.png"), m_WorkbenchPartSite.Lock()->GetWorkbenchWindow());
   m_UnknownDataNodeDescriptor->AddAction(saveAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, saveAction));
 
   m_RemoveAction = new QmitkDataNodeRemoveAction(m_Parent, m_WorkbenchPartSite.Lock());
   m_RemoveAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Remove_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_RemoveAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_RemoveAction));
 
   m_ShowSelectedNodesAction = new QmitkDataNodeShowSelectedNodesAction(m_Parent, m_WorkbenchPartSite.Lock());
   m_RemoveAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/ShowSelectedNode_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ShowSelectedNodesAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ShowSelectedNodesAction));
 
   m_ToggleVisibilityAction = new QmitkDataNodeToggleVisibilityAction(m_Parent, m_WorkbenchPartSite.Lock());
   m_ToggleVisibilityAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/InvertShowSelectedNode_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ToggleVisibilityAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ToggleVisibilityAction));
 
   m_ShowDetailsAction = new QmitkDataNodeShowDetailsAction(m_Parent, m_WorkbenchPartSite.Lock());
   m_ShowDetailsAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/ShowDataInfo_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ShowDetailsAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ShowDetailsAction));
 
   // default widget actions
   m_OpacityAction = new QmitkDataNodeOpacityAction(m_Parent, m_WorkbenchPartSite.Lock());
   // not used for batch actions (no multi-selection action)
   m_UnknownDataNodeDescriptor->AddAction(m_OpacityAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_OpacityAction));
 
   m_ColorAction = new QmitkDataNodeColorAction(m_Parent, m_WorkbenchPartSite.Lock());
   AddColorAction(m_ColorAction);
 
   m_ColormapAction = new QmitkDataNodeColorMapAction(m_Parent, m_WorkbenchPartSite.Lock());
   // not used for batch actions (no multi-selection action)
   m_ImageDataNodeDescriptor->AddAction(m_ColormapAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, m_ColormapAction));
 
   if (m_DiffusionImageDataNodeDescriptor != nullptr)
   {
     // not used for batch actions (no multi-selection action)
     m_DiffusionImageDataNodeDescriptor->AddAction(m_ColormapAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_ColormapAction));
   }
 
   m_ComponentAction = new QmitkDataNodeComponentAction(m_Parent, m_WorkbenchPartSite.Lock());
   // not used for batch actions (no multi-selection action)
   m_MultiComponentImageDataNodeDescriptor->AddAction(m_ComponentAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_MultiComponentImageDataNodeDescriptor, m_ComponentAction));
 
   if (m_DiffusionImageDataNodeDescriptor != nullptr)
   {
     // not used for batch actions (no multi-selection action)
     m_DiffusionImageDataNodeDescriptor->AddAction(m_ComponentAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_ComponentAction));
   }
 
   m_TextureInterpolationAction = new QmitkDataNodeTextureInterpolationAction(m_Parent, m_WorkbenchPartSite.Lock());
   // not used for batch actions (no multi-selection action)
   m_ImageDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, m_TextureInterpolationAction));
 
   if (m_DiffusionImageDataNodeDescriptor != nullptr)
   {
     // not used for batch actions (no multi-selection action)
     m_DiffusionImageDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_TextureInterpolationAction));
   }
 
   if (m_SegmentDataNodeDescriptor != nullptr)
   {
     // not used for batch actions (no multi-selection action)
     m_SegmentDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_SegmentDataNodeDescriptor, m_TextureInterpolationAction));
   }
 
   m_SurfaceRepresentationAction = new QmitkDataNodeSurfaceRepresentationAction(m_Parent, m_WorkbenchPartSite.Lock());
   // not used for batch actions (no multi-selection action)
   m_SurfaceDataNodeDescriptor->AddAction(m_SurfaceRepresentationAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_SurfaceDataNodeDescriptor, m_SurfaceRepresentationAction));
 }
 
 void QmitkDataNodeContextMenu::InitExtensionPointActions()
 {
   // find contextMenuAction extension points and add them to the node descriptor
   berry::IExtensionRegistry* extensionPointService = berry::Platform::GetExtensionRegistry();
   QList<berry::IConfigurationElement::Pointer> customMenuConfigs = extensionPointService->GetConfigurationElementsFor("org.mitk.gui.qt.datamanager.contextMenuActions");
 
   // prepare all custom QActions
   m_ConfigElements.clear();
   DescriptorActionListType descriptorActionList;
   for (const auto& customMenuConfig : customMenuConfigs)
   {
     QString actionNodeDescriptorName = customMenuConfig->GetAttribute("nodeDescriptorName");
     QString actionLabel = customMenuConfig->GetAttribute("label");
     QString actionClass = customMenuConfig->GetAttribute("class");
 
     if (actionNodeDescriptorName.isEmpty() || actionLabel.isEmpty() || actionClass.isEmpty())
     {
       // no properties found for the current extension point
       continue;
     }
 
     // find matching descriptor
     auto nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(actionNodeDescriptorName);
     if (nullptr == nodeDescriptor)
     {
       MITK_WARN << "Cannot add action \"" << actionLabel << "\" because descriptor " << actionNodeDescriptorName << " does not exist.";
       continue;
     }
 
     // create action with or without icon
     QAction* contextMenuAction;
     QString actionIconName = customMenuConfig->GetAttribute("icon");
     if (!actionIconName.isEmpty())
     {
       QIcon actionIcon;
       if (QFile::exists(actionIconName))
       {
         actionIcon = QIcon(actionIconName);
       }
       else
       {
         actionIcon = berry::AbstractUICTKPlugin::ImageDescriptorFromPlugin(customMenuConfig->GetContributor()->GetName(), actionIconName);
       }
       contextMenuAction = new QAction(actionIcon, actionLabel, m_Parent);
     }
     else
     {
       contextMenuAction = new QAction(actionLabel, m_Parent);
     }
 
     // connect action trigger
     connect(contextMenuAction, static_cast<void(QAction::*)(bool)>(&QAction::triggered), this, &QmitkDataNodeContextMenu::OnExtensionPointActionTriggered);
 
     // mark configuration element into lookup list for context menu handler
     m_ConfigElements[contextMenuAction] = customMenuConfig;
     // mark new action in sortable list for addition to descriptor
     descriptorActionList.emplace_back(nodeDescriptor, contextMenuAction);
   }
 
   AddDescriptorActionList(descriptorActionList);
 }
 
 void QmitkDataNodeContextMenu::InitServiceActions()
 {
 
 }
 
 void QmitkDataNodeContextMenu::OnContextMenuRequested(const QPoint& pos)
 {
   if (m_WorkbenchPartSite.Expired())
   {
     return;
   }
 
   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;
   }
 
   m_SelectedNodes = QList<mitk::DataNode::Pointer>::fromStdList(currentSelection->GetSelectedDataNodes());
   if (!m_SelectedNodes.isEmpty())
   {
     clear();
     QList<QAction*> actions;
     if (m_SelectedNodes.size() == 1)
     {
       // no batch action; should only contain a single node
       actions = GetActions(m_SelectedNodes.front());
     }
     else
     {
       // batch action
       actions = GetActions(m_SelectedNodes);
     }
 
     // initialize abstract data node actions
     for (auto& action : actions)
     {
       QmitkAbstractDataNodeAction* abstractDataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(action);
       if (nullptr != abstractDataNodeAction)
       {
         // use the first selected node to initialize the data node actions
         abstractDataNodeAction->InitializeWithDataNode(m_SelectedNodes.front());
       }
     }
 
     /*
     if (!m_ShowInActions.isEmpty())
     {
       QMenu* showInMenu = m_NodeMenu->addMenu(tr("Show In"));
       showInMenu->addActions(m_ShowInActions);
     }
     */
 
     addActions(actions);
     popup(QCursor::pos());
   }
 }
 
 void QmitkDataNodeContextMenu::OnExtensionPointActionTriggered(bool)
 {
   QAction* action = qobject_cast<QAction*>(sender());
   ConfigurationElementsType::const_iterator it = m_ConfigElements.find(action);
   if (it == m_ConfigElements.end())
   {
     MITK_WARN << "Associated configuration element for action " << action->text().toStdString() << " not found.";
     return;
   }
 
   berry::IConfigurationElement::Pointer confElem = it->second;
   mitk::IContextMenuAction* contextMenuAction = confElem->CreateExecutableExtension<mitk::IContextMenuAction>("class");
 
   QString className = confElem->GetAttribute("class");
   QString smoothed = confElem->GetAttribute("smoothed");
 
   if (!m_DataStorage.IsExpired())
   {
     auto dataStorage = m_DataStorage.Lock();
     contextMenuAction->SetDataStorage(dataStorage);
   }
 
   if (className == "QmitkCreatePolygonModelAction")
   {
     if (smoothed == "false")
     {
       contextMenuAction->SetSmoothed(false);
     }
     else
     {
       contextMenuAction->SetSmoothed(true);
     }
     contextMenuAction->SetDecimated(m_SurfaceDecimation);
   }
 
   contextMenuAction->Run(m_SelectedNodes);
 }
 
 void QmitkDataNodeContextMenu::AddColorAction(QWidgetAction* colorAction)
 {
   bool colorActionCanBatch = true;
   if (nullptr != m_ImageDataNodeDescriptor)
   {
     m_ImageDataNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_MultiComponentImageDataNodeDescriptor)
   {
     m_MultiComponentImageDataNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_MultiComponentImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_DiffusionImageDataNodeDescriptor)
   {
     m_DiffusionImageDataNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_FiberBundleDataNodeDescriptor)
   {
     m_FiberBundleDataNodeDescriptor->AddAction(colorAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_FiberBundleDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PeakImageDataNodeDescriptor)
   {
     m_PeakImageDataNodeDescriptor->AddAction(colorAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_PeakImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_SegmentDataNodeDescriptor)
   {
     m_SegmentDataNodeDescriptor->AddAction(colorAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_SegmentDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_SurfaceDataNodeDescriptor)
   {
     m_SurfaceDataNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_SurfaceDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PointSetNodeDescriptor)
   {
     m_PointSetNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PointSetNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarLineNodeDescriptor)
   {
     m_PlanarLineNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarLineNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarCircleNodeDescriptor)
   {
     m_PlanarCircleNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarCircleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarEllipseNodeDescriptor)
   {
     m_PlanarEllipseNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarEllipseNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarAngleNodeDescriptor)
   {
     m_PlanarAngleNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarAngleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarFourPointAngleNodeDescriptor)
   {
     m_PlanarFourPointAngleNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarFourPointAngleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarRectangleNodeDescriptor)
   {
     m_PlanarRectangleNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarRectangleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarPolygonNodeDescriptor)
   {
     m_PlanarPolygonNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarPolygonNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarPathNodeDescriptor)
   {
     m_PlanarPathNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarPathNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarDoubleEllipseNodeDescriptor)
   {
     m_PlanarDoubleEllipseNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarDoubleEllipseNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarBezierCurveNodeDescriptor)
   {
     m_PlanarBezierCurveNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarBezierCurveNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarSubdivisionPolygonNodeDescriptor)
   {
     m_PlanarSubdivisionPolygonNodeDescriptor->AddAction(colorAction, colorActionCanBatch);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarSubdivisionPolygonNodeDescriptor, colorAction));
   }
 }
 
 void QmitkDataNodeContextMenu::AddDescriptorActionList(DescriptorActionListType& descriptorActionList)
 {
   // sort all custom QActions by their texts
   using ListEntryType = std::pair<QmitkNodeDescriptor*, QAction*>;
   std::sort(descriptorActionList.begin(), descriptorActionList.end(),
     [](const ListEntryType& left, const ListEntryType& right) -> bool
   {
     assert(left.second != nullptr && right.second != nullptr); // unless we messed up above
     return left.second->text() < right.second->text();
   });
 
   // add custom QActions in sorted order
   for (auto& descriptorActionPair : descriptorActionList)
   {
     auto& nodeDescriptor = descriptorActionPair.first;
     auto& contextMenuAction = descriptorActionPair.second;
 
     // add action to the descriptor
     nodeDescriptor->AddAction(contextMenuAction);
 
     // mark new action into list of descriptors to remove in destructor
     m_DescriptorActionList.push_back(descriptorActionPair);
   }
 }
 
 QList<QAction*> QmitkDataNodeContextMenu::GetActions(const mitk::DataNode* node)
 {
   QList<QAction*> actions;
   for (DescriptorActionListType::const_iterator it = m_DescriptorActionList.begin(); it != m_DescriptorActionList.end(); ++it)
   {
     if ((it->first)->CheckNode(node) ||
          it->first->GetNameOfClass() == "Unknown")
     {
       actions.append(it->second);
     }
   }
 
   return actions;
 }
 
 QList<QAction*> QmitkDataNodeContextMenu::GetActions(const QList<mitk::DataNode::Pointer>& nodes)
 {
   QList<QAction*> actions;
 
   for (DescriptorActionListType::const_iterator it = m_DescriptorActionList.begin(); it != m_DescriptorActionList.end(); ++it)
   {
     for (const auto& node : nodes)
     {
       if ((it->first)->CheckNode(node) ||
            it->first->GetNameOfClass() == "Unknown")
       {
         const auto& batchActions = (it->first)->GetBatchActions();
         if (std::find(batchActions.begin(), batchActions.end(), it->second) != batchActions.end())
         {
           // current descriptor action is a batch action
           actions.append(it->second);
         }
         break; // only add action once; goto next descriptor action
       }
     }
   }
 
   return actions;
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.h b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.h
index d5f3055074..a8198f282b 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.h
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.h
@@ -1,134 +1,137 @@
 /*===================================================================
 
 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 QMITKDATANODECONTEXTMENU_H
 #define QMITKDATANODECONTEXTMENU_H
 
 #include <org_mitk_gui_qt_application_Export.h>
 
 // qt widgets module
 #include "QmitkDataNodeGlobalReinitAction.h"
 #include "QmitkDataNodeReinitAction.h"
 #include "QmitkDataNodeRemoveAction.h"
 #include "QmitkDataNodeShowSelectedNodesAction.h"
 #include "QmitkDataNodeToggleVisibilityAction.h"
 #include "QmitkDataNodeShowDetailsAction.h"
 #include "QmitkDataNodeOpacityAction.h"
 #include "QmitkDataNodeColorAction.h"
 #include "QmitkDataNodeColorMapAction.h"
 #include "QmitkDataNodeComponentAction.h"
 #include "QmitkDataNodeTextureInterpolationAction.h"
 #include "QmitkDataNodeSurfaceRepresentationAction.h"
 #include "QmitkNodeDescriptor.h"
 
 // mitk core
+#include <mitkBaseRenderer.h>
 #include <mitkDataStorage.h>
 #include <mitkWeakPointer.h>
 
 // blueberry ui qt plugin
 #include <berryIConfigurationElement.h>
 #include <berryIWorkbenchPartSite.h>
 
 // qt
 #include <QMenu>
 
 class MITK_QT_APP QmitkDataNodeContextMenu : public QMenu
 {
   Q_OBJECT
 
 public:
 
   QmitkDataNodeContextMenu(berry::IWorkbenchPartSite::Pointer workbenchPartSite, QWidget* parent = nullptr);
 
   virtual ~QmitkDataNodeContextMenu() override;
 
   void SetDataStorage(mitk::DataStorage* dataStorage);
+  void SetBaseRenderer(mitk::BaseRenderer* baseRenderer);
   void SetSurfaceDecimation(bool surfaceDecimation);
 
 public Q_SLOTS:
 
   void OnContextMenuRequested(const QPoint& pos);
   void OnExtensionPointActionTriggered(bool);
 
 private:
 
   using DescriptorActionListType = std::vector<std::pair<QmitkNodeDescriptor*, QAction*>>;
   using ConfigurationElementsType = std::map<QAction*, berry::IConfigurationElement::Pointer>;
 
   void InitNodeDescriptors();
   void InitDefaultActions();
   void InitExtensionPointActions();
   void InitServiceActions();
 
   void AddColorAction(QWidgetAction* colorAction);
   void AddDescriptorActionList(DescriptorActionListType& descriptorActionList);
 
   QList<QAction*> GetActions(const mitk::DataNode* node);
   QList<QAction*> GetActions(const QList<mitk::DataNode::Pointer>& nodes);
 
   QWidget* m_Parent;
   berry::IWorkbenchPartSite::WeakPtr m_WorkbenchPartSite;
 
   mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
+  mitk::WeakPointer<mitk::BaseRenderer> m_BaseRenderer;
   QList<mitk::DataNode::Pointer> m_SelectedNodes;
 
   // store a list of all actions to remove them on menu destruction
   DescriptorActionListType m_DescriptorActionList;
 
   // stores the configuration elements for the context menu actions from extension points
   ConfigurationElementsType m_ConfigElements;
 
   QmitkNodeDescriptor* m_UnknownDataNodeDescriptor;
   QmitkNodeDescriptor* m_ImageDataNodeDescriptor;
   QmitkNodeDescriptor* m_MultiComponentImageDataNodeDescriptor;
   QmitkNodeDescriptor* m_DiffusionImageDataNodeDescriptor;
   QmitkNodeDescriptor* m_FiberBundleDataNodeDescriptor;
   QmitkNodeDescriptor* m_PeakImageDataNodeDescriptor;
   QmitkNodeDescriptor* m_SegmentDataNodeDescriptor;
   QmitkNodeDescriptor* m_SurfaceDataNodeDescriptor;
   QmitkNodeDescriptor* m_PointSetNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarLineNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarCircleNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarEllipseNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarAngleNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarFourPointAngleNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarRectangleNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarPolygonNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarPathNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarDoubleEllipseNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarBezierCurveNodeDescriptor;
   QmitkNodeDescriptor* m_PlanarSubdivisionPolygonNodeDescriptor;
 
   //////////////////////////////////////////////////////////////////////////
   // default actions
   //////////////////////////////////////////////////////////////////////////
   QmitkDataNodeGlobalReinitAction* m_GlobalReinitAction;
   QmitkDataNodeReinitAction* m_ReinitAction;
   QmitkDataNodeRemoveAction* m_RemoveAction;
   QmitkDataNodeShowSelectedNodesAction* m_ShowSelectedNodesAction;
   QmitkDataNodeToggleVisibilityAction* m_ToggleVisibilityAction;
   QmitkDataNodeShowDetailsAction* m_ShowDetailsAction;
   QmitkDataNodeOpacityAction* m_OpacityAction;
   QmitkDataNodeColorAction* m_ColorAction;
   QmitkDataNodeColorMapAction* m_ColormapAction;
   QmitkDataNodeComponentAction* m_ComponentAction;
   QmitkDataNodeTextureInterpolationAction* m_TextureInterpolationAction;
   QmitkDataNodeSurfaceRepresentationAction* m_SurfaceRepresentationAction;
 
   bool m_SurfaceDecimation;
 };
 
 #endif // QMITKDATANODECONTEXTMENU_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 b3b5016eb4..b1cbad6b7d 100644
--- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp
@@ -1,83 +1,88 @@
 /*===================================================================
 
 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>
 
 const std::string QmitkRenderWindowManagerView::VIEW_ID = "org.mitk.views.renderwindowmanager";
 
 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);
 
   SetControlledRenderer();
 
   for (const auto& renderer : m_ControlledRenderer)
   {
     m_Controls.comboBoxRenderWindowSelection->addItem(renderer->GetName());
   }
-
-  OnRenderWindowSelectionChanged(m_Controls.comboBoxRenderWindowSelection->itemText(0));
   connect(m_Controls.comboBoxRenderWindowSelection, SIGNAL(currentIndexChanged(const QString&)), this, SLOT(OnRenderWindowSelectionChanged(const QString&)));
 
   // 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(m_InspectorView, SIGNAL(customContextMenuRequested(const QPoint&)), m_DataNodeContextMenu, SLOT(OnContextMenuRequested(const QPoint&)));
+
+  OnRenderWindowSelectionChanged(m_Controls.comboBoxRenderWindowSelection->itemText(0));
 }
 
 void QmitkRenderWindowManagerView::SetControlledRenderer()
 {
   const mitk::RenderingManager::RenderWindowVector allRegisteredRenderWindows = mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
   mitk::BaseRenderer* baseRenderer = nullptr;
   for (const auto &renderWindow : allRegisteredRenderWindows)
   {
     baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow);
     if (nullptr != baseRenderer)
     {
       m_ControlledRenderer.push_back(baseRenderer);
     }
   }
 
   m_RenderWindowInspector->SetControlledRenderer(m_ControlledRenderer);
 }
 
-void QmitkRenderWindowManagerView::OnRenderWindowSelectionChanged(const QString &renderWindowId)
+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();
 }
diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h
index e94bf0afac..8eaec8973a 100644
--- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h
+++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h
@@ -1,75 +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.
 
 ===================================================================*/
 
 #ifndef QMITKRENDERWINDOWMANAGERVIEW_H
 #define QMITKRENDERWINDOWMANAGERVIEW_H
 
 // render window manager plugin
 #include "ui_QmitkRenderWindowManagerControls.h"
 
 // render window manager UI module
 #include <QmitkDataStorageRenderWindowInspector.h>
 
 // mitk gui qt application
 #include <QmitkDataNodeContextMenu.h>
 
 // mitk gui qt common plugin
 #include <QmitkAbstractView.h>
 
 /**
 * @brief RenderWindowManager
 */
 class QmitkRenderWindowManagerView : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
 protected:
 
   virtual void SetFocus() override;
 
   virtual void CreateQtPartControl(QWidget* parent) override;
 
 private Q_SLOTS:
 
   /**
   * @brief Called when the user changes the render window selection in the combo box.
   *
   * @param renderWindowId   The text inside the combo box.
   */
-  void OnRenderWindowSelectionChanged(const QString &renderWindowId);
+  void OnRenderWindowSelectionChanged(const QString& renderWindowId);
 
 private:
 
   void SetControlledRenderer();
 
   QWidget* m_Parent;
   Ui::QmitkRenderWindowManagerControls m_Controls;
 
   QmitkDataStorageRenderWindowInspector* m_RenderWindowInspector;
   QmitkDataNodeContextMenu* m_DataNodeContextMenu;
   QAbstractItemView* m_InspectorView;
 
   mitk::RenderWindowLayerUtilities::RendererVector m_ControlledRenderer;
 
   virtual QItemSelectionModel* GetDataNodeSelectionModel() const override;
 
 };
 
 #endif // QMITKRENDERWINDOWMANAGERVIEW_H