diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
index 5c1fd9476b..6d6ba00338 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
@@ -1,178 +1,178 @@
 /*============================================================================
 
 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 "QmitkAbstractNodeSelectionWidget.h"
 
 QmitkAbstractNodeSelectionWidget::QmitkAbstractNodeSelectionWidget(QWidget* parent) : QWidget(parent), m_InvalidInfo("Error. Select data."),
 m_EmptyInfo("Empty. Make a selection."), m_PopUpTitel("Select a data node"), m_PopUpHint(""),
 m_IsOptional(false), m_SelectOnlyVisibleNodes(true)
 {
 }
 
 QmitkAbstractNodeSelectionWidget::~QmitkAbstractNodeSelectionWidget()
 {
   if (!m_DataStorage.IsExpired())
   {
     auto dataStorage = m_DataStorage.Lock();
 
     // remove Listener for the data storage itself
     dataStorage->RemoveObserver(m_DataStorageDeletedTag);
 
     // remove "add node listener" from data storage
     dataStorage->AddNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeAddedToStorage));
 
     // remove "remove node listener" from data storage
     dataStorage->RemoveNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
   }
 }
 
 
 void QmitkAbstractNodeSelectionWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage == dataStorage)
   {
     return;
   }
 
   if (!m_DataStorage.IsExpired())
   {
     auto oldStorage = m_DataStorage.Lock();
 
     // remove Listener for the data storage itself
     oldStorage->RemoveObserver(m_DataStorageDeletedTag);
 
     // remove "add node listener" from old data storage
     oldStorage->AddNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeAddedToStorage));
 
     // remove "remove node listener" from old data storage
     oldStorage->RemoveNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
   }
 
   m_DataStorage = dataStorage;
 
   if (!m_DataStorage.IsExpired())
   {
     auto newStorage = m_DataStorage.Lock();
 
     // add Listener for the data storage itself
     auto command = itk::SimpleMemberCommand<QmitkAbstractNodeSelectionWidget>::New();
     command->SetCallbackFunction(this, &QmitkAbstractNodeSelectionWidget::SetDataStorageDeleted);
     m_DataStorageDeletedTag = newStorage->AddObserver(itk::DeleteEvent(), command);
 
     // add "add node listener" for new data storage
     newStorage->AddNodeEvent.AddListener(
       mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeAddedToStorage));
 
     // add remove node listener for new data storage
     newStorage->RemoveNodeEvent.AddListener(
       mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
   }
 
   // update model if the data storage has been changed
   m_DataStorage = dataStorage;
   this->OnDataStorageChanged();
   this->UpdateInfo();
 }
 
 void QmitkAbstractNodeSelectionWidget::SetNodePredicate(const mitk::NodePredicateBase* nodePredicate)
 {
   if (m_NodePredicate != nodePredicate)
   {
     m_NodePredicate = nodePredicate;
 
     this->OnNodePredicateChanged(nodePredicate);
     this->UpdateInfo();
   }
 }
 
 const mitk::NodePredicateBase* QmitkAbstractNodeSelectionWidget::GetNodePredicate() const
 {
   return m_NodePredicate;
 }
 
 QString QmitkAbstractNodeSelectionWidget::GetInvalidInfo() const
 {
   return m_InvalidInfo;
 }
 
 QString QmitkAbstractNodeSelectionWidget::GetEmptyInfo() const
 {
   return m_EmptyInfo;
 }
 
 QString QmitkAbstractNodeSelectionWidget::GetPopUpTitel() const
 {
   return m_PopUpTitel;
 }
 
 QString QmitkAbstractNodeSelectionWidget::GetPopUpHint() const
 {
   return m_PopUpHint;
 }
 
 bool QmitkAbstractNodeSelectionWidget::GetSelectionIsOptional() const
 {
   return m_IsOptional;
 }
 
 bool QmitkAbstractNodeSelectionWidget::GetSelectOnlyVisibleNodes() const
 {
   return m_SelectOnlyVisibleNodes;
 }
 
 void QmitkAbstractNodeSelectionWidget::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
 {
   m_SelectOnlyVisibleNodes = selectOnlyVisibleNodes;
 }
 
 void QmitkAbstractNodeSelectionWidget::SetInvalidInfo(QString info)
 {
   m_InvalidInfo = info;
   this->UpdateInfo();
 }
 
 void QmitkAbstractNodeSelectionWidget::SetEmptyInfo(QString info)
 {
   m_EmptyInfo = info;
   this->UpdateInfo();
 }
 
 void QmitkAbstractNodeSelectionWidget::SetPopUpTitel(QString info)
 {
   m_PopUpTitel = info;
 }
 
 void QmitkAbstractNodeSelectionWidget::SetPopUpHint(QString info)
 {
   m_PopUpHint = info;
 }
 
 void QmitkAbstractNodeSelectionWidget::SetSelectionIsOptional(bool isOptional)
 {
   m_IsOptional = isOptional;
   this->UpdateInfo();
 }
 
 void QmitkAbstractNodeSelectionWidget::SetDataStorageDeleted()
 {
   this->SetDataStorage(nullptr);
 }
 
-void QmitkAbstractNodeSelectionWidget::NodeAddedToStorage(const mitk::DataNode* node)
+void QmitkAbstractNodeSelectionWidget::NodeAddedToStorage(const mitk::DataNode* /*node*/)
 {
   //default implementation does nothing;
-}
\ No newline at end of file
+}
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp
index 4903728a49..d48e326c82 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp
@@ -1,336 +1,336 @@
 /*============================================================================
 
 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 "QmitkSingleNodeSelectionWidget.h"
 
 #include <berryQtStyleManager.h>
 #include <QMouseEvent>
 
 #include "QmitkNodeSelectionDialog.h"
 #include "QmitkNodeDetailsDialog.h"
 
 QmitkSingleNodeSelectionWidget::QmitkSingleNodeSelectionWidget(QWidget* parent) : QmitkAbstractNodeSelectionWidget(parent), m_AutoSelectNewNodes(false)
 {
   m_Controls.setupUi(this);
 
   m_Controls.btnSelect->installEventFilter(this);
   m_Controls.btnSelect->setVisible(true);
   m_Controls.btnClear->setVisible(false);
 
   m_Controls.btnClear->setIcon(berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org.mitk.gui.qt.common/times.svg")));
 
   this->UpdateInfo();
 
   connect(m_Controls.btnClear, SIGNAL(clicked(bool)), this, SLOT(OnClearSelection()));
 }
 
 QmitkSingleNodeSelectionWidget::~QmitkSingleNodeSelectionWidget()
 {
 }
 
 mitk::DataNode::Pointer QmitkSingleNodeSelectionWidget::ExtractCurrentValidSelection(const NodeList& nodes) const
 {
   mitk::DataNode::Pointer result = nullptr;
 
   if (m_DataStorage.IsExpired())
   {
     auto storage = m_DataStorage.Lock();
 
     for (auto node : nodes)
     {
       bool valid = storage->Exists(node);
       if (valid && m_NodePredicate.IsNotNull())
       {
         valid = m_NodePredicate->CheckNode(node);
       }
 
       if (valid)
       {
         result = node;
         break;
       }
     }
   }
 
   return result;
 }
 
 QmitkSingleNodeSelectionWidget::NodeList QmitkSingleNodeSelectionWidget::CompileEmitSelection() const
 {
   NodeList result;
 
   if (!m_SelectOnlyVisibleNodes)
   {
     result = m_ExternalSelection;
   }
 
   if (m_SelectedNode.IsNotNull() && !result.contains(m_SelectedNode))
   {
     result.append(m_SelectedNode);
   }
 
   return result;
 }
 
 void QmitkSingleNodeSelectionWidget::OnNodePredicateChanged(const mitk::NodePredicateBase* /*newPredicate*/)
 {
   auto lastEmission = this->CompileEmitSelection();
 
   if (m_NodePredicate.IsNotNull() && m_SelectedNode.IsNotNull() && !m_NodePredicate->CheckNode(m_SelectedNode))
   {
     m_SelectedNode = nullptr;
   }
 
   if (m_SelectedNode.IsNull())
   {
     m_SelectedNode = this->ExtractCurrentValidSelection(m_ExternalSelection);
   }
 
   this->DoAutoSelectIfNeeded();
 
   this->EmitAndUpdateIfNeeded(lastEmission);
 };
 
 void QmitkSingleNodeSelectionWidget::OnDataStorageChanged()
 {
   auto lastEmission = this->CompileEmitSelection();
 
   if (m_DataStorage.IsExpired())
   {
     m_SelectedNode = nullptr;
   }
   else if (m_SelectedNode.IsNotNull())
   {
     auto storage = m_DataStorage.Lock();
 
     if (!storage->Exists(m_SelectedNode))
     {
       m_SelectedNode = nullptr;
     }
   }
 
   if (m_SelectedNode.IsNull())
   {
     m_SelectedNode = this->ExtractCurrentValidSelection(m_ExternalSelection);
   }
 
   this->DoAutoSelectIfNeeded();
 
   this->EmitAndUpdateIfNeeded(lastEmission);
 };
 
 void QmitkSingleNodeSelectionWidget::OnClearSelection()
 {
   if (m_IsOptional)
   {
     NodeList emptyList;
     this->SetCurrentSelection(emptyList);
   }
 
   this->UpdateInfo();
 }
 
 mitk::DataNode::Pointer QmitkSingleNodeSelectionWidget::GetSelectedNode() const
 {
   return m_SelectedNode;
 };
 
 bool QmitkSingleNodeSelectionWidget::eventFilter(QObject *obj, QEvent *ev)
 {
   if (obj == m_Controls.btnSelect)
   {
     if (ev->type() == QEvent::MouseButtonRelease)
     {
       auto mouseEv = dynamic_cast<QMouseEvent*>(ev);
       if (!mouseEv)
       {
         return false;
       }
 
       if (mouseEv->button() == Qt::LeftButton)
       {
         if (this->isEnabled())
         {
           this->EditSelection();
           return true;
         }
       }
       else
       {
         auto selection = this->CompileEmitSelection();
         if (!selection.empty())
         {
           QmitkNodeDetailsDialog infoDialog(selection, this);
           infoDialog.exec();
           return true;
         }
       }
     }
   }
 
   return false;
 }
 
 void QmitkSingleNodeSelectionWidget::EditSelection()
 {
   QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(this, m_PopUpTitel, m_PopUpHint);
 
   dialog->SetDataStorage(m_DataStorage.Lock());
   dialog->SetNodePredicate(m_NodePredicate);
   NodeList list;
   if (m_SelectedNode.IsNotNull())
   {
     list.append(m_SelectedNode);
   }
   dialog->SetCurrentSelection(list);
   dialog->SetSelectOnlyVisibleNodes(m_SelectOnlyVisibleNodes);
   dialog->SetSelectionMode(QAbstractItemView::SingleSelection);
 
   m_Controls.btnSelect->setChecked(true);
 
   if (dialog->exec())
   {
     auto lastEmission = this->CompileEmitSelection();
 
     auto nodes = dialog->GetSelectedNodes();
     if (nodes.empty())
     {
       m_SelectedNode = nullptr;
     }
     else
     {
       m_SelectedNode = nodes.first();
     }
 
     this->EmitAndUpdateIfNeeded(lastEmission);
   }
 
   m_Controls.btnSelect->setChecked(false);
 
   delete dialog;
 };
 
 void QmitkSingleNodeSelectionWidget::UpdateInfo()
 {
   if (m_SelectedNode.IsNull())
   {
     if (m_IsOptional)
     {
       m_Controls.btnSelect->SetNodeInfo(m_EmptyInfo);
     }
     else
     {
       m_Controls.btnSelect->SetNodeInfo(m_InvalidInfo);
     }
     m_Controls.btnSelect->SetSelectionIsOptional(m_IsOptional);
     m_Controls.btnClear->setVisible(false);
   }
   else
   {
     m_Controls.btnClear->setVisible(m_IsOptional);
   }
 
   m_Controls.btnSelect->SetSelectedNode(m_SelectedNode);
 };
 
 void QmitkSingleNodeSelectionWidget::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
 {
   auto lastEmission = this->CompileEmitSelection();
 
   m_SelectOnlyVisibleNodes = selectOnlyVisibleNodes;
 
   this->EmitAndUpdateIfNeeded(lastEmission);
 };
 
 void QmitkSingleNodeSelectionWidget::DoAutoSelectIfNeeded()
 {
   if (m_SelectedNode.IsNull() && m_AutoSelectNewNodes && !m_DataStorage.IsExpired())
   {
     auto storage = m_DataStorage.Lock();
     if (m_NodePredicate.IsNotNull())
     {
       m_SelectedNode = storage->GetNode(m_NodePredicate);
     }
     else
     {
       m_SelectedNode = nullptr;
       auto nodes = storage->GetAll();
       if (!nodes->empty())
       {
         m_SelectedNode = nodes->front();
       }
     }
   }
 }
 
 void QmitkSingleNodeSelectionWidget::EmitAndUpdateIfNeeded(const NodeList& lastEmission)
 {
   auto newEmission = this->CompileEmitSelection();
 
   if (!EqualNodeSelections(lastEmission, newEmission))
   {
     this->UpdateInfo();
     emit CurrentSelectionChanged(newEmission);
   }
 };
 
 
 void QmitkSingleNodeSelectionWidget::SetCurrentSelection(NodeList selectedNodes)
 {
   auto lastEmission = this->CompileEmitSelection();
 
   m_ExternalSelection = selectedNodes;
   m_SelectedNode = this->ExtractCurrentValidSelection(selectedNodes);
 
   this->DoAutoSelectIfNeeded();
 
   this->EmitAndUpdateIfNeeded(lastEmission);
 };
 
-void QmitkSingleNodeSelectionWidget::NodeAddedToStorage(const mitk::DataNode* node)
+void QmitkSingleNodeSelectionWidget::NodeAddedToStorage(const mitk::DataNode* /*node*/)
 {
   if (m_SelectedNode.IsNull() && m_AutoSelectNewNodes && !m_DataStorage.IsExpired())
   {
     auto lastEmission = this->CompileEmitSelection();
 
     this->DoAutoSelectIfNeeded();
 
     this->EmitAndUpdateIfNeeded(lastEmission);
   }
 }
 
 void QmitkSingleNodeSelectionWidget::NodeRemovedFromStorage(const mitk::DataNode* node)
 {
   if (m_SelectedNode == node && node != nullptr)
   {
     m_SelectedNode = nullptr;
 
     this->DoAutoSelectIfNeeded();
 
     auto newEmission = this->CompileEmitSelection();
 
     emit CurrentSelectionChanged(newEmission);
     this->UpdateInfo();
   }
 }
 
 bool QmitkSingleNodeSelectionWidget::GetAutoSelectNewNodes() const
 {
   return m_AutoSelectNewNodes;
 }
 
 void QmitkSingleNodeSelectionWidget::SetAutoSelectNewNodes(bool autoSelect)
 {
   m_AutoSelectNewNodes = autoSelect;
   NodeAddedToStorage(nullptr);
 }