diff --git a/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss b/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
index 595f206e36..cf73248bfa 100644
--- a/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
+++ b/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
@@ -1,601 +1,614 @@
 /*===================================================================
 
 BlueBerry Platform
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 /*
   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;
+}
+
 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.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
index 326526f925..c97a3f6016 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
@@ -1,113 +1,113 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "QmitkAbstractNodeSelectionWidget.h"
 
 QmitkAbstractNodeSelectionWidget::QmitkAbstractNodeSelectionWidget(QWidget* parent) : QWidget(parent), m_InvalidInfo("<b><font color=\"red\">Error. Select data.</font></b>"),
 m_EmptyInfo("Empty. Make a selection."), m_PopUpTitel("Select a data node"), m_PopUpHint(""),
 m_IsOptional(false), m_SelectOnlyVisibleNodes(true)
 {
 }
 
 void QmitkAbstractNodeSelectionWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage != dataStorage)
   {
     m_DataStorage = dataStorage;
     this->OnDataStorageChanged();
     this->UpdateInfo();
   }
 };
 
 void QmitkAbstractNodeSelectionWidget::SetNodePredicate(mitk::NodePredicateBase* nodePredicate)
 {
   if (m_NodePredicate != nodePredicate)
   {
     m_NodePredicate = nodePredicate;
 
     this->OnNodePredicateChanged(nodePredicate);
     this->UpdateInfo();
   }
 };
 
 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;
+  m_InvalidInfo = QString("<font class=\"warning\">")+info+QString("</font>");
   this->UpdateInfo();
 };
 
 void QmitkAbstractNodeSelectionWidget::SetEmptyInfo(QString info)
 {
-  m_EmptyInfo = info;
+  m_EmptyInfo = QString("<font class=\"normal\">")+info+QString("</font>");
   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();
 };
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
index fa21db2d4b..75dc649353 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
@@ -1,163 +1,177 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "QmitkNodeSelectionButton.h"
 
 #include "QPainter"
 #include "QTextDocument"
 
 #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)
 { }
 
 QmitkNodeSelectionButton::~QmitkNodeSelectionButton()
 {
   this->m_SelectedNode = nullptr;
 }
 
 void QmitkNodeSelectionButton::SetSelectedNode(mitk::DataNode* node)
 {
   if (m_SelectedNode != node)
   {
-    this->m_SelectedNode = node; //mitk::WeakPointer<mitk::DataNode>(node);
+    this->m_SelectedNode = node;
     this->m_OutDatedThumpNail = true;
   }
 
   this->update();
 };
 
 void QmitkNodeSelectionButton::SetNodeInfo(QString info)
 {
   this->m_Info = info;
   this->update();
 };
 
+// berry includes
+#include <berryWorkbenchPlugin.h>
+#include <berryIQtStyleManager.h>
+
 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;
+  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; // .Lock();
+    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(node->GetName()));
+    td.setHtml(QString::fromStdString("<font class=\"normal\">"+node->GetName()+"</font>"));
   }
   else
   {
     td.setHtml(m_Info);
   }
 
   auto textSize = td.size();
 
   origin.setY( (widgetSize.height() - textSize.height()) / 2.);
 
   painter.translate(origin);
   td.drawContents(&painter);
 
 }
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 dbe3bd1cc8..490fe3aa0d 100644
--- a/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp
+++ b/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp
@@ -1,247 +1,247 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // 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("<b><font color=\"red\">InvalidInfo: is displayed for invalid states</font></b>"));
+  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("<b><font color=\"red\">InvalidInfo: is displayed for invalid states</font></b>"));
+  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.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)));
 }
 
 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"));
   }
   else
   {
     m_Controls.multiSlot->SetNodePredicate(nullptr);
   }
 };