diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.cpp
index a337cd5ad7..d301680b15 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.cpp
@@ -1,463 +1,463 @@
 /*============================================================================
 
 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 "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)
+  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;
 }
 
 
 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);
 }
 
 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;
     }
   }
 }
 
 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.";
 }
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
index 9136a85b7a..94368892fb 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
+++ b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
@@ -1,491 +1,493 @@
 /*============================================================================
 
 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 "QmitkScreenshotMaker.h"
 //#include "QmitkMovieMakerControls.h"
 #include "QmitkStepperAdapter.h"
 
 #include "mitkVtkPropRenderer.h"
 #include <QmitkRenderWindow.h>
 
 #include <iostream>
 
 #include <vtkRenderer.h>
 #include <vtkCamera.h>
 
 #include <qaction.h>
 #include <qfiledialog.h>
 #include <qtimer.h>
 #include <qdatetime.h>
 #include <qspinbox.h>
 #include <qcombobox.h>
 #include <qcolor.h>
 #include <qcolordialog.h>
 
 #include "qapplication.h"
 
 #include "vtkImageWriter.h"
 #include "vtkJPEGWriter.h"
 #include "vtkPNGWriter.h"
 #include "vtkRenderLargeImage.h"
 #include "vtkRenderWindowInteractor.h"
 #include "vtkRenderer.h"
 #include "vtkTestUtilities.h"
 
 #include <vtkActor.h>
 #include "vtkMitkRenderProp.h"
 
 #include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
 #include "vtkRenderWindowInteractor.h"
 #include <qradiobutton.h>
 
 #include "mitkSliceNavigationController.h"
 #include "mitkPlanarFigure.h"
 #include <mitkWorkbenchUtil.h>
 #include <mitkImage.h>
 #include <itksys/SystemTools.hxx>
 
 QmitkScreenshotMaker::QmitkScreenshotMaker(QObject *parent, const char * /*name*/)
   : QmitkAbstractView(),
     m_Controls(nullptr),
     m_BackgroundColor(QColor(0,0,0)),
     m_SelectedNode(nullptr)
 {
   parentWidget = parent;
 }
 
 QmitkScreenshotMaker::~QmitkScreenshotMaker()
 {
 }
 
 void QmitkScreenshotMaker::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*) m_Controls->m_AllViews, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateMultiplanar3DHighresScreenshot()));
     connect((QObject*) m_Controls->m_Shot, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateMultiplanarScreenshots()));
     connect((QObject*) m_Controls->m_BackgroundColor, SIGNAL(clicked()), (QObject*) this, SLOT(SelectBackgroundColor()));
     connect((QObject*) m_Controls->btnScreenshot, SIGNAL(clicked()), this, SLOT(GenerateScreenshot()));
     connect((QObject*) m_Controls->m_HRScreenshot, SIGNAL(clicked()), this, SLOT(Generate3DHighresScreenshot()));
 
     QString styleSheet = "background-color:rgb(0,0,0)";
     m_Controls->m_BackgroundColor->setStyleSheet(styleSheet);
   }
 }
 
 mitk::DataNode::Pointer QmitkScreenshotMaker::GetTopLayerNode()
 {
   mitk::DataNode::Pointer out = nullptr;
 
   int layer = -1;
   auto nodes = GetDataStorage()->GetAll();
   for (auto node = nodes->begin(); node!=nodes->end(); ++node)
   {
     if (!(*node)->IsVisible(nullptr))
       continue;
     int current_layer;
     (*node)->GetIntProperty("layer", current_layer);
     if (current_layer>layer)
     {
       out = (*node);
       layer = current_layer;
     }
   }
 
   return out;
 }
 
 void QmitkScreenshotMaker::MultichannelScreenshot(mitk::VtkPropRenderer* renderer, QString fileName, QString filter)
 {
   auto node = GetTopLayerNode();
   if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
   {
     auto image = dynamic_cast<mitk::Image*>(node->GetData());
 
     std::string fname = itksys::SystemTools::GetFilenamePath(fileName.toStdString()) + "/" + itksys::SystemTools::GetFilenameWithoutExtension(fileName.toStdString());
     std::string ext = itksys::SystemTools::GetFilenameExtension(fileName.toStdString());
 
     mitk::PixelType chPixelType = image->GetImageDescriptor()->GetChannelTypeById(0);
     if (image->GetDimension() == 4)
     {
       MITK_INFO << "LOOPING THROUGH FOURTH DIMESNION IS NOT IMPLEMENTED";
     }
     else if (chPixelType.GetNumberOfComponents()>1)
     {
       for(int unsigned c=0; c<chPixelType.GetNumberOfComponents(); ++c)
       {
         node->SetProperty("Image.Displayed Component", mitk::IntProperty::New(c));
         this->TakeScreenshot(renderer->GetVtkRenderer(), 1, QString(fname.c_str()) + "_" + QString::number(c) + QString(ext.c_str()), filter);
       }
     }
     else
       this->TakeScreenshot(renderer->GetVtkRenderer(), 1, fileName, filter);
   }
   else
     this->TakeScreenshot(renderer->GetVtkRenderer(), 1, fileName, filter);
 }
 
 void QmitkScreenshotMaker::GenerateScreenshot()
 {
   if (m_LastFile.size()==0)
     m_LastFile = QDir::currentPath()+"/screenshot.png";
 
   QString filter;
   QString fileName = QFileDialog::getSaveFileName(nullptr, "Save screenshot to...", m_LastFile, m_PNGExtension + ";;" + m_JPGExtension, &filter);
 
   if (fileName.size()>0)
     m_LastFile = fileName;
 
   auto renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
 
   auto renderer = renderWindowPart->GetQmitkRenderWindow(m_Controls->m_DirectionBox->currentText())->GetRenderer();
   if (renderer == nullptr)
     return;
 
   if (m_Controls->m_AllChannelsBox->isChecked())
     MultichannelScreenshot(renderer, fileName, filter);
   else
     this->TakeScreenshot(renderer->GetVtkRenderer(), 1, fileName, filter);
 }
 
 void QmitkScreenshotMaker::GenerateMultiplanarScreenshots()
 {
   if (m_LastPath.size()==0)
     m_LastPath = QDir::currentPath();
   QString filePath = QFileDialog::getExistingDirectory(nullptr, "Save screenshots to...", m_LastPath);
   if (filePath.size()>0)
     m_LastPath = filePath;
 
   if( filePath.isEmpty() )
   {
     return;
   }
 
   //emit StartBlockControls();
   auto renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
   renderWindowPart->EnableDecorations(false, QStringList{mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION});
 
   QString fileName = "/axial.png";
   int c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/axial_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   vtkRenderer* renderer = renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer()->GetVtkRenderer();
   if (renderer != nullptr)
   {
     if (m_Controls->m_AllChannelsBox->isChecked())
       MultichannelScreenshot(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer(), filePath+fileName, m_PNGExtension);
     else
       this->TakeScreenshot(renderer, 1, filePath+fileName);
   }
 
   fileName = "/sagittal.png";
   c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/sagittal_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   renderer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer()->GetVtkRenderer();
   if (renderer != nullptr)
   {
     if (m_Controls->m_AllChannelsBox->isChecked())
       MultichannelScreenshot(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer(), filePath+fileName, m_PNGExtension);
     else
       this->TakeScreenshot(renderer, 1, filePath+fileName);
   }
 
   fileName = "/coronal.png";
   c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/coronal_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   renderer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer()->GetVtkRenderer();
   if (renderer != nullptr)
   {
     if (m_Controls->m_AllChannelsBox->isChecked())
       MultichannelScreenshot(renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer(), filePath+fileName, m_PNGExtension);
     else
       this->TakeScreenshot(renderer, 1, filePath+fileName);
   }
 
   /// TODO I do not find a simple way of doing this through the render window part API,
   /// however, I am also not convinced that this code is needed at all. The colour
   /// of the crosshair planes is never set to any colour other than these.
   /// I suggest a new 'mitk::DataNode* mitk::ILinkedRendererPart::GetSlicingPlane(const std::string& name) const'
   /// function to introduce that could return the individual ("axial", "sagittal" or
   /// "coronal" crosshair planes.
 
   //    mitk::DataNode* n = renderWindowPart->GetSlicingPlane("axial");
   //    if (n)
   //    {
   //        n->SetProperty( "color", mitk::ColorProperty::New( 1,0,0 ) );
   //    }
   //
   //    n = renderWindowPart->GetSlicingPlane("sagittal");
   //    if (n)
   //    {
   //        n->SetProperty( "color", mitk::ColorProperty::New( 0,1,0 ) );
   //    }
   //
   //    n = renderWindowPart->GetSlicingPlane("coronal");
   //    if (n)
   //    {
   //        n->SetProperty( "color", mitk::ColorProperty::New( 0,0,1 ) );
   //    }
 
   renderWindowPart->EnableDecorations(true, QStringList{mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION});
 }
 
 void QmitkScreenshotMaker::Generate3DHighresScreenshot()
 {
   if (m_LastFile.size()==0)
     m_LastFile = QDir::currentPath()+"/3D_screenshot.png";
 
   QString filter;
   QString fileName = QFileDialog::getSaveFileName(nullptr, "Save screenshot to...", m_LastFile, m_PNGExtension + ";;" + m_JPGExtension, &filter);
 
   if (fileName.size()>0)
     m_LastFile = fileName;
   GenerateHR3DAtlasScreenshots(fileName, filter);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkScreenshotMaker::GenerateMultiplanar3DHighresScreenshot()
 {
   if (m_LastPath.size()==0)
     m_LastPath = QDir::currentPath();
   QString filePath = QFileDialog::getExistingDirectory( nullptr, "Save screenshots to...", m_LastPath);
   if (filePath.size()>0)
     m_LastPath = filePath;
 
   if( filePath.isEmpty() )
   {
     return;
   }
 
   QString fileName = "/3D_View1.png";
   int c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/3D_View1_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   GetCam()->Azimuth( -7.5 );
   GetCam()->Roll(-4);
   GenerateHR3DAtlasScreenshots(filePath+fileName);
   GetCam()->Roll(4);
 
   fileName = "/3D_View2.png";
   c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/3D_View2_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   GetCam()->Azimuth( 90 );
   GetCam()->Elevation( 4 );
   GenerateHR3DAtlasScreenshots(filePath+fileName);
 
   fileName = "/3D_View3.png";
   c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/3D_View3_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   GetCam()->Elevation( 90 );
   GetCam()->Roll( -2.5 );
   GenerateHR3DAtlasScreenshots(filePath+fileName);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkScreenshotMaker::GenerateHR3DAtlasScreenshots(QString fileName, QString filter)
 {
   // only works correctly for 3D RenderWindow
-  this->GetRenderWindowPart()->EnableDecorations(false, QStringList{mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION});
-  vtkRenderer* renderer = this->GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer();
-  if (renderer == nullptr)
-    return;
-  this->TakeScreenshot(renderer, this->m_Controls->m_MagFactor->text().toFloat(), fileName, filter);
-  this->GetRenderWindowPart()->EnableDecorations(true, QStringList{mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION});
+  auto renderer = this->GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer();
+
+  if (nullptr != renderer)
+  {
+    this->GetRenderWindowPart()->EnableDecorations(false);
+    this->TakeScreenshot(renderer, this->m_Controls->m_MagFactor->text().toFloat(), fileName, filter);
+    this->GetRenderWindowPart()->EnableDecorations(true);
+  }
 }
 
 vtkCamera* QmitkScreenshotMaker::GetCam()
 {
   mitk::BaseRenderer* renderer = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN)->GetQmitkRenderWindow("3d")->GetRenderer();
   vtkCamera* cam = nullptr;
   const mitk::VtkPropRenderer *propRenderer = dynamic_cast<const mitk::VtkPropRenderer * >( renderer );
   if (propRenderer)
   {
     // get vtk renderer
     vtkRenderer* vtkrenderer = propRenderer->GetVtkRenderer();
     if (vtkrenderer)
     {
       // get vtk camera
       vtkCamera* vtkcam = vtkrenderer->GetActiveCamera();
       if (vtkcam)
       {
         // vtk smart pointer handling
         cam = vtkcam;
         cam->Register( nullptr );
       }
     }
   }
   return cam;
 }
 
 void QmitkScreenshotMaker::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   if(nodes.size())
     m_SelectedNode = nodes[0];
 }
 
 void QmitkScreenshotMaker::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     m_Parent = parent;
     m_Controls = new Ui::QmitkScreenshotMakerControls;
     m_Controls->setupUi(parent);
 
     // Initialize "Selected Window" combo box
     const mitk::RenderingManager::RenderWindowVector rwv =
         mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
 
   }
 
   this->CreateConnections();
 
 }
 
 void QmitkScreenshotMaker::SetFocus()
 {
   m_Controls->btnScreenshot->setFocus();
 }
 
 void QmitkScreenshotMaker::RenderWindowPartActivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_Parent->setEnabled(true);
 }
 
 void QmitkScreenshotMaker::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_Parent->setEnabled(false);
 }
 
 void QmitkScreenshotMaker::TakeScreenshot(vtkRenderer* renderer, unsigned int magnificationFactor, QString fileName, QString filter)
 {
   if ((renderer == nullptr) ||(magnificationFactor < 1) || fileName.isEmpty())
     return;
 
   bool doubleBuffering( renderer->GetRenderWindow()->GetDoubleBuffer() );
   renderer->GetRenderWindow()->DoubleBufferOff();
 
   vtkImageWriter* fileWriter = nullptr;
 
   QFileInfo fi(fileName);
   QString suffix = fi.suffix().toLower();
 
   if (suffix.isEmpty() || (suffix != "png" && suffix != "jpg" && suffix != "jpeg"))
   {
     if (filter == m_PNGExtension)
     {
       suffix = "png";
     }
     else if (filter == m_JPGExtension)
     {
       suffix = "jpg";
     }
     fileName += "." + suffix;
   }
 
   if (suffix.compare("jpg", Qt::CaseInsensitive) == 0 || suffix.compare("jpeg", Qt::CaseInsensitive) == 0)
   {
     vtkJPEGWriter* w = vtkJPEGWriter::New();
     w->SetQuality(100);
     w->ProgressiveOff();
     fileWriter = w;
   }
   else //default is png
   {
     fileWriter = vtkPNGWriter::New();
   }
 
   vtkRenderLargeImage* magnifier = vtkRenderLargeImage::New();
   magnifier->SetInput(renderer);
   magnifier->SetMagnification(magnificationFactor);
   //magnifier->Update();
   fileWriter->SetInputConnection(magnifier->GetOutputPort());
   fileWriter->SetFileName(fileName.toLatin1());
 
   // vtkRenderLargeImage has problems with different layers, therefore we have to
   // temporarily deactivate all other layers.
   // we set the background to white, because it is nicer than black...
   double oldBackground[3];
   renderer->GetBackground(oldBackground);
 
 
   //  QColor color = QColorDialog::getColor();
   double bgcolor[] = {m_BackgroundColor.red()/255.0, m_BackgroundColor.green()/255.0, m_BackgroundColor.blue()/255.0};
   renderer->SetBackground(bgcolor);
 
   mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
 
   renderWindowPart->EnableDecorations(false);
 
   fileWriter->Write();
   fileWriter->Delete();
 
   renderWindowPart->EnableDecorations(true);
 
   renderer->SetBackground(oldBackground);
 
   renderer->GetRenderWindow()->SetDoubleBuffer(doubleBuffering);
 }
 
 void QmitkScreenshotMaker::SelectBackgroundColor()
 {
   m_BackgroundColor = QColorDialog::getColor();
 
   m_Controls->m_BackgroundColor->setAutoFillBackground(true);
 
 
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(m_BackgroundColor.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(m_BackgroundColor.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(m_BackgroundColor.blue()));
   styleSheet.append(")");
   m_Controls->m_BackgroundColor->setStyleSheet(styleSheet);
 }