diff --git a/Plugins/org.mitk.gui.qt.dicominspector/src/internal/QmitkDicomInspectorView.cpp b/Plugins/org.mitk.gui.qt.dicominspector/src/internal/QmitkDicomInspectorView.cpp
index 5b601b2f03..9004dac7f8 100644
--- a/Plugins/org.mitk.gui.qt.dicominspector/src/internal/QmitkDicomInspectorView.cpp
+++ b/Plugins/org.mitk.gui.qt.dicominspector/src/internal/QmitkDicomInspectorView.cpp
@@ -1,377 +1,378 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 
 // mitk
 #include <QmitkRenderWindow.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkPixelTypeMultiplex.h>
 
 // Qt
 #include <QMessageBox>
 #include <QMessageBox>
 #include <QFileDialog>
 #include <qwt_plot_marker.h>
 
 #include "QmitkDicomInspectorView.h"
 
 const std::string QmitkDicomInspectorView::VIEW_ID = "org.mitk.views.dicominspector";
 
 QmitkDicomInspectorView::ObserverInfo::ObserverInfo(mitk::SliceNavigationController* controller,
   int observerTag, const std::string& renderWindowName, mitk::IRenderWindowPart* part) : controller(controller), observerTag(observerTag),
   renderWindowName(renderWindowName), renderWindowPart(part)
 {
 }
 
 QmitkDicomInspectorView::QmitkDicomInspectorView()
   : m_RenderWindowPart(nullptr)
   , m_PendingSliceChangedEvent(false)
   , m_SelectedNode(nullptr)
   , m_SelectedTimePoint(0.)
   , m_CurrentSelectedZSlice(0)
 {
   m_SelectedPosition.Fill(0.0);
 }
 
 QmitkDicomInspectorView::~QmitkDicomInspectorView()
 {
   this->RemoveAllObservers();
 }
 
 void QmitkDicomInspectorView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart != renderWindowPart)
   {
     m_RenderWindowPart = renderWindowPart;
 
     if (!InitObservers())
     {
       QMessageBox::information(nullptr, "Error", "Unable to set up the event observers. The " \
         "plot will not be triggered on changing the crosshair, " \
         "position or time step.");
     }
   }
 }
 
 void QmitkDicomInspectorView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   m_RenderWindowPart = nullptr;
   this->RemoveAllObservers(renderWindowPart);
 }
 
 void QmitkDicomInspectorView::CreateQtPartControl(QWidget* parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
 
   m_Controls.singleSlot->SetDataStorage(GetDataStorage());
   m_Controls.singleSlot->SetSelectionIsOptional(true);
+  m_Controls.singleSlot->SetAutoSelectNewNodes(true);
   m_Controls.singleSlot->SetEmptyInfo(QString("Please select a data node"));
   m_Controls.singleSlot->SetPopUpTitel(QString("Select data node"));
 
   m_SelectionServiceConnector = std::make_unique<QmitkSelectionServiceConnector>();
   SetAsSelectionListener(true);
 
   m_Controls.timePointValueLabel->setText(QString(""));
   m_Controls.sliceNumberValueLabel->setText(QString(""));
 
   connect(m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkDicomInspectorView::OnCurrentSelectionChanged);
 
   mitk::IRenderWindowPart* renderWindowPart = GetRenderWindowPart();
   RenderWindowPartActivated(renderWindowPart);
 }
 
 bool QmitkDicomInspectorView::InitObservers()
 {
   bool result = true;
 
   typedef QHash<QString, QmitkRenderWindow*> WindowMapType;
   WindowMapType windowMap = m_RenderWindowPart->GetQmitkRenderWindows();
 
   auto i = windowMap.begin();
 
   while (i != windowMap.end())
   {
     mitk::SliceNavigationController* sliceNavController =
       i.value()->GetSliceNavigationController();
 
     if (sliceNavController)
     {
       auto cmdSliceEvent = itk::SimpleMemberCommand<QmitkDicomInspectorView>::New();
       cmdSliceEvent->SetCallbackFunction(this, &QmitkDicomInspectorView::OnSliceChanged);
       int tag = sliceNavController->AddObserver(
         mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), cmdSliceEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_RenderWindowPart)));
 
       auto cmdTimeEvent = itk::SimpleMemberCommand<QmitkDicomInspectorView>::New();
       cmdTimeEvent->SetCallbackFunction(this, &QmitkDicomInspectorView::OnSliceChanged);
       tag = sliceNavController->AddObserver(
         mitk::SliceNavigationController::GeometryTimeEvent(nullptr, 0), cmdTimeEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_RenderWindowPart)));
 
       auto cmdDelEvent = itk::MemberCommand<QmitkDicomInspectorView>::New();
       cmdDelEvent->SetCallbackFunction(this, &QmitkDicomInspectorView::OnSliceNavigationControllerDeleted);
       tag = sliceNavController->AddObserver(itk::DeleteEvent(), cmdDelEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_RenderWindowPart)));
     }
 
     ++i;
 
     result = result && sliceNavController;
   }
 
   return result;
 }
 
 void QmitkDicomInspectorView::RemoveObservers(const mitk::SliceNavigationController* deletedSlicer)
 {
   std::pair<ObserverMapType::const_iterator, ObserverMapType::const_iterator> obsRange =
     m_ObserverMap.equal_range(deletedSlicer);
 
   for (ObserverMapType::const_iterator pos = obsRange.first; pos != obsRange.second; ++pos)
   {
     pos->second.controller->RemoveObserver(pos->second.observerTag);
   }
 
   m_ObserverMap.erase(deletedSlicer);
 }
 
 void QmitkDicomInspectorView::RemoveAllObservers(mitk::IRenderWindowPart* deletedPart)
 {
   for (ObserverMapType::const_iterator pos = m_ObserverMap.begin(); pos != m_ObserverMap.end();)
   {
     ObserverMapType::const_iterator delPos = pos++;
 
     if (nullptr == deletedPart || deletedPart == delPos->second.renderWindowPart)
     {
       delPos->second.controller->RemoveObserver(delPos->second.observerTag);
       m_ObserverMap.erase(delPos);
     }
   }
 }
 
 void QmitkDicomInspectorView::OnCurrentSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   if (nodes.empty() || nodes.front().IsNull())
   {
     m_SelectedNode = nullptr;
     m_SelectedData = nullptr;
     UpdateData();
     return;
   }
 
   if (nodes.front() != this->m_SelectedNode)
   {
     // node is selected, create DICOM tag table
     m_SelectedNode = nodes.front();
     m_SelectedData = this->m_SelectedNode->GetData();
 
     m_SelectedNodeTime.Modified();
     UpdateData();
     OnSliceChangedDelayed();
   }
 }
 
 void QmitkDicomInspectorView::OnSliceChanged()
 {
   // Taken from QmitkStdMultiWidget::HandleCrosshairPositionEvent().
   // Since there are always 3 events arriving (one for each render window) every time the slice
   // or time changes, the slot OnSliceChangedDelayed is triggered - and only if it hasn't been
   // triggered yet - so it is only executed once for every slice/time change.
   if (!m_PendingSliceChangedEvent)
   {
     m_PendingSliceChangedEvent = true;
 
     QTimer::singleShot(0, this, SLOT(OnSliceChangedDelayed()));
   }
 }
 
 void QmitkDicomInspectorView::OnSliceNavigationControllerDeleted(const itk::Object* sender, const itk::EventObject& /*e*/)
 {
   auto sendingSlicer = dynamic_cast<const mitk::SliceNavigationController*>(sender);
 
   this->RemoveObservers(sendingSlicer);
 }
 
 void QmitkDicomInspectorView::ValidateAndSetCurrentPosition()
 {
   auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
   auto currentSelectedPosition = renderWindowPart->GetSelectedPosition(nullptr);
   const auto currentSelectedTimePoint = renderWindowPart->GetSelectedTimePoint();
 
   if (m_SelectedPosition != currentSelectedPosition
     || m_SelectedTimePoint != currentSelectedTimePoint
     || m_SelectedNodeTime > m_CurrentPositionTime)
   {
     // the current position has been changed, the selected node has been changed since
     // the last position validation or the current time position has been changed -> check position
     m_SelectedPosition = currentSelectedPosition;
     m_SelectedTimePoint = currentSelectedTimePoint;
     m_CurrentPositionTime.Modified();
     m_ValidSelectedPosition = false;
 
     if (m_SelectedData.IsNull())
     {
       return;
     }
 
     mitk::BaseGeometry::Pointer geometry = m_SelectedData->GetTimeGeometry()->GetGeometryForTimePoint(m_SelectedTimePoint);
 
     // check for invalid time step
     if (geometry.IsNull())
     {
       geometry = m_SelectedData->GetTimeGeometry()->GetGeometryForTimeStep(0);
     }
 
     if (geometry.IsNull())
     {
       return;
     }
 
     m_ValidSelectedPosition = geometry->IsInside(m_SelectedPosition);
     itk::Index<3> index;
     geometry->WorldToIndex(m_SelectedPosition, index);
 
     m_CurrentSelectedZSlice = index[2];
   }
 }
 
 void QmitkDicomInspectorView::OnSliceChangedDelayed()
 {
   m_PendingSliceChangedEvent = false;
 
   ValidateAndSetCurrentPosition();
 
   m_Controls.tableTags->setEnabled(m_ValidSelectedPosition);
 
   if (m_SelectedNode.IsNotNull())
   {
     RenderTable();
   }
 }
 
 void QmitkDicomInspectorView::RenderTable()
 {
   assert(nullptr != m_RenderWindowPart);
 
   const auto timeStep = (m_SelectedData.IsNull()) ? 0 : m_SelectedData->GetTimeGeometry()->TimePointToTimeStep(m_SelectedTimePoint);
 
   unsigned int rowIndex = 0;
   for (const auto& element : m_Tags)
   {
     QTableWidgetItem* newItem = new QTableWidgetItem(QString::fromStdString(
       element.second.prop->GetValue(timeStep, m_CurrentSelectedZSlice, true, true)));
     m_Controls.tableTags->setItem(rowIndex, 3, newItem);
     ++rowIndex;
   }
 
   UpdateLabels();
 }
 
 void QmitkDicomInspectorView::UpdateData()
 {
   QStringList headers;
 
   m_Controls.tableTags->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
 
   m_Tags.clear();
 
   if (m_SelectedData.IsNotNull())
   {
     for (const auto& element : *(m_SelectedData->GetPropertyList()->GetMap()))
     {
       if (element.first.find("DICOM") == 0)
       {
         std::istringstream stream(element.first);
         std::string token;
         std::getline(stream, token, '.'); //drop the DICOM suffix
         std::getline(stream, token, '.'); //group id
         unsigned long dcmgroup = std::stoul(token, nullptr, 16);
         std::getline(stream, token, '.'); //element id
         unsigned long dcmelement = std::stoul(token, nullptr, 16);
 
         TagInfo info(mitk::DICOMTag(dcmgroup, dcmelement), dynamic_cast<const mitk::DICOMProperty*>(element.second.GetPointer()));
 
         m_Tags.insert(std::make_pair(element.first, info));
       }
     }
   }
 
   m_Controls.tableTags->setRowCount(m_Tags.size());
 
   unsigned int rowIndex = 0;
   for (const auto& element : m_Tags)
   {
     QTableWidgetItem* newItem = new QTableWidgetItem(QString::number(element.second.tag.GetGroup(), 16));
     m_Controls.tableTags->setItem(rowIndex, 0, newItem);
     newItem = new QTableWidgetItem(QString::number(element.second.tag.GetElement(), 16));
     m_Controls.tableTags->setItem(rowIndex, 1, newItem);
     newItem = new QTableWidgetItem(QString::fromStdString(element.second.tag.GetName()));
     m_Controls.tableTags->setItem(rowIndex, 2, newItem);
     newItem = new QTableWidgetItem(QString::fromStdString(element.second.prop->GetValue()));
     m_Controls.tableTags->setItem(rowIndex, 3, newItem);
     ++rowIndex;
   }
 
   UpdateLabels();
 }
 
 void QmitkDicomInspectorView::UpdateLabels()
 {
   if (m_SelectedData.IsNull())
   {
     m_Controls.timePointValueLabel->setText(QString(""));
     m_Controls.sliceNumberValueLabel->setText(QString(""));
   }
   else
   {
     const auto timeStep = m_SelectedData->GetTimeGeometry()->TimePointToTimeStep(m_SelectedTimePoint);
 
     if (m_ValidSelectedPosition)
     {
       m_Controls.timePointValueLabel->setText(QString::number(timeStep) + QStringLiteral("(")+ QString::number(m_SelectedTimePoint/1000.) + QStringLiteral(" [s])"));
       m_Controls.sliceNumberValueLabel->setText(QString::number(m_CurrentSelectedZSlice));
     }
     else
     {
       m_Controls.timePointValueLabel->setText(QString("outside data geometry"));
       m_Controls.sliceNumberValueLabel->setText(QString("outside data geometry"));
     }
   }
 }
 
 void QmitkDicomInspectorView::SetAsSelectionListener(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
     connect(m_SelectionServiceConnector.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged,
       m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
   }
   else
   {
     m_SelectionServiceConnector->RemovePostSelectionListener();
     disconnect(m_SelectionServiceConnector.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged,
       m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
index a95ddd70ce..70bc475007 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
@@ -1,370 +1,371 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkAddNewPropertyDialog.h"
 #include "QmitkPropertyItemDelegate.h"
 #include "QmitkPropertyItemModel.h"
 #include "QmitkPropertyItemSortFilterProxyModel.h"
 #include "QmitkPropertyTreeView.h"
 #include <berryIBerryPreferences.h>
 #include <berryQtStyleManager.h>
 #include <mitkIPropertyAliases.h>
 #include <mitkIPropertyDescriptions.h>
 #include <mitkIPropertyPersistence.h>
 #include <QmitkRenderWindow.h>
 #include <QPainter>
 #include <memory>
 
 const std::string QmitkPropertyTreeView::VIEW_ID = "org.mitk.views.properties";
 
 QmitkPropertyTreeView::QmitkPropertyTreeView()
   : m_PropertyAliases(mitk::CoreServices::GetPropertyAliases(nullptr), nullptr),
     m_PropertyDescriptions(mitk::CoreServices::GetPropertyDescriptions(nullptr), nullptr),
     m_PropertyPersistence(mitk::CoreServices::GetPropertyPersistence(nullptr), nullptr),
     m_ProxyModel(nullptr),
     m_Model(nullptr),
     m_Delegate(nullptr),
     m_Renderer(nullptr)
 {
 }
 
 QmitkPropertyTreeView::~QmitkPropertyTreeView()
 {
 }
 
 void QmitkPropertyTreeView::SetFocus()
 {
   m_Controls.filterLineEdit->setFocus();
 }
 
 void QmitkPropertyTreeView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_Controls.propertyListComboBox->count() == 2)
   {
     QHash<QString, QmitkRenderWindow*> renderWindows = renderWindowPart->GetQmitkRenderWindows();
 
     Q_FOREACH(QString renderWindow, renderWindows.keys())
     {
       m_Controls.propertyListComboBox->insertItem(m_Controls.propertyListComboBox->count() - 1, QString("Data node: ") + renderWindow);
     }
   }
 }
 
 void QmitkPropertyTreeView::RenderWindowPartDeactivated(mitk::IRenderWindowPart*)
 {
   if (m_Controls.propertyListComboBox->count() > 2)
   {
     m_Controls.propertyListComboBox->clear();
     m_Controls.propertyListComboBox->addItem("Data node: common");
     m_Controls.propertyListComboBox->addItem("Base data");
   }
 }
 
 void QmitkPropertyTreeView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
 
   m_Controls.propertyListComboBox->addItem("Data node: common");
 
   mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
   if (renderWindowPart != nullptr)
   {
     QHash<QString, QmitkRenderWindow*> renderWindows = renderWindowPart->GetQmitkRenderWindows();
 
     for(const auto& renderWindow : renderWindows.keys())
     {
       m_Controls.propertyListComboBox->addItem(QString("Data node: ") + renderWindow);
     }
   }
 
   m_Controls.propertyListComboBox->addItem("Base data");
 
   m_Controls.newButton->setEnabled(false);
 
   this->HideAllIcons();
 
   m_ProxyModel = new QmitkPropertyItemSortFilterProxyModel(m_Controls.treeView);
   m_Model = new QmitkPropertyItemModel(m_ProxyModel);
 
   m_ProxyModel->setSourceModel(m_Model);
   m_ProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
   m_ProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
   m_ProxyModel->setDynamicSortFilter(true);
 
   m_Delegate = new QmitkPropertyItemDelegate(m_Controls.treeView);
 
   m_Controls.singleSlot->SetDataStorage(GetDataStorage());
   m_Controls.singleSlot->SetSelectionIsOptional(true);
+  m_Controls.singleSlot->SetAutoSelectNewNodes(true);
   m_Controls.singleSlot->SetEmptyInfo(QString("Please select a data node"));
   m_Controls.singleSlot->SetPopUpTitel(QString("Select data node"));
 
   m_SelectionServiceConnector = std::make_unique<QmitkSelectionServiceConnector>();
   SetAsSelectionListener(true);
 
   m_Controls.filterLineEdit->setClearButtonEnabled(true);
 
   m_Controls.treeView->setItemDelegateForColumn(1, m_Delegate);
   m_Controls.treeView->setModel(m_ProxyModel);
   m_Controls.treeView->setColumnWidth(0, 160);
   m_Controls.treeView->sortByColumn(0, Qt::AscendingOrder);
   m_Controls.treeView->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_Controls.treeView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.treeView->setEditTriggers(QAbstractItemView::SelectedClicked | QAbstractItemView::DoubleClicked);
 
   const int ICON_SIZE = 32;
 
   auto icon = berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/tags.svg"));
   m_Controls.tagsLabel->setPixmap(icon.pixmap(ICON_SIZE));
 
   icon = berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/tag.svg"));
   m_Controls.tagLabel->setPixmap(icon.pixmap(ICON_SIZE));
 
   icon = berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-save.svg"));
   m_Controls.saveLabel->setPixmap(icon.pixmap(ICON_SIZE));
 
   connect(m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkPropertyTreeView::OnCurrentSelectionChanged);
   connect(m_Controls.filterLineEdit, &QLineEdit::textChanged,
     this, &QmitkPropertyTreeView::OnFilterTextChanged);
   connect(m_Controls.propertyListComboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
     this, &QmitkPropertyTreeView::OnPropertyListChanged);
   connect(m_Controls.newButton, &QPushButton::clicked,
     this, &QmitkPropertyTreeView::OnAddNewProperty);
   connect(m_Controls.treeView->selectionModel(), &QItemSelectionModel::currentRowChanged,
     this, &QmitkPropertyTreeView::OnCurrentRowChanged);
   connect(m_Model, &QmitkPropertyItemModel::modelReset,
     this, &QmitkPropertyTreeView::OnModelReset);
 }
 
 void QmitkPropertyTreeView::SetAsSelectionListener(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
     connect(m_SelectionServiceConnector.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
   }
   else
   {
     m_SelectionServiceConnector->RemovePostSelectionListener();
     disconnect(m_SelectionServiceConnector.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
   }
 }
 
 QString QmitkPropertyTreeView::GetPropertyNameOrAlias(const QModelIndex& index)
 {
   QString propertyName;
 
   if (index.isValid())
   {
     QModelIndex current = index;
 
     while (current.isValid())
     {
       QString name = m_ProxyModel->data(m_ProxyModel->index(current.row(), 0, current.parent())).toString();
 
       propertyName.prepend(propertyName.isEmpty()
         ? name
         : name.append('.'));
 
       current = current.parent();
     }
   }
 
   return propertyName;
 }
 
 void QmitkPropertyTreeView::OnCurrentSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   if (nodes.empty() || nodes.front().IsNull())
   {
     m_SelectedNode = nullptr;
 
     this->SetPartName("Properties");
     m_Model->SetPropertyList(nullptr);
     m_Delegate->SetPropertyList(nullptr);
 
     m_Controls.newButton->setEnabled(false);
 
     return;
   }
 
   // node is selected, create tree with node properties
   m_SelectedNode = nodes.front();
   mitk::PropertyList* propertyList = m_Model->GetPropertyList();
   if (m_Renderer == nullptr && m_Controls.propertyListComboBox->currentText() == "Base data")
   {
     propertyList = m_SelectedNode->GetData() != nullptr
       ? m_SelectedNode->GetData()->GetPropertyList()
       : nullptr;
   }
   else
   {
     propertyList = m_SelectedNode->GetPropertyList(m_Renderer);
   }
 
   QString selectionClassName = m_SelectedNode->GetData() != nullptr
     ? m_SelectedNode->GetData()->GetNameOfClass()
     : "";
 
   m_SelectionClassName = selectionClassName.toStdString();
 
   m_Model->SetPropertyList(propertyList, selectionClassName);
   m_Delegate->SetPropertyList(propertyList);
 
   m_Controls.newButton->setEnabled(true);
 
   if (!m_ProxyModel->filterRegExp().isEmpty())
   {
     m_Controls.treeView->expandAll();
   }
 }
 
 void QmitkPropertyTreeView::HideAllIcons()
 {
   m_Controls.tagLabel->hide();
   m_Controls.tagsLabel->hide();
   m_Controls.saveLabel->hide();
 }
 
 void QmitkPropertyTreeView::OnCurrentRowChanged(const QModelIndex& current, const QModelIndex&)
 {
   if (current.isValid())
   {
     QString name = this->GetPropertyNameOrAlias(current);
 
     if (!name.isEmpty())
     {
       QString alias;
       bool isTrueName = true;
 
       std::string trueName = m_PropertyAliases->GetPropertyName(name.toStdString());
 
       if (trueName.empty() && !m_SelectionClassName.empty())
         trueName = m_PropertyAliases->GetPropertyName(name.toStdString(), m_SelectionClassName);
 
       if (!trueName.empty())
       {
         alias = name;
         name = QString::fromStdString(trueName);
         isTrueName = false;
       }
 
       QString description = QString::fromStdString(m_PropertyDescriptions->GetDescription(name.toStdString()));
       std::vector<std::string> aliases;
 
       if (!isTrueName)
       {
         aliases = m_PropertyAliases->GetAliases(name.toStdString(), m_SelectionClassName);
 
         if (aliases.empty() && !m_SelectionClassName.empty())
           aliases = m_PropertyAliases->GetAliases(name.toStdString());
       }
 
       bool isPersistent = m_PropertyPersistence->HasInfo(name.toStdString());
 
       if (!description.isEmpty() || !aliases.empty() || isPersistent)
       {
         QString customizedDescription;
 
         if (!aliases.empty())
         {
           customizedDescription = "<h3 style=\"margin-bottom:0\">" + name + "</h3>";
 
           std::size_t numAliases = aliases.size();
           std::size_t lastAlias = numAliases - 1;
 
           for (std::size_t i = 0; i < numAliases; ++i)
           {
             customizedDescription += i != lastAlias
               ? "<h5 style=\"margin-top:0;margin-bottom:0\">"
               : "<h5 style=\"margin-top:0;margin-bottom:10px\">";
 
             customizedDescription += QString::fromStdString(aliases[i]) + "</h5>";
           }
         }
         else
         {
           customizedDescription = "<h3 style=\"margin-bottom:10px\">" + name + "</h3>";
         }
 
         if (!description.isEmpty())
           customizedDescription += "<p>" + description + "</p>";
 
         m_Controls.tagsLabel->setVisible(!aliases.empty() && aliases.size() > 1);
         m_Controls.tagLabel->setVisible(!aliases.empty() && aliases.size() == 1);
         m_Controls.saveLabel->setVisible(isPersistent);
 
         m_Controls.descriptionLabel->setText(customizedDescription);
         m_Controls.descriptionLabel->show();
 
         return;
       }
     }
   }
 
   m_Controls.descriptionLabel->hide();
   this->HideAllIcons();
 }
 
 void QmitkPropertyTreeView::OnPropertyListChanged(int index)
 {
   if (index == -1)
     return;
 
   QString renderer = m_Controls.propertyListComboBox->itemText(index);
 
   if (renderer.startsWith("Data node: "))
     renderer = QString::fromStdString(renderer.toStdString().substr(11));
 
   m_Renderer = nullptr;
 
   if (renderer != "common" && renderer != "Base data")
   {
     auto* renderWindowPart = this->GetRenderWindowPart();
 
     if (nullptr != renderWindowPart)
       m_Renderer = renderWindowPart->GetQmitkRenderWindow(renderer)->GetRenderer();
   }
 
   QList<mitk::DataNode::Pointer> nodes;
 
   if (m_SelectedNode.IsNotNull())
     nodes << m_SelectedNode;
 
   this->OnCurrentSelectionChanged(nodes);
 }
 
 void QmitkPropertyTreeView::OnAddNewProperty()
 {
   std::unique_ptr<QmitkAddNewPropertyDialog> dialog(m_Controls.propertyListComboBox->currentText() != "Base data"
     ? new QmitkAddNewPropertyDialog(m_SelectedNode, m_Renderer)
     : new QmitkAddNewPropertyDialog(m_SelectedNode->GetData()));
 
   if (dialog->exec() == QDialog::Accepted)
     this->m_Model->Update();
 }
 
 void QmitkPropertyTreeView::OnFilterTextChanged(const QString& filter)
 {
   m_ProxyModel->setFilterWildcard(filter);
 
   if (filter.isEmpty())
     m_Controls.treeView->collapseAll();
   else
     m_Controls.treeView->expandAll();
 }
 
 void QmitkPropertyTreeView::OnModelReset()
 {
   m_Controls.descriptionLabel->hide();
   this->HideAllIcons();
 }
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
index 7ab3ab1e54..b9b80e8e0b 100755
--- a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
@@ -1,292 +1,293 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkVolumeVisualizationView.h"
 
 #include <vtkSmartVolumeMapper.h>
 
 #include <mitkImage.h>
 
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionInitializer.h>
 #include <mitkTransferFunctionProperty.h>
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateProperty.h>
 
 #include <mitkProperties.h>
 
 const std::string QmitkVolumeVisualizationView::VIEW_ID = "org.mitk.views.volumevisualization";
 
 enum
 {
   DEFAULT_RENDERMODE = 0,
   RAYCAST_RENDERMODE = 1,
   GPU_RENDERMODE = 2
 };
 
 QmitkVolumeVisualizationView::QmitkVolumeVisualizationView()
   : QmitkAbstractView()
   , m_Controls(nullptr)
 {
 }
 
 void QmitkVolumeVisualizationView::SetFocus()
 {
 }
 
 void QmitkVolumeVisualizationView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls = new Ui::QmitkVolumeVisualizationViewControls;
   m_Controls->setupUi(parent);
 
   m_Controls->volumeSelectionWidget->SetDataStorage(GetDataStorage());
   m_Controls->volumeSelectionWidget->SetNodePredicate(mitk::NodePredicateAnd::New(
     mitk::TNodePredicateDataType<mitk::Image>::New(),
     mitk::NodePredicateOr::New(mitk::NodePredicateDimension::New(3), mitk::NodePredicateDimension::New(4)),
     mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))));
   m_Controls->volumeSelectionWidget->SetSelectionIsOptional(true);
+  m_Controls->volumeSelectionWidget->SetAutoSelectNewNodes(true);
   m_Controls->volumeSelectionWidget->SetEmptyInfo(QString("Please select a 3D / 4D image volume"));
   m_Controls->volumeSelectionWidget->SetPopUpTitel(QString("Select image volume"));
 
   // Fill the transfer function presets in the generator widget
   std::vector<std::string> names;
   mitk::TransferFunctionInitializer::GetPresetNames(names);
   for (const auto& name : names)
   {
     m_Controls->transferFunctionGeneratorWidget->AddPreset(QString::fromStdString(name));
   }
 
   // see enum in vtkSmartVolumeMapper
   m_Controls->renderMode->addItem("Default");
   m_Controls->renderMode->addItem("RayCast");
   m_Controls->renderMode->addItem("GPU");
 
   // see vtkVolumeMapper::BlendModes
   m_Controls->blendMode->addItem("Comp");
   m_Controls->blendMode->addItem("Max");
   m_Controls->blendMode->addItem("Min");
   m_Controls->blendMode->addItem("Avg");
   m_Controls->blendMode->addItem("Add");
 
   connect(m_Controls->volumeSelectionWidget, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkVolumeVisualizationView::OnCurrentSelectionChanged);
   connect(m_Controls->enableRenderingCB, SIGNAL(toggled(bool)), this, SLOT(OnEnableRendering(bool)));
   connect(m_Controls->renderMode, SIGNAL(activated(int)), this, SLOT(OnRenderMode(int)));
   connect(m_Controls->blendMode, SIGNAL(activated(int)), this, SLOT(OnBlendMode(int)));
 
   connect(m_Controls->transferFunctionGeneratorWidget, SIGNAL(SignalUpdateCanvas()),
           m_Controls->transferFunctionWidget, SLOT(OnUpdateCanvas()));
   connect(m_Controls->transferFunctionGeneratorWidget, SIGNAL(SignalTransferFunctionModeChanged(int)),
           SLOT(OnMitkInternalPreset(int)));
 
   m_Controls->enableRenderingCB->setEnabled(false);
   m_Controls->blendMode->setEnabled(false);
   m_Controls->renderMode->setEnabled(false);
   m_Controls->transferFunctionWidget->setEnabled(false);
   m_Controls->transferFunctionGeneratorWidget->setEnabled(false);
 
   m_Controls->volumeSelectionWidget->SetAutoSelectNewNodes(true);
 }
 
 void QmitkVolumeVisualizationView::OnMitkInternalPreset(int mode)
 {
   if (m_SelectedNode.IsExpired())
   {
     return;
   }
 
   auto node = m_SelectedNode.Lock();
   mitk::TransferFunctionProperty::Pointer transferFuncProp;
   if (node->GetProperty(transferFuncProp, "TransferFunction"))
   {
     // first item is only information
     if (--mode == -1)
       return;
 
     // -- Creat new TransferFunction
     mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(transferFuncProp->GetValue());
     tfInit->SetTransferFunctionMode(mode);
     RequestRenderWindowUpdate();
     m_Controls->transferFunctionWidget->OnUpdateCanvas();
   }
 }
 
 void QmitkVolumeVisualizationView::OnCurrentSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   m_SelectedNode = nullptr;
 
   if (nodes.empty() || nodes.front().IsNull())
   {
     UpdateInterface();
     return;
   }
 
   auto selectedNode = nodes.front();
   auto image = dynamic_cast<mitk::Image*>(selectedNode->GetData());
   if (nullptr != image)
   {
     m_SelectedNode = selectedNode;
   }
 
   UpdateInterface();
 }
 
 void QmitkVolumeVisualizationView::OnEnableRendering(bool state)
 {
   if (m_SelectedNode.IsExpired())
   {
     return;
   }
 
   m_SelectedNode.Lock()->SetProperty("volumerendering", mitk::BoolProperty::New(state));
   UpdateInterface();
   RequestRenderWindowUpdate();
 }
 
 void QmitkVolumeVisualizationView::OnRenderMode(int mode)
 {
   if (m_SelectedNode.IsExpired())
   {
     return;
   }
 
   auto selectedNode = m_SelectedNode.Lock();
 
   bool usegpu = false;
   bool useray = false;
   if (DEFAULT_RENDERMODE == mode)
   {
     useray = true;
     usegpu = true;
   }
   else if (GPU_RENDERMODE == mode)
   {
     usegpu = true;
   }
   else if (RAYCAST_RENDERMODE == mode)
   {
     useray = true;
   }
 
   selectedNode->SetProperty("volumerendering.usegpu", mitk::BoolProperty::New(usegpu));
   selectedNode->SetProperty("volumerendering.useray", mitk::BoolProperty::New(useray));
 
   RequestRenderWindowUpdate();
 }
 
 void QmitkVolumeVisualizationView::OnBlendMode(int mode)
 {
   if (m_SelectedNode.IsExpired())
   {
     return;
   }
 
   auto selectedNode = m_SelectedNode.Lock();
 
   bool usemip = false;
   if (vtkVolumeMapper::MAXIMUM_INTENSITY_BLEND == mode)
   {
     usemip = true;
   }
 
   selectedNode->SetProperty("volumerendering.usemip", mitk::BoolProperty::New(usemip));
   selectedNode->SetProperty("volumerendering.blendmode", mitk::IntProperty::New(mode));
 
   RequestRenderWindowUpdate();
 }
 
 void QmitkVolumeVisualizationView::UpdateInterface()
 {
   if (m_SelectedNode.IsExpired())
   {
     // turnoff all
     m_Controls->enableRenderingCB->setChecked(false);
     m_Controls->enableRenderingCB->setEnabled(false);
 
     m_Controls->blendMode->setCurrentIndex(0);
     m_Controls->blendMode->setEnabled(false);
 
     m_Controls->renderMode->setCurrentIndex(0);
     m_Controls->renderMode->setEnabled(false);
 
     m_Controls->transferFunctionWidget->SetDataNode(nullptr);
     m_Controls->transferFunctionWidget->setEnabled(false);
 
     m_Controls->transferFunctionGeneratorWidget->SetDataNode(nullptr);
     m_Controls->transferFunctionGeneratorWidget->setEnabled(false);
     return;
   }
 
   bool enabled = false;
   auto selectedNode = m_SelectedNode.Lock();
 
   selectedNode->GetBoolProperty("volumerendering", enabled);
   m_Controls->enableRenderingCB->setEnabled(true);
   m_Controls->enableRenderingCB->setChecked(enabled);
 
   if (!enabled)
   {
     // turnoff all except volumerendering checkbox
     m_Controls->blendMode->setCurrentIndex(0);
     m_Controls->blendMode->setEnabled(false);
 
     m_Controls->renderMode->setCurrentIndex(0);
     m_Controls->renderMode->setEnabled(false);
 
     m_Controls->transferFunctionWidget->SetDataNode(nullptr);
     m_Controls->transferFunctionWidget->setEnabled(false);
 
     m_Controls->transferFunctionGeneratorWidget->SetDataNode(nullptr);
     m_Controls->transferFunctionGeneratorWidget->setEnabled(false);
     return;
   }
 
   // otherwise we can activate em all
   m_Controls->blendMode->setEnabled(true);
   m_Controls->renderMode->setEnabled(true);
 
   // Determine Combo Box mode
   {
     bool usegpu = false;
     bool useray = false;
     bool usemip = false;
     selectedNode->GetBoolProperty("volumerendering.usegpu", usegpu);
     selectedNode->GetBoolProperty("volumerendering.useray", useray);
     selectedNode->GetBoolProperty("volumerendering.usemip", usemip);
 
     int blendMode;
     if (selectedNode->GetIntProperty("volumerendering.blendmode", blendMode))
       m_Controls->blendMode->setCurrentIndex(blendMode);
 
     if (usemip)
       m_Controls->blendMode->setCurrentIndex(vtkVolumeMapper::MAXIMUM_INTENSITY_BLEND);
 
     int mode = DEFAULT_RENDERMODE;
 
     if (useray)
       mode = RAYCAST_RENDERMODE;
     else if (usegpu)
       mode = GPU_RENDERMODE;
 
     m_Controls->renderMode->setCurrentIndex(mode);
   }
 
   m_Controls->transferFunctionWidget->SetDataNode(selectedNode);
   m_Controls->transferFunctionWidget->setEnabled(true);
   m_Controls->transferFunctionGeneratorWidget->SetDataNode(selectedNode);
   m_Controls->transferFunctionGeneratorWidget->setEnabled(true);
 }