diff --git a/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss b/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
index 3f436c08cc..f2b1f818d3 100644
--- a/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
+++ b/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
@@ -1,610 +1,614 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 /*
   iconColor       = #c7c7c7 <- This line is parsed by MITK
   iconAccentColor = #d4821e <- This line is parsed by MITK
 */
 
 font.warning {
   color: #ff5c33;
   font-weight: bold;
 }
 
 font.normal {
   color: #f1f1f1;
 }
 
 font.highlight {
   color: #d4821e;
 }
 
+font.disabled {
+  color: #656565;
+}
+
 QWidget {
   background-color: #2d2d30;
   border: none;
   color: #f1f1f1;
 }
 
 QWidget:disabled {
   background-color: #2d2d30;
   border-color: #434346;
   color: #656565;
 }
 
 QStackedWidget {
   background-color: transparent;
 }
 
 QAbstractButton:hover, QComboBox:hover, QLineEdit:hover, QAbstractSpinBox:hover {
   background-color: #3f3f46;
 }
 
 QAbstractButton:pressed, QAbstractButton:checked {
   background-color: #434346;
 }
 
 QPushButton {
   border: 1px solid #3f3f46;
   padding: 4px 8px;
 }
 
 QPushButton:pressed {
   border: 1px solid #434346;
 }
 
 QPushButton:checked, QToolButton:checked {
   border: 1px solid #007acc;
 }
 
 QToolButton {
   padding: 2px;
 }
 
 QToolBar QToolButton {
   padding: 4px;
 }
 
 QToolButton#qt_toolbar_ext_button {
   background-color: transparent;
   border: none;
   min-width: 12px;
   max-width: 12px;
   padding: 0;
   qproperty-icon: url(:/org.blueberry.ui.qt/dark/tight-right-arrow-textcolor.svg);
 }
 
 QToolBox::tab {
   border: 1px solid #3f3f46;
 }
 
 QToolBox::tab:hover {
   background-color: #434346;
 }
 
 QToolBox::tab:selected {
   background-color: #1c97ea;
   border: 1px solid #1c97ea;
 }
 
 QAbstractItemView {
   alternate-background-color: #1b1b1c;
   background-color: #252526;
 }
 
 QAbstractItemView::item {
   color: #f1f1f1;
 }
 
 QAbstractItemView::item:selected {
   background-color: #1c97ea;
 }
 
 QHeaderView::section {
   background-color: #2d2d30;
   border: 1px solid transparent;
 }
 
 QHeaderView::section:horizontal {
   border-right: 1px solid #3f3f46;
 }
 
 QHeaderView::section:vertical {
   border-bottom: 1px solid #3f3f46;
 }
 
 QHeaderView::section:vertical:checked {
   background-color: #1c97ea;
 }
 
 QHeaderView::section:vertical:pressed {
   background-color: #1c97ea;
   font-weight: bold;
 }
 
 QHeaderView::down-arrow {
   image: url(:/org.blueberry.ui.qt/dark/down-arrow.svg);
   height: 16px;
   width: 16px;
 }
 
 QHeaderView::down-arrow:hover {
   image: url(:/org.blueberry.ui.qt/dark/down-arrow-hover.svg);
 }
 
 QHeaderView::down-arrow:pressed {
   image: url(:/org.blueberry.ui.qt/dark/down-arrow-pressed.svg);
 }
 
 QHeaderView::up-arrow {
   image: url(:/org.blueberry.ui.qt/dark/up-arrow.svg);
   height: 16px;
   width: 16px;
 }
 
 QHeaderView::up-arrow:hover {
   image: url(:/org.blueberry.ui.qt/dark/up-arrow-hover.svg);
 }
 
 QHeaderView::up-arrow:pressed {
   image: url(:/org.blueberry.ui.qt/dark/up-arrow-pressed.svg);
 }
 
 QGroupBox {
   border: 1px solid #434346;
   margin-top: 8px;
   padding-top: 8px;
 }
 
 QGroupBox, QGroupBox:disabled {
   background-color: #252526;
 }
 
 QGroupBox::title {
   padding: 0 4px;
   subcontrol-origin: margin;
   subcontrol-position: top center;
 }
 
 QComboBox, QLineEdit, QAbstractSpinBox {
   background-color: #333337;
   border: 1px solid #434346;
 }
 
 QComboBox QAbstractItemView {
   border: 1px solid #333337;
   selection-background-color: #3f3f46;
 }
 
 QComboBox::drop-down {
   image: url(:/org.blueberry.ui.qt/dark/down-arrow.svg);
   subcontrol-origin: margin;
   subcontrol-position: right;
   width: 12px;
 }
 
 QComboBox::drop-down:hover {
   background-color: #1f1f20;
   border-left: 1px solid #007acc;
   image: url(:/org.blueberry.ui.qt/dark/down-arrow-pressed.svg);
 }
 
 QAbstractSpinBox::up-button, QAbstractSpinBox::down-button {
   background-color: transparent;
   border: none;
   height: 9px;
 }
 
 QAbstractSpinBox::up-button:hover, QAbstractSpinBox::down-button:hover {
   background-color: #1f1f20;
 }
 
 QAbstractSpinBox::up-arrow {
   image: url(:/org.blueberry.ui.qt/dark/tight-up-arrow.svg);
 }
 
 QAbstractSpinBox::up-arrow:disabled, QAbstractSpinBox::up-arrow:off {
   image: url(:/org.blueberry.ui.qt/dark/tight-up-arrow-disabled.svg);
 }
 
 QAbstractSpinBox::up-arrow:hover {
   image: url(:/org.blueberry.ui.qt/dark/tight-up-arrow-hover.svg);
 }
 
 QAbstractSpinBox::up-arrow:pressed {
   image: url(:/org.blueberry.ui.qt/dark/tight-up-arrow-pressed.svg);
 }
 
 QAbstractSpinBox::down-arrow {
   image: url(:/org.blueberry.ui.qt/dark/tight-down-arrow.svg);
 }
 
 QAbstractSpinBox::down-arrow:disabled, QAbstractSpinBox::down-arrow:off {
   image: url(:/org.blueberry.ui.qt/dark/tight-down-arrow-disabled.svg);
 }
 
 QAbstractSpinBox::down-arrow:hover {
   image: url(:/org.blueberry.ui.qt/dark/tight-down-arrow-hover.svg);
 }
 
 QAbstractSpinBox::down-arrow:pressed {
   image: url(:/org.blueberry.ui.qt/dark/tight-down-arrow-pressed.svg);
 }
 
 QCheckBox, QCheckBox:hover, QCheckBox:disabled, QCheckBox:checked, QRadioButton, QRadioButton:hover, QRadioButton:disabled, QRadioButton:checked {
   background-color: none;
 }
 
 QCheckBox::indicator, QRadioButton::indicator {
   height: 13px;
   width: 13px;
 }
 
 QCheckBox::indicator:unchecked {
   image: url(:/org.blueberry.ui.qt/dark/checkbox-unchecked.svg);
 }
 
 QCheckBox::indicator:unchecked:hover {
   image: url(:/org.blueberry.ui.qt/dark/checkbox-unchecked-hover.svg);
 }
 
 QCheckBox::indicator:unchecked:disabled {
   image: url(:/org.blueberry.ui.qt/dark/checkbox-unchecked-disabled.svg);
 }
 
 QCheckBox::indicator:checked {
   image: url(:/org.blueberry.ui.qt/dark/checkbox-checked.svg);
 }
 
 QCheckBox::indicator:checked:hover {
   image: url(:/org.blueberry.ui.qt/dark/checkbox-checked-hover.svg);
 }
 
 QCheckBox::indicator:checked:disabled {
   image: url(:/org.blueberry.ui.qt/dark/checkbox-checked-disabled.svg);
 }
 
 QRadioButton::indicator:unchecked {
   image: url(:/org.blueberry.ui.qt/dark/radiobutton-unchecked.svg);
 }
 
 QRadioButton::indicator:unchecked:hover {
   image: url(:/org.blueberry.ui.qt/dark/radiobutton-unchecked-hover.svg);
 }
 
 QRadioButton::indicator:unchecked:disabled {
   image: url(:/org.blueberry.ui.qt/dark/radiobutton-unchecked-disabled.svg);
 }
 
 QRadioButton::indicator:checked {
   image: url(:/org.blueberry.ui.qt/dark/radiobutton-checked.svg);
 }
 
 QRadioButton::indicator:checked:hover {
   image: url(:/org.blueberry.ui.qt/dark/radiobutton-checked-hover.svg);
 }
 
 QRadioButton::indicator:checked:disabled {
   image: url(:/org.blueberry.ui.qt/dark/radiobutton-checked-disabled.svg);
 }
 
 QSlider::groove {
   background-color: #686868;
 }
 
 QSlider::groove:hover {
   background-color: #9e9e9e;
 }
 
 QSlider::groove:horizontal {
   height: 3px;
 }
 
 QSlider::groove:vertical {
   width: 3px;
 }
 
 QSlider::handle {
   background-color: #686868;
 }
 
 QSlider::handle:hover {
   background-color: #1c97ea;
 }
 
 QSlider::handle:pressed {
   background-color: #007acc;
 }
 
 QSlider::handle:horizontal {
   margin: -8px 0;
   width: 8px;
 }
 
 QSlider::handle::vertical {
   margin: 0 -8px;
   height: 8px;
 }
 
 QLineEdit:hover {
   border: 1px solid #2b7de1;
 }
 
 QLabel, QLabel:disabled {
   background-color: none;
 }
 
 QMenu {
   border: 1px solid #3e3e40;
 }
 
 QMenu QWidget {
   background-color: #1b1b1c;
 }
 
 QMenu::item {
   background-color: #1b1b1c;
 }
 
 QMenu::item:selected {
   background-color: #333334;
 }
 
 QMenu::separator {
   height: 1px;
   background-color: #3e3e40;
 }
 
 QMenuBar::item:selected {
   background-color: #3e3e40;
 }
 
 QScrollBar {
   background-color: #3e3e42;
 }
 
 QScrollBar:horizontal {
   height: 18px;
   margin: 0 18px 0 18px;
 }
 
 QScrollBar:vertical {
   width: 18px;
   margin: 18px 0 18px 0;
 }
 
 QScrollBar::handle {
   background-color: #686868;
 }
 
 QScrollBar::handle:hover {
   background-color: #9e9e9e;
 }
 
 QScrollBar::handle:pressed {
   background-color: #efebef;
 }
 
 QScrollBar::handle:horizontal {
   min-width: 18px;
   margin: 4px 0 5px 0;
 }
 
 QScrollBar::handle:vertical {
   min-height: 18px;
   margin: 0 5px 0 4px;
 }
 
 QScrollBar::add-page, QScrollBar::sub-page {
   background-color: none;
 }
 
 QScrollBar::add-line, QScrollBar::sub-line {
   background-color: #3e3e42;
   subcontrol-origin: margin;
 }
 
 QScrollBar::add-line:horizontal {
   subcontrol-position: right;
   width: 18px;
 }
 
 QScrollBar::sub-line:horizontal {
   subcontrol-position: left;
   width: 18px;
 }
 
 QScrollBar::add-line:vertical {
   subcontrol-position: bottom;
   height: 18px;
 }
 
 QScrollBar::sub-line:vertical {
   subcontrol-position: top;
   height: 18px;
 }
 
 QScrollBar::up-arrow, QScrollBar::right-arrow, QScrollBar:down-arrow, QScrollBar:left-arrow {
   width: 18px;
   height: 18px;
 }
 
 QScrollBar::down-arrow {
   image: url(:/org.blueberry.ui.qt/dark/down-arrow.svg);
 }
 
 QScrollBar::down-arrow:disabled {
   image: url(:/org.blueberry.ui.qt/dark/down-arrow-disabled.svg);
 }
 
 QScrollBar::down-arrow:hover {
   image: url(:/org.blueberry.ui.qt/dark/down-arrow-hover.svg);
 }
 
 QScrollBar::down-arrow:pressed {
   image: url(:/org.blueberry.ui.qt/dark/down-arrow-pressed.svg);
 }
 
 QScrollBar::left-arrow {
   image: url(:/org.blueberry.ui.qt/dark/left-arrow.svg);
 }
 
 QScrollBar::left-arrow:disabled {
   image: url(:/org.blueberry.ui.qt/dark/left-arrow-disabled.svg);
 }
 
 QScrollBar::left-arrow:hover {
   image: url(:/org.blueberry.ui.qt/dark/left-arrow-hover.svg);
 }
 
 QScrollBar::left-arrow:pressed {
   image: url(:/org.blueberry.ui.qt/dark/left-arrow-pressed.svg);
 }
 
 QScrollBar::right-arrow {
   image: url(:/org.blueberry.ui.qt/dark/right-arrow.svg);
 }
 
 QScrollBar::right-arrow:disabled {
   image: url(:/org.blueberry.ui.qt/dark/right-arrow-disabled.svg);
 }
 
 QScrollBar::right-arrow:hover {
   image: url(:/org.blueberry.ui.qt/dark/right-arrow-hover.svg);
 }
 
 QScrollBar::right-arrow:pressed {
   image: url(:/org.blueberry.ui.qt/dark/right-arrow-pressed.svg);
 }
 
 QScrollBar::up-arrow {
   image: url(:/org.blueberry.ui.qt/dark/up-arrow.svg);
 }
 
 QScrollBar::up-arrow:disabled {
   image: url(:/org.blueberry.ui.qt/dark/up-arrow-disabled.svg);
 }
 
 QScrollBar::up-arrow:hover {
   image: url(:/org.blueberry.ui.qt/dark/up-arrow-hover.svg);
 }
 
 QScrollBar::up-arrow:pressed {
   image: url(:/org.blueberry.ui.qt/dark/up-arrow-pressed.svg);
 }
 
 QTabWidget::pane {
   border: 1px solid #434346;
 }
 
 QTabBar::tab {
   background-color: #434346;
   border: 1px solid #434346;
   border-bottom: none;
   padding: 4px;
 }
 
 QTabBar::tab:middle {
   border-left: none;
 }
 
 QTabBar::tab:last {
   border-left: none;
 }
 
 QTabBar::tab:next-selected {
   border-right: none;
 }
 
 QTabBar::tab:selected {
   border: 1px solid #434346;
   border-bottom: none;
 }
 
 QTabBar::tab:!selected {
   background-color: #2d2d30;
 }
 
 QTabBar::tab:!selected:hover {
   background-color: #434346;
 }
 
 #TabCloseButton {
   background-color: none;
 }
 
 QTabBar QToolButton::left-arrow {
   image: url(:/org.blueberry.ui.qt/dark/tight-left-arrow.svg);
 }
 
 QTabBar QToolButton::left-arrow:hover {
   image: url(:/org.blueberry.ui.qt/dark/tight-left-arrow-hover.svg);
 }
 
 QTabBar QToolButton::left-arrow:pressed {
   image: url(:/org.blueberry.ui.qt/dark/tight-left-arrow-pressed.svg);
 }
 
 QTabBar QToolButton::left-arrow:disabled {
   image: url(:/org.blueberry.ui.qt/dark/tight-left-arrow-disabled.svg);
 }
 
 QTabBar QToolButton::right-arrow {
   image: url(:/org.blueberry.ui.qt/dark/tight-right-arrow.svg);
 }
 
 QTabBar QToolButton::right-arrow:hover {
   image: url(:/org.blueberry.ui.qt/dark/tight-right-arrow-hover.svg);
 }
 
 QTabBar QToolButton::right-arrow:pressed {
   image: url(:/org.blueberry.ui.qt/dark/tight-right-arrow-pressed.svg);
 }
 
 QTabBar QToolButton::right-arrow:disabled {
   image: url(:/org.blueberry.ui.qt/dark/tight-right-arrow-disabled.svg);
 }
 
 QTreeView::branch:closed:has-children:has-siblings,
 QTreeView::branch:closed:has-children:!has-siblings {
   image: url(:/org.blueberry.ui.qt/dark/right-arrow.svg);
 }
 
 QTreeView::branch:closed:has-children:has-siblings:hover,
 QTreeView::branch:closed:has-children:!has-siblings:hover {
   image: url(:/org.blueberry.ui.qt/dark/right-arrow-hover.svg);
 }
 
 QTreeView::branch:open:has-children:has-siblings,
 QTreeView::branch:open:has-children:!has-siblings {
   image: url(:/org.blueberry.ui.qt/dark/down-arrow.svg);
 }
 
 QTreeView::branch:open:has-children:has-siblings:hover,
 QTreeView::branch:open:has-children:!has-siblings:hover {
   image: url(:/org.blueberry.ui.qt/dark/down-arrow-hover.svg);
 }
 
 QTreeView::indicator:unchecked {
   image: url(:/org.blueberry.ui.qt/dark/checkbox-unchecked.svg);
 }
 
 QTreeView::indicator:unchecked:selected {
   image: url(:/org.blueberry.ui.qt/dark/checkbox-unchecked-selected.svg);
 }
 
 QTreeView::indicator:checked, QTreeView::indicator:indeterminate {
   image: url(:/org.blueberry.ui.qt/dark/checkbox-checked.svg);
 }
 
 QTreeView::indicator:checked:selected, QTreeView::indicator:indeterminate:selected {
   image: url(:/org.blueberry.ui.qt/dark/checkbox-checked-selected.svg);
 }
diff --git a/Plugins/org.blueberry.ui.qt/resources/lightstyle.qss b/Plugins/org.blueberry.ui.qt/resources/lightstyle.qss
index 3b42dbabf6..a188570487 100644
--- a/Plugins/org.blueberry.ui.qt/resources/lightstyle.qss
+++ b/Plugins/org.blueberry.ui.qt/resources/lightstyle.qss
@@ -1,89 +1,93 @@
 /*
   iconColor       = #000000 <- This line is parsed by MITK
   iconAccentColor = #2067bd <- This line is parsed by MITK
 */
 
 font.warning {
   color: red;
   font-weight: bold;
 }
 
 font.normal {
   color: #000000;
 }
 
 font.highlight {
   color: #2067bd;
 }
 
+font.disabled {
+  color: #808080;
+}
+
 berry--QCTabBar::tab {
     background: palette(window);
     min-height: 24px;
     border-top: 1px solid palette(mid);
     border-left: 1px solid palette(mid);
     border-bottom: 1px solid palette(mid);
     margin-top: -1px;
     padding-left: 5px
 }
 
 berry--QCTabBar::tab:only-one {
     border-top-left-radius: 8px;
     border-top-right-radius: 8px;
     min-height: 25px;
     margin-left: -1px
 }
 
 berry--QCTabBar::tab:first {
     margin-left: -1px;
     border-left: 0px;
     border-top-left-radius: 8px;
 }
 
 berry--QCTabBar::tab:last {
     border-right: 1px solid palette(mid);
     border-top-right-radius: 8px
 }
 
 berry--QCTabBar::tab:previous-selected {
     border-left: 0px
 }
 
 berry--QCTabBar::tab:selected {
     border-right: 1px solid palette(Mid);
     border-bottom: 0px;
     border-top-left-radius: 8px;
     border-top-right-radius: 8px;
 }
 
 berry--QCTabBar QToolButton {
     border: 1px solid palette(window);
     max-height: 22px;
     background: palette(window);
 }
 
 berry--QCTabBar QToolButton#TabCloseButton
 {
     border: none;
     background: none;
 }
 
 QWidget#TabTopRightControls {
     border: 1px solid palette(mid);
     border-left: 0px;
     border-top: 0px;
     border-right: 0px;
 }
 
 QWidget#ViewForm {
     border: 1px solid palette(mid);
     border-top-left-radius: 8px;
     border-top-right-radius: 8px;
 }
 
 QWidget#StandaloneViewForm {
     border: 1px solid palette(mid);
 }
 
 QWidget#PageCompositeControlWidget {
     margin: 3px;
 }
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
index dd748cdc15..87daa45a43 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
@@ -1,161 +1,161 @@
 /*============================================================================
 
 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("<font class=\"warning\">Error. Select data.</font>"),
-m_EmptyInfo("<font class=\"normal\">Empty. Make a selection.</font>"), m_PopUpTitel("Select a data node"), m_PopUpHint(""),
+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 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 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 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 = QString("<font class=\"warning\">")+info+QString("</font>");
+  m_InvalidInfo = info;
   this->UpdateInfo();
 }
 
 void QmitkAbstractNodeSelectionWidget::SetEmptyInfo(QString info)
 {
-  m_EmptyInfo = QString("<font class=\"normal\">")+info+QString("</font>");
+  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);
 }
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp
index 4a5f731d08..3e556d7f77 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp
@@ -1,250 +1,272 @@
 /*============================================================================
 
 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 "QmitkMultiNodeSelectionWidget.h"
 
 #include <algorithm>
 
 #include "QmitkNodeSelectionDialog.h"
 #include "QmitkCustomVariants.h"
 #include "internal/QmitkNodeSelectionListItemWidget.h"
 
 QmitkMultiNodeSelectionWidget::QmitkMultiNodeSelectionWidget(QWidget* parent) : QmitkAbstractNodeSelectionWidget(parent)
 {
   m_Controls.setupUi(this);
   m_Overlay = new QmitkSimpleTextOverlayWidget(m_Controls.list);
   m_Overlay->setVisible(false);
   m_CheckFunction = [](const NodeList &) { return ""; };
 
   this->UpdateList();
   this->UpdateInfo();
 
   connect(m_Controls.btnChange, SIGNAL(clicked(bool)), this, SLOT(OnEditSelection()));
 }
 
 QmitkMultiNodeSelectionWidget::NodeList QmitkMultiNodeSelectionWidget::CompileEmitSelection() const
 {
   NodeList result;
 
   for (int i = 0; i < m_Controls.list->count(); ++i)
   {
     QListWidgetItem* item = m_Controls.list->item(i);
 
     auto node = item->data(Qt::UserRole).value<mitk::DataNode::Pointer>();
     result.append(node);
   }
 
 
   if (!m_SelectOnlyVisibleNodes)
   {
     for (auto node : m_CurrentSelection)
     {
       if (!result.contains(node))
       {
         result.append(node);
       }
     }
   }
 
   return result;
 }
 
 void QmitkMultiNodeSelectionWidget::OnNodePredicateChanged(const mitk::NodePredicateBase* /*newPredicate*/)
 {
   this->UpdateInfo();
   this->UpdateList();
 };
 
 void QmitkMultiNodeSelectionWidget::OnDataStorageChanged()
 {
   this->UpdateInfo();
   this->UpdateList();
 };
 
 QmitkMultiNodeSelectionWidget::NodeList QmitkMultiNodeSelectionWidget::GetSelectedNodes() const
 {
   return m_CurrentSelection;
 };
 
 void QmitkMultiNodeSelectionWidget::SetSelectionCheckFunction(const SelectionCheckFunctionType &checkFunction)
 {
   m_CheckFunction = checkFunction;
 
   auto newEmission = this->CompileEmitSelection();
   auto newCheckResponse = m_CheckFunction(newEmission);
 
   if (newCheckResponse.empty() && !m_CheckResponse.empty())
   {
     emit CurrentSelectionChanged(newEmission);
   }
   m_CheckResponse = newCheckResponse;
   this->UpdateInfo();
 };
 
 void QmitkMultiNodeSelectionWidget::OnEditSelection()
 {
   QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(this, m_PopUpTitel, m_PopUpHint);
 
   dialog->SetDataStorage(m_DataStorage.Lock());
   dialog->SetNodePredicate(m_NodePredicate);
   dialog->SetCurrentSelection(this->CompileEmitSelection());
   dialog->SetSelectOnlyVisibleNodes(m_SelectOnlyVisibleNodes);
   dialog->SetSelectionMode(QAbstractItemView::MultiSelection);
 
   m_Controls.btnChange->setChecked(true);
   if (dialog->exec())
   {
     auto lastEmission = this->CompileEmitSelection();
 
     m_CurrentSelection = dialog->GetSelectedNodes();
     this->UpdateList();
 
     auto newEmission = this->CompileEmitSelection();
 
     m_CheckResponse = m_CheckFunction(newEmission);
     this->UpdateInfo();
 
     if (!EqualNodeSelections(lastEmission, newEmission))
     {
       if (m_CheckResponse.empty())
       {
         emit CurrentSelectionChanged(newEmission);
       }
     }
   }
   m_Controls.btnChange->setChecked(false);
 
   delete dialog;
 };
 
 void QmitkMultiNodeSelectionWidget::UpdateInfo()
 {
   if (!m_Controls.list->count())
   {
     if (m_IsOptional)
     {
-      m_Overlay->SetOverlayText(m_EmptyInfo);
+      if (this->isEnabled())
+      {
+        m_Overlay->SetOverlayText(QString("<font class=\"normal\">") + m_EmptyInfo + QString("</font>"));
+      }
+      else
+      {
+        m_Overlay->SetOverlayText(QString("<font class=\"disabled\">") + m_EmptyInfo + QString("</font>"));
+      }
     }
     else
     {
-      m_Overlay->SetOverlayText(m_InvalidInfo);
+      if (this->isEnabled())
+      {
+        m_Overlay->SetOverlayText(QString("<font class=\"warning\">") + m_InvalidInfo + QString("</font>"));
+      }
+      else
+      {
+        m_Overlay->SetOverlayText(QString("<font class=\"disabled\">") + m_InvalidInfo + QString("</font>"));
+      }
     }
   }
   else
   {
     if (!m_CheckResponse.empty())
     {
       m_Overlay->SetOverlayText(QString::fromStdString(m_CheckResponse));
     }
   }
 
   m_Overlay->setVisible(m_Controls.list->count() == 0 || !m_CheckResponse.empty());
 
   for (auto i = 0; i < m_Controls.list->count(); ++i)
   {
     auto item = m_Controls.list->item(i);
     auto widget = qobject_cast<QmitkNodeSelectionListItemWidget*>(m_Controls.list->itemWidget(item));
     widget->SetClearAllowed(m_IsOptional || m_CurrentSelection.size() > 1);
   }
 };
 
 void QmitkMultiNodeSelectionWidget::UpdateList()
 {
   m_Controls.list->clear();
 
   for (auto node : m_CurrentSelection)
   {
     if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node))
     {
       QListWidgetItem *newItem = new QListWidgetItem;
 
       newItem->setSizeHint(QSize(0, 40));
       QmitkNodeSelectionListItemWidget* widget = new QmitkNodeSelectionListItemWidget;
 
       widget->SetSelectedNode(node);
       widget->SetClearAllowed(m_IsOptional || m_CurrentSelection.size() > 1);
 
       connect(widget, &QmitkNodeSelectionListItemWidget::ClearSelection, this, &QmitkMultiNodeSelectionWidget::OnClearSelection);
       newItem->setData(Qt::UserRole, QVariant::fromValue<mitk::DataNode::Pointer>(node));
 
       m_Controls.list->addItem(newItem);
       m_Controls.list->setItemWidget(newItem, widget);
     }
   }
 };
 
 void QmitkMultiNodeSelectionWidget::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
 {
   auto lastEmission = this->CompileEmitSelection();
 
   m_SelectOnlyVisibleNodes = selectOnlyVisibleNodes;
 
   auto newEmission = this->CompileEmitSelection();
 
   if (!EqualNodeSelections(lastEmission, newEmission))
   {
     m_CheckResponse = m_CheckFunction(newEmission);
     if (m_CheckResponse.empty())
     {
       emit CurrentSelectionChanged(newEmission);
     }
     this->UpdateList();
     this->UpdateInfo();
   }
 };
 
 void QmitkMultiNodeSelectionWidget::SetCurrentSelection(NodeList selectedNodes)
 {
   auto lastEmission = this->CompileEmitSelection();
 
   m_CurrentSelection = selectedNodes;
   this->UpdateList();
 
   auto newEmission = this->CompileEmitSelection();
 
   if (!EqualNodeSelections(lastEmission, newEmission))
   {
     m_CheckResponse = m_CheckFunction(newEmission);
     if (m_CheckResponse.empty())
     {
       emit CurrentSelectionChanged(newEmission);
     }
     this->UpdateInfo();
   }
 };
 
 void QmitkMultiNodeSelectionWidget::OnClearSelection(const mitk::DataNode* node)
 {
   auto finding = std::find(std::begin(m_CurrentSelection), std::end(m_CurrentSelection), node);
   m_CurrentSelection.erase(finding);
 
   this->UpdateList();
   auto newEmission = this->CompileEmitSelection();
   m_CheckResponse = m_CheckFunction(newEmission);
 
   if (m_CheckResponse.empty())
   {
     emit CurrentSelectionChanged(newEmission);
   }
   this->UpdateInfo();
 };
 
 void QmitkMultiNodeSelectionWidget::NodeRemovedFromStorage(const mitk::DataNode* node)
 {
   auto finding = std::find(std::begin(m_CurrentSelection), std::end(m_CurrentSelection), node);
 
   if (finding != std::end(m_CurrentSelection))
   {
     this->OnClearSelection(node);
   }
 }
+
+void QmitkMultiNodeSelectionWidget::changeEvent(QEvent *event)
+{
+  if (event->type() == QEvent::EnabledChange)
+  {
+    this->UpdateInfo();
+  }
+}
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.h b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.h
index bf759eb2c7..f4e411234a 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.h
@@ -1,85 +1,87 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 
 #ifndef QMITK_MULTI_NODE_SELECTION_WIDGET_H
 #define QMITK_MULTI_NODE_SELECTION_WIDGET_H
 
 #include <mitkDataStorage.h>
 #include <mitkWeakPointer.h>
 #include <mitkNodePredicateBase.h>
 
 #include "QmitkSimpleTextOverlayWidget.h"
 
 #include "org_mitk_gui_qt_common_Export.h"
 
 #include "ui_QmitkMultiNodeSelectionWidget.h"
 
 #include <QmitkAbstractNodeSelectionWidget.h>
 
 class QmitkAbstractDataStorageModel;
 class QAbstractItemVew;
 
 /**
 * \class QmitkMultiNodeSelectionWidget
 * \brief Widget that allows to perform and represents a multiple node selection.
 */
 class MITK_QT_COMMON QmitkMultiNodeSelectionWidget : public QmitkAbstractNodeSelectionWidget
 {
   Q_OBJECT
 
 public:
   explicit QmitkMultiNodeSelectionWidget(QWidget* parent = nullptr);
 
   using NodeList = QmitkAbstractNodeSelectionWidget::NodeList;
 
   NodeList GetSelectedNodes() const;
 
   /**Helper function that is used to check the given selection for consistency.
    Returning an empty string assumes that everything is alright and the selection
    is valid. If the string is not empty, the content of the string will be used
    as error message in the overlay to indicate the problem.*/
   using SelectionCheckFunctionType = std::function<std::string(const NodeList &)>;
   /**A selection check function can be set. If set the widget uses this function to
    check the made/set selection. If the selection is valid, everything is fine.
    If selection is indicated as invalid, it will not be communicated by the widget
    (no signal emission.*/
   void SetSelectionCheckFunction(const SelectionCheckFunctionType &checkFunction);
 
 public Q_SLOTS:
   void SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes) override;
   void SetCurrentSelection(NodeList selectedNodes) override;
   void OnEditSelection();
 
 protected Q_SLOTS:
   void OnClearSelection(const mitk::DataNode* node);
 
 protected:
   NodeList CompileEmitSelection() const;
 
+  void changeEvent(QEvent *event) override;
+
   void UpdateInfo() override;
   virtual void UpdateList();
 
   void OnNodePredicateChanged(const mitk::NodePredicateBase* newPredicate) override;
   void OnDataStorageChanged() override;
   void NodeRemovedFromStorage(const mitk::DataNode* node) override;
 
   NodeList m_CurrentSelection;
 
   QmitkSimpleTextOverlayWidget* m_Overlay;
 
   SelectionCheckFunctionType m_CheckFunction;
   std::string m_CheckResponse;
 
   Ui_QmitkMultiNodeSelectionWidget m_Controls;
 };
 #endif // QmitkMultiNodeSelectionWidget_H
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
index 9c9c9d88e9..9f927b0d47 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
@@ -1,177 +1,218 @@
 /*============================================================================
 
 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 "QmitkNodeSelectionButton.h"
 
 // berry includes
 #include <berryWorkbenchPlugin.h>
 #include <berryQtStyleManager.h>
 
 #include "QPainter"
 #include "QTextDocument"
+#include "QEvent"
 
 #include <mitkDataNode.h>
 #include <QmitkNodeDescriptorManager.h>
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDataNode.h>
 #include <mitkExtractSliceFilter.h>
 #include <vtkMitkLevelWindowFilter.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPropertyNameHelper.h>
 
 // vtk
 #include <vtkLookupTable.h>
 
 QPixmap GetPixmapFromImageNode(const mitk::DataNode* dataNode, int height)
 {
   if (nullptr == dataNode)
   {
     return QPixmap();
   }
 
   const mitk::Image* image = dynamic_cast<const mitk::Image*>(dataNode->GetData());
   if ((nullptr == image || !image->IsInitialized()) || // -> must be an image
     (image->GetPixelType().GetNumberOfComponents() != 1)) // -> for now only single component are allowed
   {
     auto descManager = QmitkNodeDescriptorManager::GetInstance();
     auto desc = descManager->GetDescriptor(dataNode);
     auto icon = desc->GetIcon(dataNode);
     auto fallBackMap = icon.pixmap(height, height);
     return fallBackMap;
   }
 
   mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
   int sliceNumber = image->GetDimension(2) / 2;
   planeGeometry->InitializeStandardPlane(image->GetGeometry(), mitk::PlaneGeometry::Axial, sliceNumber);
 
   mitk::ExtractSliceFilter::Pointer extractSliceFilter = mitk::ExtractSliceFilter::New();
   extractSliceFilter->SetInput(image);
   extractSliceFilter->SetInterpolationMode(mitk::ExtractSliceFilter::RESLICE_CUBIC);
   extractSliceFilter->SetResliceTransformByGeometry(image->GetGeometry());
   extractSliceFilter->SetWorldGeometry(planeGeometry);
   extractSliceFilter->SetOutputDimensionality(2);
   extractSliceFilter->SetVtkOutputRequest(true);
   extractSliceFilter->Update();
 
   vtkImageData* imageData = extractSliceFilter->GetVtkOutput();
 
   mitk::LevelWindow levelWindow;
   dataNode->GetLevelWindow(levelWindow);
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetRange(levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound());
   lookupTable->SetSaturationRange(0.0, 0.0);
   lookupTable->SetValueRange(0.0, 1.0);
   lookupTable->SetHueRange(0.0, 0.0);
   lookupTable->SetRampToLinear();
 
   vtkSmartPointer<vtkMitkLevelWindowFilter> levelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
   levelWindowFilter->SetLookupTable(lookupTable);
   levelWindowFilter->SetInputData(imageData);
   levelWindowFilter->SetMinOpacity(0.0);
   levelWindowFilter->SetMaxOpacity(1.0);
   int dims[3];
   imageData->GetDimensions(dims);
   double clippingBounds[] = { 0.0, static_cast<double>(dims[0]), 0.0, static_cast<double>(dims[1]) };
   levelWindowFilter->SetClippingBounds(clippingBounds);
   levelWindowFilter->Update();
   imageData = levelWindowFilter->GetOutput();
 
   QImage thumbnailImage(reinterpret_cast<const unsigned char*>(imageData->GetScalarPointer()), dims[0], dims[1], QImage::Format_ARGB32);
 
   thumbnailImage = thumbnailImage.scaledToHeight(height,Qt::SmoothTransformation).rgbSwapped();
   return QPixmap::fromImage(thumbnailImage);
 }
 
 QmitkNodeSelectionButton::QmitkNodeSelectionButton(QWidget *parent)
-  : QPushButton(parent), m_OutDatedThumpNail(true)
+  : QPushButton(parent), m_OutDatedThumpNail(true), m_IsOptional(true)
 { }
 
 QmitkNodeSelectionButton::~QmitkNodeSelectionButton()
 {
   this->m_SelectedNode = nullptr;
 }
 
 const mitk::DataNode* QmitkNodeSelectionButton::GetSelectedNode() const
 {
   return m_SelectedNode;
 }
 
 void QmitkNodeSelectionButton::SetSelectedNode(const mitk::DataNode* node)
 {
   if (m_SelectedNode != node)
   {
     this->m_SelectedNode = node;
     this->m_OutDatedThumpNail = true;
   }
 
   this->update();
 }
 
 void QmitkNodeSelectionButton::SetNodeInfo(QString info)
 {
   this->m_Info = info;
   this->update();
 }
 
 void QmitkNodeSelectionButton::paintEvent(QPaintEvent *p)
 {
   QString stylesheet;
 
   ctkPluginContext* context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
   if (styleManagerRef)
   {
     auto styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
     stylesheet = styleManager->GetStylesheet();
   }
 
   QPushButton::paintEvent(p);
 
   QPainter painter(this);
   QTextDocument td(this);
   td.setDefaultStyleSheet(stylesheet);
 
   auto widgetSize = this->size();
   QPoint origin = QPoint(5, 5);
 
   if (this->m_SelectedNode)
   {
     auto iconLength = widgetSize.height() - 10;
     auto node = this->m_SelectedNode;
 
     if (this->m_OutDatedThumpNail)
     {
       this->m_ThumpNail = GetPixmapFromImageNode(node, iconLength);
       this->m_OutDatedThumpNail = false;
     }
 
     painter.drawPixmap(origin, m_ThumpNail);
     origin.setX(origin.x() + iconLength + 5);
 
-    td.setHtml(QString::fromStdString("<font class=\"normal\">"+node->GetName()+"</font>"));
+    if (this->isEnabled())
+    {
+      td.setHtml(QString::fromStdString("<font class=\"normal\">" + node->GetName() + "</font>"));
+    }
+    else
+    {
+      td.setHtml(QString::fromStdString("<font class=\"disabled\">" + node->GetName() + "</font>"));
+    }
   }
   else
   {
-    td.setHtml(m_Info);
+    if (this->isEnabled())
+    {
+      if (this->m_IsOptional)
+      {
+        td.setHtml(QString("<font class=\"normal\">") + m_Info + QString("</font>"));
+      }
+      else
+      {
+        td.setHtml(QString("<font class=\"warning\">") + m_Info + QString("</font>"));
+      }
+    }
+    else
+    {
+      td.setHtml(QString("<font class=\"disabled\">") + m_Info + QString("</font>"));
+    }
   }
 
   auto textSize = td.size();
 
   origin.setY( (widgetSize.height() - textSize.height()) / 2.);
 
   painter.translate(origin);
   td.drawContents(&painter);
 
 }
+
+void QmitkNodeSelectionButton::changeEvent(QEvent *event)
+{
+  if (event->type() == QEvent::EnabledChange)
+  {
+    this->repaint();
+  }
+}
+
+bool QmitkNodeSelectionButton::GetSelectionIsOptional() const
+{
+  return m_IsOptional;
+}
+
+void QmitkNodeSelectionButton::SetSelectionIsOptional(bool isOptional)
+{
+  m_IsOptional = isOptional;
+  this->repaint();
+}
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h
index 376877677d..98974a6b0c 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h
@@ -1,54 +1,63 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 
 #ifndef QMITK_NODE_SELECTION_BUTTON_H
 #define QMITK_NODE_SELECTION_BUTTON_H
 
 #include <mitkWeakPointer.h>
 #include <mitkDataNode.h>
 
 #include "org_mitk_gui_qt_common_Export.h"
 
 #include "QPushButton"
 #include "QPixmap"
 
 
 /** Button class that can be used to display informations about a passed node.
  * If the passed node is a null ptr the node info text will be shown.
  * In difference to the normal push button text property. The node info can
  * be formated text (e.g. HTML code; like the tooltip text).*/
 class MITK_QT_COMMON QmitkNodeSelectionButton : public QPushButton
 {
   Q_OBJECT
 
 public:
   explicit QmitkNodeSelectionButton(QWidget *parent = nullptr);
   ~QmitkNodeSelectionButton() override;
 
   const mitk::DataNode* GetSelectedNode() const;
+  bool GetSelectionIsOptional() const;
 
 public Q_SLOTS :
   virtual void SetSelectedNode(const mitk::DataNode* node);
   virtual void SetNodeInfo(QString info);
 
+  /** Set the widget into an optional mode. Optional means that the selection of no valid
+  node does not mean an invalid state. Thus no node is a valid "node" selection too.
+  The state influences if the info text is handled as an information (optional) or a
+  warning (optiona==false).*/
+  void SetSelectionIsOptional(bool isOptional);
+
 protected:
   void paintEvent(QPaintEvent *p) override;
+  void changeEvent(QEvent *event) override;
 
   mitk::DataNode::ConstPointer m_SelectedNode;
   QString m_Info;
   bool m_OutDatedThumpNail;
   QPixmap m_ThumpNail;
+  bool m_IsOptional;
 };
 
 
 #endif // QmitkSingleNodeSelectionWidget_H
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp
index eb02d1f901..2689d07b5f 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp
@@ -1,257 +1,258 @@
 /*============================================================================
 
 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_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;
 
   for (auto node : nodes)
   {
     bool valid = true;
     if (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*/)
 {
   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);
   }
 };
 
 void QmitkSingleNodeSelectionWidget::OnDataStorageChanged()
 {
 };
 
 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();
     }
 
     auto newEmission = this->CompileEmitSelection();
 
     if (!EqualNodeSelections(lastEmission, newEmission))
     {
       emit CurrentSelectionChanged(newEmission);
       this->UpdateInfo();
     }
   }
 
   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;
 
   auto newEmission = this->CompileEmitSelection();
 
   if (!EqualNodeSelections(lastEmission, newEmission))
   {
     emit CurrentSelectionChanged(newEmission);
     this->UpdateInfo();
   }
 };
 
 void QmitkSingleNodeSelectionWidget::SetCurrentSelection(NodeList selectedNodes)
 {
   auto lastEmission = this->CompileEmitSelection();
 
   m_ExternalSelection = selectedNodes;
   m_SelectedNode = this->ExtractCurrentValidSelection(selectedNodes);
 
   auto newEmission = this->CompileEmitSelection();
 
   if (!EqualNodeSelections(lastEmission, newEmission))
   {
     this->UpdateInfo();
     emit CurrentSelectionChanged(newEmission);
   }
 };
 
 void QmitkSingleNodeSelectionWidget::NodeRemovedFromStorage(const mitk::DataNode* node)
 {
   if (m_SelectedNode == node && node != nullptr)
   {
     m_SelectedNode = nullptr;
     auto newEmission = this->CompileEmitSelection();
 
     emit CurrentSelectionChanged(newEmission);
     this->UpdateInfo();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestControls.ui b/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestControls.ui
index 77f8edc873..f6e396042d 100644
--- a/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestControls.ui
+++ b/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestControls.ui
@@ -1,173 +1,193 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkDataStorageViewerTestControls</class>
  <widget class="QWidget" name="QmitkDataStorageViewerTestControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>945</width>
     <height>456</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>Data storage viewer test</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
-   <item row="1" column="0">
-    <widget class="QCheckBox" name="selectionProviderCheckBox">
-     <property name="text">
-      <string>Set as selection provider</string>
-     </property>
-    </widget>
-   </item>
-   <item row="0" column="1">
-    <widget class="QListView" name="selectionListView2"/>
-   </item>
-   <item row="1" column="1">
-    <widget class="QCheckBox" name="selectionProviderCheckBox2">
+   <item row="7" column="1">
+    <widget class="QCheckBox" name="checkOnlyImages_2">
      <property name="text">
-      <string>Set as selection provider</string>
+      <string>Allow only images
+(using NodePredicate feature and general invalid message)</string>
      </property>
     </widget>
    </item>
-   <item row="0" column="0">
-    <widget class="QListView" name="selectionListView"/>
-   </item>
-   <item row="7" column="0">
-    <widget class="QCheckBox" name="checkOnlyImages">
+   <item row="5" column="0">
+    <widget class="QCheckBox" name="selectionListenerCheckBox3">
      <property name="text">
-      <string>Allow only images </string>
+      <string>Set as selection listner</string>
      </property>
     </widget>
    </item>
-   <item row="9" column="0">
-    <widget class="QCheckBox" name="checkOptional">
+   <item row="2" column="0">
+    <widget class="QCheckBox" name="selectionListenerCheckBox">
      <property name="text">
-      <string>Is Optional</string>
+      <string>Set as selection listener</string>
      </property>
     </widget>
    </item>
-   <item row="4" column="1">
-    <widget class="QCheckBox" name="selectionProviderCheckBox4">
+   <item row="5" column="1">
+    <widget class="QCheckBox" name="selectionListenerCheckBox4">
      <property name="text">
-      <string>Set as selection provider</string>
+      <string>Set as selection listner</string>
      </property>
     </widget>
    </item>
    <item row="6" column="1">
     <widget class="QCheckBox" name="checkOnlyVisible_2">
      <property name="text">
       <string>Only valid nodes</string>
      </property>
     </widget>
    </item>
-   <item row="7" column="1">
-    <widget class="QCheckBox" name="checkOnlyImages_2">
+   <item row="4" column="0">
+    <widget class="QCheckBox" name="selectionProviderCheckBox3">
      <property name="text">
-      <string>Allow only images
-(using NodePredicate feature and general invalid message)</string>
+      <string>Set as selection provider</string>
      </property>
     </widget>
    </item>
-   <item row="2" column="0">
-    <widget class="QCheckBox" name="selectionListenerCheckBox">
+   <item row="0" column="0">
+    <widget class="QListView" name="selectionListView"/>
+   </item>
+   <item row="9" column="1">
+    <widget class="QCheckBox" name="checkOptional_2">
      <property name="text">
-      <string>Set as selection listener</string>
+      <string>Is Optional</string>
      </property>
     </widget>
    </item>
+   <item row="0" column="1">
+    <widget class="QListView" name="selectionListView2"/>
+   </item>
    <item row="2" column="1">
     <widget class="QCheckBox" name="selectionListenerCheckBox2">
      <property name="text">
       <string>Set as selection listener</string>
      </property>
     </widget>
    </item>
-   <item row="6" column="0">
-    <widget class="QCheckBox" name="checkOnlyVisible">
+   <item row="1" column="0">
+    <widget class="QCheckBox" name="selectionProviderCheckBox">
      <property name="text">
-      <string>Only valid nodes</string>
+      <string>Set as selection provider</string>
      </property>
     </widget>
    </item>
-   <item row="5" column="0">
-    <widget class="QCheckBox" name="selectionListenerCheckBox3">
+   <item row="6" column="0">
+    <widget class="QCheckBox" name="checkOnlyVisible">
      <property name="text">
-      <string>Set as selection listner</string>
+      <string>Only valid nodes</string>
      </property>
     </widget>
    </item>
-   <item row="5" column="1">
-    <widget class="QCheckBox" name="selectionListenerCheckBox4">
+   <item row="9" column="0">
+    <widget class="QCheckBox" name="checkOptional">
      <property name="text">
-      <string>Set as selection listner</string>
+      <string>Is Optional</string>
      </property>
     </widget>
    </item>
-   <item row="4" column="0">
-    <widget class="QCheckBox" name="selectionProviderCheckBox3">
+   <item row="4" column="1">
+    <widget class="QCheckBox" name="selectionProviderCheckBox4">
      <property name="text">
       <string>Set as selection provider</string>
      </property>
     </widget>
    </item>
-   <item row="9" column="1">
-    <widget class="QCheckBox" name="checkOptional_2">
+   <item row="7" column="0">
+    <widget class="QCheckBox" name="checkOnlyImages">
      <property name="text">
-      <string>Is Optional</string>
+      <string>Allow only images </string>
      </property>
     </widget>
    </item>
    <item row="3" column="0">
     <widget class="QmitkSingleNodeSelectionWidget" name="singleSlot" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>40</height>
       </size>
      </property>
     </widget>
    </item>
    <item row="3" column="1">
     <widget class="QmitkMultiNodeSelectionWidget" name="multiSlot" native="true"/>
    </item>
    <item row="8" column="1">
     <widget class="QCheckBox" name="checkOnlyUneven">
      <property name="text">
       <string>Allow only uneven selection count
 (using check funcktion feature)</string>
      </property>
     </widget>
    </item>
+   <item row="1" column="1">
+    <widget class="QCheckBox" name="selectionProviderCheckBox2">
+     <property name="text">
+      <string>Set as selection provider</string>
+     </property>
+    </widget>
+   </item>
+   <item row="10" column="0">
+    <widget class="QCheckBox" name="checkEnabled">
+     <property name="text">
+      <string>Is Enabled</string>
+     </property>
+     <property name="checked">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="10" column="1">
+    <widget class="QCheckBox" name="checkEnabled_2">
+     <property name="text">
+      <string>Is Enabled</string>
+     </property>
+     <property name="checked">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkSingleNodeSelectionWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkSingleNodeSelectionWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkMultiNodeSelectionWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkMultiNodeSelectionWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp b/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp
index 16c0783ef5..de255ca099 100644
--- a/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp
+++ b/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp
@@ -1,274 +1,276 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 // data storage viewer test plugin
 #include "QmitkDataStorageViewerTestView.h"
 
 #include "mitkNodePredicateDataType.h"
 
 // berry
 #include <berryIWorkbenchWindow.h>
 
 // qt
 #include <QHBoxLayout>
 
 const std::string QmitkDataStorageViewerTestView::VIEW_ID = "org.mitk.views.datastorageviewertest";
 
 void QmitkDataStorageViewerTestView::SetFocus()
 {
   // nothing here
 }
 
 void QmitkDataStorageViewerTestView::CreateQtPartControl(QWidget* parent)
 {
   // create GUI widgets
   m_Controls.setupUi(parent);
 
   m_DataStorageDefaultListModel = new QmitkDataStorageDefaultListModel(this);
   m_DataStorageDefaultListModel->SetDataStorage(GetDataStorage());
   m_Controls.selectionListView->setSelectionMode(QAbstractItemView::ExtendedSelection);
   m_Controls.selectionListView->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_Controls.selectionListView->setAlternatingRowColors(true);
   m_Controls.selectionListView->setModel(m_DataStorageDefaultListModel);
 
   m_DataStorageDefaultListModel2 = new QmitkDataStorageDefaultListModel(this);
   m_DataStorageDefaultListModel2->SetDataStorage(GetDataStorage());
   m_Controls.selectionListView2->setSelectionMode(QAbstractItemView::ExtendedSelection);
   m_Controls.selectionListView2->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_Controls.selectionListView2->setAlternatingRowColors(true);
   m_Controls.selectionListView2->setModel(m_DataStorageDefaultListModel2);
 
   m_Controls.singleSlot->SetDataStorage(GetDataStorage());
   m_Controls.singleSlot->SetEmptyInfo(QString("EmptyInfo: Set this to display info in empty state"));
   m_Controls.singleSlot->SetInvalidInfo(QString("InvalidInfo: is displayed for invalid states"));
   m_Controls.singleSlot->SetPopUpTitel(QString("This is the definable caption. Choose your data now!"));
   m_Controls.singleSlot->SetPopUpHint(QString("I am an optional hint, that can be set by the developer<p/>If not set the widget is invisible."));
 
   m_Controls.multiSlot->SetDataStorage(GetDataStorage());
   m_Controls.multiSlot->SetEmptyInfo(QString("EmptyInfo: Set this to display info in empty state"));
   m_Controls.multiSlot->SetInvalidInfo(QString("InvalidInfo: is displayed for invalid states"));
   m_Controls.multiSlot->SetPopUpTitel(QString("This is the definable caption. Choose your data now!"));
   m_Controls.multiSlot->SetPopUpHint(QString("I am an optional hint, that can be set by the developer<p/>If not set the widget is invisible."));
 
   m_ModelViewSelectionConnector = std::make_unique<QmitkModelViewSelectionConnector>();
   try
   {
     m_ModelViewSelectionConnector->SetView(m_Controls.selectionListView);
   }
   catch (mitk::Exception& e)
   {
     mitkReThrow(e) << "Cannot connect the model-view pair signals and slots.";
   }
   m_SelectionServiceConnector = std::make_unique<QmitkSelectionServiceConnector>();
 
   m_ModelViewSelectionConnector2 = std::make_unique<QmitkModelViewSelectionConnector>();
   try
   {
     m_ModelViewSelectionConnector2->SetView(m_Controls.selectionListView2);
   }
   catch (mitk::Exception& e)
   {
     mitkReThrow(e) << "Cannot connect the model-view pair signals and slots.";
   }
   m_SelectionServiceConnector2 = std::make_unique<QmitkSelectionServiceConnector>();
 
   m_SelectionServiceConnector3 = std::make_unique<QmitkSelectionServiceConnector>();
   m_SelectionServiceConnector4 = std::make_unique<QmitkSelectionServiceConnector>();
 
   connect(m_Controls.selectionProviderCheckBox, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionProvider1(bool)));
   connect(m_Controls.selectionProviderCheckBox2, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionProvider2(bool)));
 
   connect(m_Controls.selectionListenerCheckBox, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionListener1(bool)));
   connect(m_Controls.selectionListenerCheckBox2, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionListener2(bool)));
 
   connect(m_Controls.selectionProviderCheckBox3, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionProvider3(bool)));
   connect(m_Controls.selectionListenerCheckBox3, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionListener3(bool)));
 
   connect(m_Controls.checkOnlyVisible, SIGNAL(toggled(bool)), m_Controls.singleSlot, SLOT(SetSelectOnlyVisibleNodes(bool)));
   connect(m_Controls.checkOptional, SIGNAL(toggled(bool)), m_Controls.singleSlot, SLOT(SetSelectionIsOptional(bool)));
   connect(m_Controls.checkOnlyImages, SIGNAL(toggled(bool)), this, SLOT(OnOnlyImages(bool)));
+  connect(m_Controls.checkEnabled, SIGNAL(toggled(bool)), m_Controls.singleSlot, SLOT(setEnabled(bool)));
 
   connect(m_Controls.selectionProviderCheckBox4, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionProvider4(bool)));
   connect(m_Controls.selectionListenerCheckBox4, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionListener4(bool)));
 
   connect(m_Controls.checkOnlyVisible_2, SIGNAL(toggled(bool)), m_Controls.multiSlot, SLOT(SetSelectOnlyVisibleNodes(bool)));
   connect(m_Controls.checkOptional_2, SIGNAL(toggled(bool)), m_Controls.multiSlot, SLOT(SetSelectionIsOptional(bool)));
   connect(m_Controls.checkOnlyImages_2, SIGNAL(toggled(bool)), this, SLOT(OnOnlyImages2(bool)));
   connect(m_Controls.checkOnlyUneven, SIGNAL(toggled(bool)), this, SLOT(OnOnlyUneven(bool)));
+  connect(m_Controls.checkEnabled_2, SIGNAL(toggled(bool)), m_Controls.multiSlot, SLOT(setEnabled(bool)));
 }
 
 void QmitkDataStorageViewerTestView::SetAsSelectionProvider1(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector->SetAsSelectionProvider(GetSite()->GetSelectionProvider().Cast<QmitkDataNodeSelectionProvider>().GetPointer());
     connect(m_ModelViewSelectionConnector.get(), SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
   }
   else
   {
     m_SelectionServiceConnector->RemoveAsSelectionProvider();
     disconnect(m_ModelViewSelectionConnector.get(), SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
   }
 }
 
 void QmitkDataStorageViewerTestView::SetAsSelectionListener1(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
     connect(m_SelectionServiceConnector.get(), SIGNAL(ServiceSelectionChanged(QList<mitk::DataNode::Pointer>)), m_ModelViewSelectionConnector.get(), SLOT(SetCurrentSelection(QList<mitk::DataNode::Pointer>)));
   }
   else
   {
     m_SelectionServiceConnector->RemovePostSelectionListener();
     disconnect(m_SelectionServiceConnector.get(), SIGNAL(ServiceSelectionChanged(QList<mitk::DataNode::Pointer>)), m_ModelViewSelectionConnector.get(), SLOT(SetCurrentSelection(QList<mitk::DataNode::Pointer>)));
 
   }
 }
 
 void QmitkDataStorageViewerTestView::SetAsSelectionProvider2(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector2->SetAsSelectionProvider(GetSite()->GetSelectionProvider().Cast<QmitkDataNodeSelectionProvider>().GetPointer());
     connect(m_ModelViewSelectionConnector2.get(), SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector2.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
   }
   else
   {
     m_SelectionServiceConnector2->RemoveAsSelectionProvider();
     disconnect(m_ModelViewSelectionConnector2.get(), SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector2.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
   }
 }
 
 void QmitkDataStorageViewerTestView::SetAsSelectionListener2(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector2->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
     connect(m_SelectionServiceConnector2.get(), SIGNAL(ServiceSelectionChanged(QList<mitk::DataNode::Pointer>)), m_ModelViewSelectionConnector2.get(), SLOT(SetCurrentSelection(QList<mitk::DataNode::Pointer>)));
   }
   else
   {
     m_SelectionServiceConnector2->RemovePostSelectionListener();
     disconnect(m_SelectionServiceConnector2.get(), SIGNAL(ServiceSelectionChanged(QList<mitk::DataNode::Pointer>)), m_ModelViewSelectionConnector2.get(), SLOT(SetCurrentSelection(QList<mitk::DataNode::Pointer>)));
   }
 }
 
 void QmitkDataStorageViewerTestView::SetAsSelectionProvider3(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector3->SetAsSelectionProvider(GetSite()->GetSelectionProvider().Cast<QmitkDataNodeSelectionProvider>().GetPointer());
     connect(m_Controls.singleSlot, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector3.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
   }
   else
   {
     m_SelectionServiceConnector3->RemoveAsSelectionProvider();
     disconnect(m_Controls.singleSlot, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector3.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
   }
 }
 
 void QmitkDataStorageViewerTestView::SetAsSelectionListener3(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector3->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
     connect(m_SelectionServiceConnector3.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
   }
   else
   {
     m_SelectionServiceConnector3->RemovePostSelectionListener();
     disconnect(m_SelectionServiceConnector3.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
   }
 }
 
 void QmitkDataStorageViewerTestView::SetAsSelectionProvider4(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector4->SetAsSelectionProvider(GetSite()->GetSelectionProvider().Cast<QmitkDataNodeSelectionProvider>().GetPointer());
     connect(m_Controls.multiSlot, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector4.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
   }
   else
   {
     m_SelectionServiceConnector4->RemoveAsSelectionProvider();
     disconnect(m_Controls.multiSlot, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector4.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
   }
 }
 
 void QmitkDataStorageViewerTestView::SetAsSelectionListener4(bool checked)
 {
   if (checked)
   {
     m_SelectionServiceConnector4->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
     connect(m_SelectionServiceConnector4.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.multiSlot, &QmitkMultiNodeSelectionWidget::SetCurrentSelection);
   }
   else
   {
     m_SelectionServiceConnector4->RemovePostSelectionListener();
     disconnect(m_SelectionServiceConnector4.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.multiSlot, &QmitkMultiNodeSelectionWidget::SetCurrentSelection);
   }
 }
 
 void QmitkDataStorageViewerTestView::OnOnlyImages(bool checked)
 {
   if (checked)
   {
     m_Controls.singleSlot->SetNodePredicate(mitk::NodePredicateDataType::New("Image"));
   }
   else
   {
     m_Controls.singleSlot->SetNodePredicate(nullptr);
   }
 };
 
 void QmitkDataStorageViewerTestView::OnOnlyImages2(bool checked)
 {
   if (checked)
   {
     m_Controls.multiSlot->SetNodePredicate(mitk::NodePredicateDataType::New("Image"));
     m_Controls.multiSlot->SetInvalidInfo(QString("InvalidInfo: is displayed for invalid states. Only images allowed!"));
   }
   else
   {
     m_Controls.multiSlot->SetNodePredicate(nullptr);
     m_Controls.multiSlot->SetInvalidInfo(QString("InvalidInfo: is displayed for invalid states"));
   }
 };
 
 void QmitkDataStorageViewerTestView::OnOnlyUneven(bool checked)
 {
   if (checked)
   {
     auto checkFunction = [](const QmitkMultiNodeSelectionWidget::NodeList & nodes)
     {
       if (!(nodes.size() % 2))
       {
         std::stringstream ss;
         ss << "<font class=\"warning\"><p>Invalid selection.<p/><p>The number of selected nodes must be uneven! the current number is " << nodes.size() << ".</p>";
         return ss.str();
       }
       return std::string();
     };
 
     m_Controls.multiSlot->SetSelectionCheckFunction(checkFunction);
   }
   else
   {
     auto checkFunction = [](const QmitkMultiNodeSelectionWidget::NodeList & /*nodes*/)
     {
       return std::string();
     };
 
     m_Controls.multiSlot->SetSelectionCheckFunction(checkFunction);
   }
 };