diff --git a/Modules/QtWidgets/include/QmitkRenderWindowWidget.h b/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
index ee59a1e945..e6575ab7a1 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
@@ -1,115 +1,120 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef QMITKRENDERWINDOWWIDGET_H
 #define QMITKRENDERWINDOWWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkRenderWindow.h"
 
 // mitk core
 #include <mitkDataStorage.h>
 #include <mitkPointSet.h>
 #include <mitkRenderWindow.h>
-#include <vtkCornerAnnotation.h>
 
 // qt
 #include <QFrame>
 #include <QHBoxLayout>
 #include <QMouseEvent>
 
+class vtkCornerAnnotation;
+class vtkMitkRectangleProp;
+
 /**
 * @brief The 'QmitkRenderWindowWidget' is a QFrame that holds a render window
 *        and some associates properties, like a crosshair (pointset) and decorations.
-*        Decorations are corner annotation (text and color) or background color and can be set using this class.
+*        Decorations are corner annotation (text and color), frame color or background color
+*        and can be set using this class.
 *        The 'QmitkRenderWindowWidget' is used inside a 'QmitkAbstractMultiWidget', where a map contains
 *        several render window widgets to create the multi widget display.
 */
-class MITKQTWIDGETS_EXPORT QmitkRenderWindowWidget : public QFrame
+class MITKQTWIDGETS_EXPORT QmitkRenderWindowWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkRenderWindowWidget(
     QWidget* parent = nullptr,
     const QString& widgetName = "",
     mitk::DataStorage* dataStorage = nullptr,
     mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard
   );
 
   virtual ~QmitkRenderWindowWidget();
 
   void SetDataStorage(mitk::DataStorage* dataStorage);
 
   const QString& GetWidgetName() const { return m_WidgetName; };
   QmitkRenderWindow* GetRenderWindow() const { return m_RenderWindow; };
 
   mitk::SliceNavigationController* GetSliceNavigationController() const;
 
   void RequestUpdate();
   void ForceImmediateUpdate();
 
   void SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower);
   void ShowGradientBackground(bool enable);
   std::pair<mitk::Color, mitk::Color> GetGradientBackgroundColors() const { return m_GradientBackgroundColors; };
   bool IsGradientBackgroundOn() const;
 
   void SetDecorationColor(const mitk::Color& color);
   mitk::Color GetDecorationColor() const { return m_DecorationColor; };
 
   void ShowColoredRectangle(bool show);
   bool IsColoredRectangleVisible() const;
 
   void ShowCornerAnnotation(bool show);
   bool IsCornerAnnotationVisible() const;
   void SetCornerAnnotationText(const std::string& cornerAnnotation);
   std::string GetCornerAnnotationText() const;
 
   bool IsRenderWindowMenuActivated() const;
 
   void ActivateCrosshair(bool activate);
 
 Q_SIGNALS:
 
   void MouseEvent(QMouseEvent* e);
 
 private:
 
   void InitializeGUI();
   void InitializeDecorations();
 
   void SetCrosshair(mitk::Point3D selectedPoint);
 
   QString m_WidgetName;
   QHBoxLayout* m_Layout;
 
   mitk::DataStorage* m_DataStorage;
   QmitkRenderWindow* m_RenderWindow;
 
   mitk::RenderingManager::Pointer m_RenderingManager;
   mitk::BaseRenderer::RenderingMode::Type m_RenderingMode;
 
   mitk::DataNode::Pointer m_PointSetNode;
   mitk::PointSet::Pointer m_PointSet;
 
   std::pair<mitk::Color, mitk::Color> m_GradientBackgroundColors;
   mitk::Color m_DecorationColor;
   vtkSmartPointer<vtkCornerAnnotation> m_CornerAnnotation;
+  vtkSmartPointer<vtkMitkRectangleProp> m_RectangleProp;
+
 };
 
 #endif // QMITKRENDERWINDOWWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
index 219f7e0d2b..84391f7b63 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
@@ -1,244 +1,255 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "QmitkRenderWindowWidget.h"
 
 // vtk
+#include <vtkCornerAnnotation.h>
+#include <vtkMitkRectangleProp.h>
 #include <vtkTextProperty.h>
 
 QmitkRenderWindowWidget::QmitkRenderWindowWidget(QWidget* parent/* = nullptr*/,
                                                  const QString& widgetName/* = ""*/,
                                                  mitk::DataStorage* dataStorage/* = nullptr*/,
                                                  mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/)
-  : QFrame(parent)
+  : QWidget(parent)
   , m_WidgetName(widgetName)
   , m_DataStorage(dataStorage)
   , m_RenderWindow(nullptr)
   , m_RenderingMode(renderingMode)
   , m_PointSetNode(nullptr)
   , m_PointSet(nullptr)
 {
   InitializeGUI();
 }
 
 QmitkRenderWindowWidget::~QmitkRenderWindowWidget()
 {
   auto sliceNavigationController = m_RenderWindow->GetSliceNavigationController();
   if (nullptr != sliceNavigationController)
   {
     sliceNavigationController->SetCrosshairEvent.RemoveListener(mitk::MessageDelegate1<QmitkRenderWindowWidget, mitk::Point3D>(this, &QmitkRenderWindowWidget::SetCrosshair));
   }
   if (nullptr != m_DataStorage)
   {
     m_DataStorage->Remove(m_PointSetNode);
   }
 }
 
 void QmitkRenderWindowWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (dataStorage == m_DataStorage)
   {
     return;
   }
 
   m_DataStorage = dataStorage;
   if (nullptr != m_RenderWindow)
   {
     mitk::BaseRenderer::GetInstance(m_RenderWindow->GetRenderWindow())->SetDataStorage(dataStorage);
   }
 }
 
 mitk::SliceNavigationController* QmitkRenderWindowWidget::GetSliceNavigationController() const
 {
   return m_RenderWindow->GetSliceNavigationController();
 }
 
 void QmitkRenderWindowWidget::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(m_RenderWindow->GetRenderWindow());
 }
 
 void QmitkRenderWindowWidget::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(m_RenderWindow->GetRenderWindow());
 }
 
 void QmitkRenderWindowWidget::SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower)
 {
   vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
   if (nullptr == vtkRenderer)
   {
     return;
   }
 
   m_GradientBackgroundColors.first = upper;
   m_GradientBackgroundColors.second = lower;
   vtkRenderer->SetBackground(lower[0], lower[1], lower[2]);
   vtkRenderer->SetBackground2(upper[0], upper[1], upper[2]);
 
   ShowGradientBackground(true);
 }
 
 void QmitkRenderWindowWidget::ShowGradientBackground(bool show)
 {
   m_RenderWindow->GetRenderer()->GetVtkRenderer()->SetGradientBackground(show);
 }
 
 bool QmitkRenderWindowWidget::IsGradientBackgroundOn() const
 {
   return m_RenderWindow->GetRenderer()->GetVtkRenderer()->GetGradientBackground();
 }
 
 void QmitkRenderWindowWidget::SetDecorationColor(const mitk::Color& color)
 {
   m_DecorationColor = color;
-  m_CornerAnnotation->GetTextProperty()->SetColor(color[0], color[1], color[2]);
+  m_CornerAnnotation->GetTextProperty()->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
+  m_RectangleProp->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
 }
 
 void QmitkRenderWindowWidget::ShowColoredRectangle(bool show)
 {
-  // Not implemented for now. Colored rectangle is defined via qt border stylesheet
+  m_RectangleProp->SetVisibility(show);
 }
 
 bool QmitkRenderWindowWidget::IsColoredRectangleVisible() const
 {
-  return false;
+  return m_RectangleProp->GetVisibility() > 0;
 }
 
 void QmitkRenderWindowWidget::ShowCornerAnnotation(bool show)
 {
   m_CornerAnnotation->SetVisibility(show);
 }
 
 bool QmitkRenderWindowWidget::IsCornerAnnotationVisible() const
 {
   return m_CornerAnnotation->GetVisibility() > 0;
 }
 
 void QmitkRenderWindowWidget::SetCornerAnnotationText(const std::string& cornerAnnotation)
 {
   m_CornerAnnotation->SetText(0, cornerAnnotation.c_str());
 }
 
 std::string QmitkRenderWindowWidget::GetCornerAnnotationText() const
 {
   return std::string(m_CornerAnnotation->GetText(0));
 }
 
 bool QmitkRenderWindowWidget::IsRenderWindowMenuActivated() const
 {
   return m_RenderWindow->GetActivateMenuWidgetFlag();
 }
 
 void QmitkRenderWindowWidget::ActivateCrosshair(bool activate)
 {
   if (nullptr == m_DataStorage)
   {
     return;
   }
 
   if (activate)
   {
     try
     {
       m_DataStorage->Add(m_PointSetNode);
     }
     catch(std::invalid_argument& /*e*/)
     {
       // crosshair already existing
       return;
     }
   }
   else
   {
     m_DataStorage->Remove(m_PointSetNode);
   }
 }
 
 void QmitkRenderWindowWidget::InitializeGUI()
 {
   m_Layout = new QHBoxLayout(this);
   m_Layout->setMargin(0);
   setLayout(m_Layout);
   setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+  setContentsMargins(0, 0, 0, 0);
 
   // create render window for this render window widget
   m_RenderingManager = mitk::RenderingManager::GetInstance();
   //m_RenderingManager = mitk::RenderingManager::New();
   m_RenderingManager->SetDataStorage(m_DataStorage);
 
   m_RenderWindow = new QmitkRenderWindow(this, m_WidgetName, nullptr, m_RenderingManager, m_RenderingMode);
   m_RenderWindow->SetLayoutIndex(mitk::SliceNavigationController::Sagittal);
   m_RenderWindow->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
   m_RenderWindow->GetSliceNavigationController()->SetRenderingManager(m_RenderingManager);
   m_RenderWindow->GetSliceNavigationController()->SetCrosshairEvent.AddListener(mitk::MessageDelegate1<QmitkRenderWindowWidget, mitk::Point3D>(this, &QmitkRenderWindowWidget::SetCrosshair));
 
   connect(m_RenderWindow, &QVTKOpenGLWidget::mouseEvent, this, &QmitkRenderWindowWidget::MouseEvent);
 
   mitk::TimeGeometry::ConstPointer timeGeometry = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
   m_RenderingManager->InitializeViews(timeGeometry);
   m_Layout->addWidget(m_RenderWindow);
 
   // add point set as a crosshair
   m_PointSetNode = mitk::DataNode::New();
   m_PointSetNode->SetProperty("name", mitk::StringProperty::New("Crosshair of render window " + m_WidgetName.toStdString()));
   m_PointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true)); // crosshair-node should typically be invisible
 
   // set the crosshair only visible for this specific renderer
   m_PointSetNode->SetBoolProperty("fixedLayer", true, m_RenderWindow->GetRenderer());
   m_PointSetNode->SetVisibility(true, m_RenderWindow->GetRenderer());
   m_PointSetNode->SetVisibility(false);
 
   m_PointSet = mitk::PointSet::New();
   m_PointSetNode->SetData(m_PointSet);
 
   // set colors and corner annotation
   InitializeDecorations();
 }
 
 void QmitkRenderWindowWidget::InitializeDecorations()
 {
   vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
   if (nullptr == vtkRenderer)
   {
     return;
   }
 
   // initialize background color gradients
   float black[3] = { 0.0f, 0.0f, 0.0f };
   SetGradientBackgroundColors(black, black);
 
   // initialize decoration color, rectangle and annotation text
   float white[3] = { 1.0f, 1.0f, 1.0f };
   m_DecorationColor = white;
 
   setStyleSheet("border: 2px solid white");
 
   m_CornerAnnotation = vtkSmartPointer<vtkCornerAnnotation>::New();
   m_CornerAnnotation->SetText(0, "Sagittal");
   m_CornerAnnotation->SetMaximumFontSize(12);
   m_CornerAnnotation->GetTextProperty()->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
   if (0 == vtkRenderer->HasViewProp(m_CornerAnnotation))
   {
     vtkRenderer->AddViewProp(m_CornerAnnotation);
   }
+
+  m_RectangleProp = vtkSmartPointer<vtkMitkRectangleProp>::New();
+  m_RectangleProp->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
+  if (0 == vtkRenderer->HasViewProp(m_RectangleProp))
+  {
+    vtkRenderer->AddViewProp(m_RectangleProp);
+  }
 }
 
 void QmitkRenderWindowWidget::SetCrosshair(mitk::Point3D selectedPoint)
 {
   m_PointSet->SetPoint(1, selectedPoint, 0);
   mitk::RenderingManager::GetInstance()->RequestUpdate(m_RenderWindow->GetRenderWindow());
 }
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.cpp
index b152b3f85b..283c71f796 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.cpp
@@ -1,461 +1,467 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "QmitkMultiWidgetDecorationManager.h"
 
 // org mitk gui common plugin
 #include <mitkIRenderWindowPart.h>
 
 // mitk annotation module
 #include <mitkManualPlacementAnnotationRenderer.h>
 
 // mitk qt widgets module
 #include <QmitkRenderWindowWidget.h>
 
 // vtk
 #include <vtkQImageToImageSource.h>
 
 // qt
 #include <QColor>
 
 QmitkMultiWidgetDecorationManager::QmitkMultiWidgetDecorationManager(QmitkAbstractMultiWidget* multiWidget)
   : m_MultiWidget(multiWidget)
   , m_LogoAnnotation(mitk::LogoAnnotation::New())
 {
   // nothing here
 }
 
 void QmitkMultiWidgetDecorationManager::DecorationPreferencesChanged(const berry::IBerryPreferences* preferences)
 {
   // Enable change of logo. If no DepartmentLogo was set explicitly, MBILogo is used.
   // Set new department logo by prefs->Set("DepartmentLogo", "PathToImage");
 
   // If no logo was set for this plug-in specifically, walk the parent preference nodes
   // and lookup a logo value there.
 
   // Disable the logo first, otherwise setting a new logo will have no effect due to how mitkManufacturerLogo works
   ShowLogo(false);
   SetupLogo(qPrintable(":/org.mitk.gui.qt.stdmultiwidgeteditor/defaultWatermark.png"));
   ShowLogo(true);
 
   const berry::IPreferences* currentNode = preferences;
   while (currentNode)
   {
     bool logoFound = false;
     foreach(const QString& key, currentNode->Keys())
     {
       if (key == "DepartmentLogo")
       {
         ShowLogo(false);
         QString departmentLogoLocation = currentNode->Get("DepartmentLogo", "");
         if (!departmentLogoLocation.isEmpty())
         {
           SetupLogo(qPrintable(departmentLogoLocation));
           ShowLogo(true);
         }
         logoFound = true;
         break;
       }
     }
 
     if (logoFound)
     {
       break;
     }
     currentNode = currentNode->Parent().GetPointer();
   }
 
+  /*
   QmitkMultiWidgetDecorationManager::Colormap colormap = static_cast<QmitkMultiWidgetDecorationManager::Colormap>(preferences->GetInt("Render window widget colormap", 0));
   SetColormap(colormap);
+  */
 
   // show colored rectangle
   ShowAllColoredRectangles(true);
 
+  // show all gradient background
+  ShowAllGradientBackgrounds(true);
+
   // show corner annotations
   ShowAllCornerAnnotations(true);
 }
 
 void QmitkMultiWidgetDecorationManager::ShowDecorations(bool show, const QStringList& decorations)
 {
   if (nullptr != m_MultiWidget)
   {
     return;
   }
 
   if (decorations.isEmpty() || decorations.contains(mitk::IRenderWindowPart::DECORATION_BORDER))
   {
     ShowAllColoredRectangles(show);
   }
   if (decorations.isEmpty() || decorations.contains(mitk::IRenderWindowPart::DECORATION_LOGO))
   {
     ShowLogo(show);
   }
   if (decorations.isEmpty() || decorations.contains(mitk::IRenderWindowPart::DECORATION_MENU))
   {
     //m_MultiWidget->ActivateAllRenderWindowMenus(show);
   }
   if (decorations.isEmpty() || decorations.contains(mitk::IRenderWindowPart::DECORATION_BACKGROUND))
   {
     ShowAllGradientBackgrounds(show);
   }
   if (decorations.isEmpty() || decorations.contains(mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION))
   {
     ShowAllCornerAnnotations(show);
   }
 }
 
 bool QmitkMultiWidgetDecorationManager::IsDecorationVisible(const QString& decoration) const
 { 
   if (mitk::IRenderWindowPart::DECORATION_BORDER == decoration)
   {
     return AreAllColoredRectanglesVisible();
   }
   else if (mitk::IRenderWindowPart::DECORATION_LOGO == decoration)
   {
     return IsLogoVisible();
   }
   else if (mitk::IRenderWindowPart::DECORATION_MENU == decoration)
   {
     //return IsMenuWidgetEnabled();
   }
   else if (mitk::IRenderWindowPart::DECORATION_BACKGROUND == decoration)
   {
     return AreAllGradientBackgroundsOn();
   }
   else if (mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION == decoration)
   {
     return AreAllCornerAnnotationsVisible();
   }
 
   return false;
 }
 
 QStringList QmitkMultiWidgetDecorationManager::GetDecorations() const
 {
   QStringList decorations;
   decorations << mitk::IRenderWindowPart::DECORATION_BORDER << mitk::IRenderWindowPart::DECORATION_LOGO << mitk::IRenderWindowPart::DECORATION_MENU
               << mitk::IRenderWindowPart::DECORATION_BACKGROUND << mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION;
   return decorations;
 }
 
-//////////////////////////////////////////////////////////////////////////
-// PRIVATE
-//////////////////////////////////////////////////////////////////////////
+
 void QmitkMultiWidgetDecorationManager::SetupLogo(const char* path)
 {
   m_LogoAnnotation->SetOpacity(0.5);
   mitk::Point2D offset;
   offset.Fill(0.03);
   m_LogoAnnotation->SetOffsetVector(offset);
   m_LogoAnnotation->SetRelativeSize(0.25);
   m_LogoAnnotation->SetCornerPosition(1);
   vtkSmartPointer<vtkImageData> vtkLogo = GetVtkLogo(path);
 
   SetLogo(vtkLogo);
 }
 
-vtkSmartPointer<vtkImageData> QmitkMultiWidgetDecorationManager::GetVtkLogo(const char* path)
-{
-  QImage* qimage = new QImage(path);
-  vtkSmartPointer<vtkQImageToImageSource> qImageToVtk;
-  qImageToVtk = vtkSmartPointer<vtkQImageToImageSource>::New();
-
-  qImageToVtk->SetQImage(qimage);
-  qImageToVtk->Update();
-  vtkSmartPointer<vtkImageData> vtkLogo = qImageToVtk->GetOutput();
-  return vtkLogo;
-}
-
-void QmitkMultiWidgetDecorationManager::SetLogo(vtkSmartPointer<vtkImageData> vtkLogo)
-{
-  std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetLastRenderWindowWidget();
-  if (nullptr != renderWindowWidget && m_LogoAnnotation.IsNotNull())
-  {
-    mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_LogoAnnotation.GetPointer(), renderWindowWidget->GetRenderWindow()->GetRenderer());
-    m_LogoAnnotation->SetLogoImage(vtkLogo);
-    mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderWindowWidget->GetRenderWindow()->GetVtkRenderWindow());
-    m_LogoAnnotation->Update(renderer);
-    renderWindowWidget->RequestUpdate();
-    return;
-  }
-
-  MITK_ERROR << "Logo can not be set for an unknown widget.";
-}
-
 void QmitkMultiWidgetDecorationManager::ShowLogo(bool show)
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetLastRenderWindowWidget();
   if (nullptr != renderWindowWidget)
   {
     m_LogoAnnotation->SetVisibility(show);
     renderWindowWidget->RequestUpdate();
     return;
   }
 
   MITK_ERROR << "Logo can not be shown for an unknown widget.";
 }
 
 bool QmitkMultiWidgetDecorationManager::IsLogoVisible() const
 {
   return m_LogoAnnotation->IsVisible();
 }
 
 void QmitkMultiWidgetDecorationManager::SetColormap(QmitkMultiWidgetDecorationManager::Colormap colormap)
 {
   switch (colormap)
   {
-  case Colormap::BlackAndWhite:
-  {
-    FillAllGradientBackgroundColorsWithBlack();
-    float white[3] = { 1.0f, 1.0f, 1.0f };
-    SetAllDecorationColors(white);
-    break;
-  }
+    case Colormap::BlackAndWhite:
+    {
+      FillAllGradientBackgroundColorsWithBlack();
+      float white[3] = { 1.0f, 1.0f, 1.0f };
+      SetAllDecorationColors(white);
+      break;
+    }
   }
 }
 
 void QmitkMultiWidgetDecorationManager::SetDecorationColor(const QString& widgetID, const mitk::Color& color)
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->SetDecorationColor(color);
     return;
   }
 
   MITK_ERROR << "Decoration color can not be set for an unknown widget.";
 }
 
 void QmitkMultiWidgetDecorationManager::SetAllDecorationColors(const mitk::Color& color)
 {
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->SetDecorationColor(color);
   }
 }
 
 mitk::Color QmitkMultiWidgetDecorationManager::GetDecorationColor(const QString& widgetID) const
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->GetDecorationColor();
   }
 
   MITK_ERROR << "Decoration color can not be retrieved for an unknown widget. Returning black color!";
   float black[3] = { 0.0f, 0.0f, 0.0f };
   return mitk::Color(black);
 }
 
 void QmitkMultiWidgetDecorationManager::ShowColoredRectangle(const QString& widgetID, bool show)
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->ShowColoredRectangle(show);
     return;
   }
 
   MITK_ERROR << "Colored rectangle can not be set for an unknown widget.";
 }
 
 void QmitkMultiWidgetDecorationManager::ShowAllColoredRectangles(bool show)
 {
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->ShowColoredRectangle(show);
   }
 }
 
 bool QmitkMultiWidgetDecorationManager::IsColoredRectangleVisible(const QString& widgetID) const
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->IsColoredRectangleVisible();
   }
 
   MITK_ERROR << "Colored rectangle visibility can not be retrieved for an unknown widget. Returning 'false'.";
   return false;
 }
 
 bool QmitkMultiWidgetDecorationManager::AreAllColoredRectanglesVisible() const
 {
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
   bool allTrue = true;
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     allTrue = allTrue && renderWindowWidget.second->IsColoredRectangleVisible();
   }
 
   return allTrue;
 }
 
 void QmitkMultiWidgetDecorationManager::SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower, const QString& widgetID)
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->SetGradientBackgroundColors(upper, lower);
     return;
   }
 
   MITK_ERROR << "Background color gradient can not be set for an unknown widget.";
 }
 
 void QmitkMultiWidgetDecorationManager::SetAllGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower)
 {
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->SetGradientBackgroundColors(upper, lower);
   }
 }
 
 void QmitkMultiWidgetDecorationManager::FillAllGradientBackgroundColorsWithBlack()
 {
   float black[3] = { 0.0f, 0.0f, 0.0f };
   SetAllGradientBackgroundColors(black, black);
 }
 
 void QmitkMultiWidgetDecorationManager::ShowGradientBackground(const QString& widgetID, bool show)
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->ShowGradientBackground(show);
     return;
   }
 
   MITK_ERROR << "Background color gradient can not be shown for an unknown widget.";
 }
 
 void QmitkMultiWidgetDecorationManager::ShowAllGradientBackgrounds(bool show)
 {
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->ShowGradientBackground(show);
   }
 }
 
 std::pair<mitk::Color, mitk::Color> QmitkMultiWidgetDecorationManager::GetGradientBackgroundColors(const QString& widgetID) const
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->GetGradientBackgroundColors();
   }
 
   MITK_ERROR << "Background color gradient can not be retrieved for an unknown widget. Returning black color pair.";
   float black[3] = { 0.0f, 0.0f, 0.0f };
   return std::make_pair(mitk::Color(black), mitk::Color(black));
 }
 
 bool QmitkMultiWidgetDecorationManager::IsGradientBackgroundOn(const QString& widgetID) const
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->IsGradientBackgroundOn();
   }
 
   MITK_ERROR << "Background color gradient flag can not be retrieved for an unknown widget. Returning 'false'.";
   return false;
 }
 
 bool QmitkMultiWidgetDecorationManager::AreAllGradientBackgroundsOn() const
 {
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
   bool allTrue = true;
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     allTrue = allTrue && renderWindowWidget.second->IsGradientBackgroundOn();
   }
 
   return allTrue;
 }
 
 void QmitkMultiWidgetDecorationManager::SetCornerAnnotationText(const QString& widgetID, const std::string& cornerAnnotation)
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->SetCornerAnnotationText(cornerAnnotation);
     return;
   }
 
   MITK_ERROR << "Corner annotation text can not be retrieved for an unknown widget.";
 }
 
 std::string QmitkMultiWidgetDecorationManager::GetCornerAnnotationText(const QString& widgetID) const
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->GetCornerAnnotationText();
   }
 
   MITK_ERROR << "Corner annotation text can not be retrieved for an unknown widget.";
   return "";
 }
 
 void QmitkMultiWidgetDecorationManager::ShowCornerAnnotation(const QString& widgetID, bool show)
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->ShowCornerAnnotation(show);
     return;
   }
 
   MITK_ERROR << "Corner annotation can not be set for an unknown widget.";
 }
 
 void QmitkMultiWidgetDecorationManager::ShowAllCornerAnnotations(bool show)
 {
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     renderWindowWidget.second->ShowCornerAnnotation(show);
   }
 }
 
 bool QmitkMultiWidgetDecorationManager::IsCornerAnnotationVisible(const QString& widgetID) const
 {
   std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(widgetID);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->IsCornerAnnotationVisible();
   }
 
   MITK_ERROR << "Corner annotation visibility can not be retrieved for an unknown widget. Returning 'false'.";
   return false;
 }
 
 bool QmitkMultiWidgetDecorationManager::AreAllCornerAnnotationsVisible() const
 {
   QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
   bool allTrue = true;
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     allTrue = allTrue && renderWindowWidget.second->IsCornerAnnotationVisible();
   }
 
   return allTrue;
 }
+
+//////////////////////////////////////////////////////////////////////////
+// PRIVATE
+//////////////////////////////////////////////////////////////////////////
+vtkSmartPointer<vtkImageData> QmitkMultiWidgetDecorationManager::GetVtkLogo(const char* path)
+{
+  QImage* qimage = new QImage(path);
+  vtkSmartPointer<vtkQImageToImageSource> qImageToVtk;
+  qImageToVtk = vtkSmartPointer<vtkQImageToImageSource>::New();
+
+  qImageToVtk->SetQImage(qimage);
+  qImageToVtk->Update();
+  vtkSmartPointer<vtkImageData> vtkLogo = qImageToVtk->GetOutput();
+  return vtkLogo;
+}
+
+void QmitkMultiWidgetDecorationManager::SetLogo(vtkSmartPointer<vtkImageData> vtkLogo)
+{
+  std::shared_ptr<QmitkRenderWindowWidget> renderWindowWidget = m_MultiWidget->GetLastRenderWindowWidget();
+  if (nullptr != renderWindowWidget && m_LogoAnnotation.IsNotNull())
+  {
+    mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_LogoAnnotation.GetPointer(), renderWindowWidget->GetRenderWindow()->GetRenderer());
+    m_LogoAnnotation->SetLogoImage(vtkLogo);
+    mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderWindowWidget->GetRenderWindow()->GetVtkRenderWindow());
+    m_LogoAnnotation->Update(renderer);
+    renderWindowWidget->RequestUpdate();
+    return;
+  }
+
+  MITK_ERROR << "Logo can not be set for an unknown widget.";
+}
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.h b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.h
index ab96b72465..c0f60c5d54 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.h
@@ -1,143 +1,144 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef QMITKMULTIWIDGETDECORATIONMANAGER_H
 #define QMITKMULTIWIDGETDECORATIONMANAGER_H
 
 #include <org_mitk_gui_qt_common_Export.h>
 
 // mitk core
 #include <mitkColorProperty.h>
 
 // mitk annotation
 #include <mitkLogoAnnotation.h>
 
 // mitk qt widgets
 #include <QmitkAbstractMultiWidget.h>
 
 // berry
 #include <berryIBerryPreferences.h>
 
 // vtk
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 
 // qt
 #include <QString>
 #include <QStringList>
 
 /**
 * @brief
 *
 *
 */
 class MITK_QT_COMMON QmitkMultiWidgetDecorationManager
 {
 
 public:
 
   QmitkMultiWidgetDecorationManager(QmitkAbstractMultiWidget* multiWidget);
 
   enum class Colormap
   {
     BlackAndWhite = 0 // black background, white decoration
   };
 
   void DecorationPreferencesChanged(const berry::IBerryPreferences* preferences);
 
   /**
   * @brief Show or hide decorations like like colored borders or background, logos, menu widgets, logos and
   *     text annotations.
   *
   * \@par  Show the decorations specified in decorations if true. Hide them, if not.
   * \@par  A list of decoration names. If empty, all supported decorations are affected.
   */
   void ShowDecorations(bool show, const QStringList& decorations);
   /**
   * @brief Return if a specific decoration is visible.
   *
   * \return True, if the specified decoration is shown, false if not.
   */
   bool IsDecorationVisible(const QString &decoration) const;
   QStringList GetDecorations() const;
 
-private:
-
   void SetupLogo(const char* path);
-  vtkSmartPointer<vtkImageData> GetVtkLogo(const char* path);
-  void SetLogo(vtkSmartPointer<vtkImageData> vtkLogo);
   void ShowLogo(bool show);
   bool IsLogoVisible() const;
 
   void SetColormap(Colormap colormap);
 
   void SetDecorationColor(const QString& widgetID, const mitk::Color& color);
   void SetAllDecorationColors(const mitk::Color& color);
   mitk::Color GetDecorationColor(const QString& widgetID) const;
 
   void ShowColoredRectangle(const QString& widgetID, bool show);
   void ShowAllColoredRectangles(bool show);
   bool IsColoredRectangleVisible(const QString& widgetID) const;
   bool AreAllColoredRectanglesVisible() const;
 
   /**
   * @brief Set a background color gradient for a specific render window.
   *
   *   If two different input colors are used, a gradient background is generated.
   *
   * @param upper          The color of the gradient background.
   * @param lower          The color of the gradient background.
   * @param widgetID   The widget identifier.
   */
   void SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower, const QString& widgetID);
   /**
   * @brief Set a background color gradient for all available render windows.
   *
   *   If two different input colors are used, a gradient background is generated.
   *
   * @param upper          The color of the gradient background.
   * @param lower          The color of the gradient background.
   */
   void SetAllGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower);
   void FillAllGradientBackgroundColorsWithBlack();
   void ShowGradientBackground(const QString& widgetID, bool show);
   void ShowAllGradientBackgrounds(bool show);
   /**
   * @rief Return a render window (widget) specific background color gradient
   *
   * @param widgetID   The widget identifier.
   *
   * @return               A color gradient as a pair of colors.
   *                       First entry: upper color value
   *                       Second entry: lower color value
   */
   std::pair<mitk::Color, mitk::Color> GetGradientBackgroundColors(const QString& widgetID) const;
   bool IsGradientBackgroundOn(const QString& widgetID) const;
   bool AreAllGradientBackgroundsOn() const;
 
   void SetCornerAnnotationText(const QString& widgetID, const std::string& cornerAnnotation);
   std::string GetCornerAnnotationText(const QString& widgetID) const;
   void ShowCornerAnnotation(const QString& widgetID, bool show);
   void ShowAllCornerAnnotations(bool show);
   bool IsCornerAnnotationVisible(const QString& widgetID) const;
   bool AreAllCornerAnnotationsVisible() const;
 
+private:
+
+  vtkSmartPointer<vtkImageData> GetVtkLogo(const char* path);
+  void SetLogo(vtkSmartPointer<vtkImageData> vtkLogo);
+
   QmitkAbstractMultiWidget* m_MultiWidget;
   mitk::LogoAnnotation::Pointer m_LogoAnnotation;
 
 };
 
 #endif // QMITKMULTIWIDGETDECORATIONMANAGER_H