diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index 3e0da23893..3ad055e200 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,742 +1,742 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 #define SMW_INFO MITK_INFO("widget.stdmulti")
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkCameraController.h>
 #include <mitkImage.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkInteractionConst.h>
 #include <mitkLine.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkPlaneGeometryDataMapper2D.h>
 #include <mitkPointSet.h>
 #include <mitkProperties.h>
 #include <mitkStatusBar.h>
 #include <mitkDisplayActionEventHandlerStd.h>
 #include <mitkVtkLayerController.h>
 
 // qt
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 
 // vtk
 #include <vtkSmartPointer.h>
 
 // c++
 #include <iomanip>
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          const QString &name/* = "stdmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, name)
   , m_TimeNavigationController(nullptr)
 {
   m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
 }
 
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   auto allRenderWindows = this->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     m_TimeNavigationController->Disconnect(renderWindow->GetSliceNavigationController());
   }
 }
 
 void QmitkStdMultiWidget::InitializeMultiWidget()
 {
   // yellow is default color for widget4
   m_DecorationColorWidget4[0] = 1.0f;
   m_DecorationColorWidget4[1] = 1.0f;
   m_DecorationColorWidget4[2] = 0.0f;
 
   SetLayout(2, 2);
 
   // transfer colors in WorldGeometry-Nodes of the associated Renderer
   // of widget 1
   m_PlaneNode1 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetColor(GetDecorationColor(0));
 
   // of widget 2
   m_PlaneNode2 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetColor(GetDecorationColor(1));
 
   // of widget 3
   m_PlaneNode3 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetColor(GetDecorationColor(2));
 
   // the parent node
   m_ParentNodeForGeometryPlanes =
     mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
 
   AddDisplayPlaneSubTree();
 
   SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerStd>());
 
   auto displayActionEventHandler = GetDisplayActionEventHandler();
   if (nullptr != displayActionEventHandler)
   {
     displayActionEventHandler->InitActions();
   }
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
-  if ("axial" == widgetName)
+  if ("axial" == widgetName || "Axial" == widgetName)
   {
     return GetRenderWindow1();
   }
 
-  if ("sagittal" == widgetName)
+  if ("sagittal" == widgetName || "Sagittal" == widgetName)
   {
     return GetRenderWindow2();
   }
 
-  if ("coronal" == widgetName)
+  if ("coronal" == widgetName || "Coronal" == widgetName)
   {
     return GetRenderWindow3();
   }
 
-  if ("3d" == widgetName)
+  if ("3d" == widgetName || "3D" == widgetName)
   {
     return GetRenderWindow4();
   }
 
 
   return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const mitk::AnatomicalPlane& orientation) const
 {
   return GetRenderWindow(static_cast<unsigned int>(orientation));
 }
 
 void QmitkStdMultiWidget::InitializeViews(const mitk::TimeGeometry* geometry, bool resetCamera)
 {
   auto* renderingManager = mitk::RenderingManager::GetInstance();
   mitk::Point3D currentPosition = mitk::Point3D();
   unsigned int imageTimeStep = 0;
   if (!resetCamera)
   {
     // store the current position to set it again later, if the camera should not be reset
     currentPosition = this->GetSelectedPosition("");
 
     // store the current time step to set it again later, if the camera should not be reset
     const auto currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
     if (geometry->IsValidTimePoint(currentTimePoint))
     {
       imageTimeStep = geometry->TimePointToTimeStep(currentTimePoint);
     }
   }
 
   // initialize render windows
   renderingManager->InitializeViews(geometry, mitk::RenderingManager::REQUEST_UPDATE_ALL, resetCamera);
 
   if (!resetCamera)
   {
     this->SetSelectedPosition(currentPosition, "");
     renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
   }
 }
 
 void QmitkStdMultiWidget::SetInteractionReferenceGeometry(const mitk::TimeGeometry* /*referenceGeometry*/)
 {
   // not implemented on purpose
 }
 
 bool QmitkStdMultiWidget::HasCoupledRenderWindows() const
 {
   return true;
 }
 
 void QmitkStdMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& /*widgetName*/)
 {
   GetRenderWindow1()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   GetRenderWindow2()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   GetRenderWindow3()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
 
   RequestUpdateAll();
 }
 
 const mitk::Point3D QmitkStdMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
 {
   const mitk::PlaneGeometry* plane1 = GetRenderWindow1()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry* plane2 = GetRenderWindow2()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry* plane3 = GetRenderWindow3()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ((plane1 != nullptr) && (plane2 != nullptr)
    && (plane1->IntersectionLine(plane2, line)))
   {
     mitk::Point3D point;
     if ((plane3 != nullptr) && (plane3->IntersectionPoint(line, point)))
     {
       return point;
     }
   }
 
   return mitk::Point3D();
 }
 
 void QmitkStdMultiWidget::SetCrosshairVisibility(bool visible)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible);
   }
 
   emit NotifyCrosshairVisibilityChanged(visible);
 
   RequestUpdateAll();
 }
 
 bool QmitkStdMultiWidget::GetCrosshairVisibility() const
 {
   bool crosshairVisibility = true;
 
   if (m_PlaneNode1.IsNotNull())
   {
     bool visibilityProperty = false;
     m_PlaneNode1->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   if (m_PlaneNode2.IsNotNull())
   {
     bool visibilityProperty = false;
     crosshairVisibility &= m_PlaneNode2->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   if (m_PlaneNode3.IsNotNull())
   {
     bool visibilityProperty = false;
     crosshairVisibility &= m_PlaneNode3->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   return crosshairVisibility;
 }
 
 void QmitkStdMultiWidget::SetCrosshairGap(unsigned int gapSize)
 {
   m_PlaneNode1->SetIntProperty("Crosshair.Gap Size", gapSize);
   m_PlaneNode2->SetIntProperty("Crosshair.Gap Size", gapSize);
   m_PlaneNode3->SetIntProperty("Crosshair.Gap Size", gapSize);
 }
 
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
 
   SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   switch (userMode)
   {
   case 0:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKStandard);
     break;
   case 1:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationUncoupled);
     break;
   case 2:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationCoupled);
     break;
   case 3:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKSwivel);
     break;
   }
 
   emit NotifyCrosshairRotationModeChanged(userMode);
 }
 
 mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 void QmitkStdMultiWidget::AddPlanesToDataStorage()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
    && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     dataStorage->Add(m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
   }
 }
 
 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
    && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     dataStorage->Remove(m_PlaneNode1);
     dataStorage->Remove(m_PlaneNode2);
     dataStorage->Remove(m_PlaneNode3);
     dataStorage->Remove(m_ParentNodeForGeometryPlanes);
   }
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(unsigned int number) const
 {
   switch (number)
   {
   case 0:
     return GetRenderWindow1();
   case 1:
     return GetRenderWindow2();
   case 2:
     return GetRenderWindow3();
   case 3:
     return GetRenderWindow4();
   default:
     MITK_ERROR << "Requested unknown render window";
     break;
   }
 
   return nullptr;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 0));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 1));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 0));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 1));
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1() const
 {
   return m_PlaneNode1;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2() const
 {
   return m_PlaneNode2;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3() const
 {
   return m_PlaneNode3;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(unsigned number) const
 {
   switch (number)
   {
   case 1:
     return m_PlaneNode1;
   case 2:
     return m_PlaneNode2;
   case 3:
     return m_PlaneNode3;
   default:
     MITK_ERROR << "Requested unknown render window";
     break;
   }
 
   return nullptr;
 }
 
 void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
 {
   switch (widgetNumber)
   {
   case 0:
     if (m_PlaneNode1.IsNotNull())
     {
       m_PlaneNode1->SetColor(color);
     }
     break;
   case 1:
     if (m_PlaneNode2.IsNotNull())
     {
       m_PlaneNode2->SetColor(color);
     }
     break;
   case 2:
     if (m_PlaneNode3.IsNotNull())
     {
       m_PlaneNode3->SetColor(color);
     }
     break;
   case 3:
     m_DecorationColorWidget4 = color;
     break;
   default:
     MITK_ERROR << "Decoration color for unknown widget!";
     break;
   }
 }
 
 mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber)
 {
   // The implementation looks a bit messy here, but it avoids
   // synchronization of the color of the geometry nodes and an
   // internal member here.
   // Default colors were chosen for decent visibility.
   // Feel free to change your preferences in the workbench.
   float tmp[3] = { 0.0f, 0.0f, 0.0f };
   switch (widgetNumber)
   {
   case 0:
   {
     if (m_PlaneNode1.IsNotNull())
     {
       if (m_PlaneNode1->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode1->GetProperty("color"))->GetColor();
       }
     }
     float red[3] = { 0.753f, 0.0f, 0.0f }; // This is #C00000 in hex
     return mitk::Color(red);
   }
   case 1:
   {
     if (m_PlaneNode2.IsNotNull())
     {
       if (m_PlaneNode2->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode2->GetProperty("color"))->GetColor();
       }
     }
     float green[3] = { 0.0f, 0.69f, 0.0f }; // This is #00B000 in hex
     return mitk::Color(green);
   }
   case 2:
   {
     if (m_PlaneNode3.IsNotNull())
     {
       if (m_PlaneNode3->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode3->GetProperty("color"))->GetColor();
       }
     }
     float blue[3] = { 0.0, 0.502f, 1.0f }; // This is #0080FF in hex
     return mitk::Color(blue);
   }
   case 3:
   {
     return m_DecorationColorWidget4;
   }
   default:
     MITK_ERROR << "Decoration color for unknown widget!";
     float black[3] = { 0.0f, 0.0f, 0.0f };
     return mitk::Color(black);
   }
 }
 
 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent*)
 {
   // nothing here, but necessary for mouse interactions (.xml-configuration files)
 }
 
 void QmitkStdMultiWidget::moveEvent(QMoveEvent* e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the Annotation as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 void QmitkStdMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkStdMultiWidget::Fit()
 {
   vtkSmartPointer<vtkRenderer> vtkrenderer;
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetCameraController()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
 {
   // add the displayed planes of the multiwidget to a node to which the subtree
   // @a planesSubTree points ...
 
   mitk::PlaneGeometryDataMapper2D::Pointer mapper;
 
   // ... of widget 1
   mitk::BaseRenderer* renderer1 = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow());
   m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane"));
   m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   mitk::BaseRenderer* renderer2 = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow());
   m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane"));
   m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow());
   m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane"));
   m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   m_ParentNodeForGeometryPlanes = mitk::DataNode::New();
   m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets"));
   m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true));
 }
 
 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
 {
   mitk::Point2D pointOnDisplay;
   renderer->WorldToDisplay(p, pointOnDisplay);
 
   if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] ||
     pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] ||
     pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] ||
     pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1])
   {
     mitk::Point2D pointOnPlane;
     renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane);
     renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane);
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
 {
   auto dataStorage = GetDataStorage();
   if (nullptr != dataStorage)
   {
     mitk::DataNode* dataNode = dataStorage->GetNamedNode(widgetName);
     if (dataNode != nullptr)
     {
       dataNode->SetVisibility(visible, renderer);
     }
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible, renderer);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkStdMultiWidget::SetLayoutImpl()
 {
   CreateRenderWindowWidgets();
   GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
 
   // Initialize views as axial, sagittal, coronal to all data objects in DataStorage
   auto geo = GetDataStorage()->ComputeBoundingGeometry3D(GetDataStorage()->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 }
 
 void QmitkStdMultiWidget::CreateRenderWindowWidgets()
 {
   // create axial render window (widget)
   QString renderWindowWidgetName = GetNameFromIndex(0, 0);
   RenderWindowWidgetPointer renderWindowWidget1 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow1 = renderWindowWidget1->GetRenderWindow();
   renderWindow1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::AnatomicalPlane::Axial);
   renderWindowWidget1->SetDecorationColor(GetDecorationColor(0));
   renderWindowWidget1->SetCornerAnnotationText("Axial");
   renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::Axial);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget1);
 
   // create sagittal render window (widget)
   renderWindowWidgetName = GetNameFromIndex(0, 1);
   RenderWindowWidgetPointer renderWindowWidget2 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow2 = renderWindowWidget2->GetRenderWindow();
   renderWindow2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::AnatomicalPlane::Sagittal);
   renderWindowWidget2->SetDecorationColor(GetDecorationColor(1));
   renderWindowWidget2->setStyleSheet("border: 0px");
   renderWindowWidget2->SetCornerAnnotationText("Sagittal");
   renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::Sagittal);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget2);
 
   // create coronal render window (widget)
   renderWindowWidgetName = GetNameFromIndex(1, 0);
   RenderWindowWidgetPointer renderWindowWidget3 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow3 = renderWindowWidget3->GetRenderWindow();
   renderWindow3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::AnatomicalPlane::Coronal);
   renderWindowWidget3->SetDecorationColor(GetDecorationColor(2));
   renderWindowWidget3->SetCornerAnnotationText("Coronal");
   renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::Coronal);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget3);
 
   // create 3D render window (widget)
   renderWindowWidgetName = GetNameFromIndex(1, 1);
   RenderWindowWidgetPointer renderWindowWidget4 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow4 = renderWindowWidget4->GetRenderWindow();
   renderWindow4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::AnatomicalPlane::Original);
   renderWindowWidget4->SetDecorationColor(GetDecorationColor(3));
   renderWindowWidget4->SetCornerAnnotationText("3D");
   renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::Original);
   mitk::BaseRenderer::GetInstance(renderWindowWidget4->GetRenderWindow()->renderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget4);
 
   SetActiveRenderWindowWidget(renderWindowWidget1);
 
   // connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow1->GetSliceNavigationController());
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow2->GetSliceNavigationController());
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow3->GetSliceNavigationController());
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow4->GetSliceNavigationController());
   renderWindow1->GetSliceNavigationController()->ConnectGeometrySendEvent(
     mitk::BaseRenderer::GetInstance(renderWindow4->renderWindow()));
 
   // reverse connection between sliceNavigationControllers and timeNavigationController
   renderWindow1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
   renderWindow2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
   renderWindow3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
   //renderWindow4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
 
   auto layoutManager = GetMultiWidgetLayoutManager();
   connect(renderWindow1, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow1, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow1, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow1, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow1, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow1, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow2, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow2, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow2, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow2, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow2, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow2, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow3, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow3, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow3, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow3, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow3, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow3, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow4, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow4, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow4, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow4, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow4, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow4, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 }
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 d4fa50a026..22adac61e4 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
+++ b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
@@ -1,499 +1,512 @@
 /*============================================================================
 
 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 <QmitkRenderWindowWidget.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 <QAction>
+#include <QFileDialog>
+#include <QTimer>
+#include <QDateTime>
+#include <QSpinBox>
+#include <QComboBox>
+#include <QColor>
+#include <QColorDialog>
 
-#include "qapplication.h"
+#include <QApplication>
 
 #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::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::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))
+  auto windowCount = m_Controls->m_DirectionBox->count();
+  for (int i = 0; i < windowCount; ++i)
   {
-    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);
+    auto windowName = m_Controls->m_DirectionBox->itemText(i);
+    QString fileName = QDir::separator() + windowName + QString::fromStdString(".png");
+    int c = 1;
+    while (QFile::exists(filePath + fileName))
+    {
+      fileName = QDir::separator() + windowName + QString::fromStdString("_");
+      fileName += QString::number(c);
+      fileName += ".png";
+      c++;
+    }
+    vtkRenderer* renderer = renderWindowPart->GetQmitkRenderWindow(windowName)->GetRenderer()->GetVtkRenderer();
+    if (renderer != nullptr)
+    {
+      if (m_Controls->m_AllChannelsBox->isChecked())
+        MultichannelScreenshot(renderWindowPart->GetQmitkRenderWindow(windowName)->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);
 
   GetCam()->Roll( 2.5 );
   // not negative because direction of elevation has flipped
   GetCam()->Elevation( 94 );
   GetCam()->Azimuth( -82.5 );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkScreenshotMaker::GenerateHR3DAtlasScreenshots(QString fileName, QString filter)
 {
   // only works correctly for 3D RenderWindow
   auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
   auto* renderer = renderWindowPart->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer();
 
   if (nullptr != renderer)
   {
     renderWindowPart->EnableDecorations(false);
     this->TakeScreenshot(renderer, this->m_Controls->m_MagFactor->text().toFloat(), fileName, filter);
     renderWindowPart->EnableDecorations(true);
   }
 }
 
 vtkCamera* QmitkScreenshotMaker::GetCam()
 {
   auto* renderer = this->GetRenderWindowPart(mitk::WorkbenchUtil::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::UpdateDirectionBox(mitk::IRenderWindowPart* renderWindowPart)
+{
+  m_Controls->m_DirectionBox->clear();
+
+  auto renderWindows = renderWindowPart->GetQmitkRenderWindows();
+  bool has3DWindow = false;
+  for (auto name : renderWindows.keys())
+  {
+    auto window = renderWindows[name];
+    if (window->GetRenderer()->GetMapperID() == mitk::BaseRenderer::Standard3D)
+    {
+      has3DWindow = true;
+    }
+    else
+    {
+      auto windowName = name;
+      auto renderWindowWidget = dynamic_cast<QmitkRenderWindowWidget*>(window->parentWidget());
+      if (renderWindowWidget)
+      {
+        windowName = QString::fromStdString(renderWindowWidget->GetCornerAnnotationText());
+      }
+      m_Controls->m_DirectionBox->insertItem(m_Controls->m_DirectionBox->count() + 1, windowName);
+    }
+  }
+
+  renderWindows = renderWindowPart->GetQmitkRenderWindows();
+
+  m_Controls->groupBox->setEnabled(has3DWindow);
+}
+
 void QmitkScreenshotMaker::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     m_Parent = parent;
     m_Controls = new Ui::QmitkScreenshotMakerControls;
     m_Controls->setupUi(parent);
 
+    auto renderWindowPart = this->GetRenderWindowPart();
+    if (renderWindowPart)
+    {
+      this->UpdateDirectionBox(renderWindowPart);
+    }
+
     // 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*/)
+void QmitkScreenshotMaker::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   m_Parent->setEnabled(true);
+  this->UpdateDirectionBox(renderWindowPart);
+}
+
+void QmitkScreenshotMaker::RenderWindowPartInputChanged(mitk::IRenderWindowPart* renderWindowPart)
+{
+  this->UpdateDirectionBox(renderWindowPart);
 }
 
 void QmitkScreenshotMaker::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_Parent->setEnabled(false);
+  m_Controls->m_DirectionBox->clear();
 }
 
 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(mitk::WorkbenchUtil::OPEN);
 
   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);
 }
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.h b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.h
index 543a69a60e..17ae9a859d 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.h
+++ b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.h
@@ -1,128 +1,133 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkScreenshotMaker_h
 #define QmitkScreenshotMaker_h
 
 #include <QmitkAbstractView.h>
 #include <mitkIRenderWindowPartListener.h>
 
 #include "mitkCameraRotationController.h"
 #include "mitkStepper.h"
 #include "mitkMultiStepper.h"
 #include "mitkMovieGenerator.h"
 #include "itkCommand.h"
 
 #include "vtkEventQtSlotConnect.h"
 #include "vtkRenderWindow.h"
 #include "mitkVtkPropRenderer.h"
 
 #include "ui_QmitkScreenshotMakerControls.h"
 //#include "../MovieMakerDll.h"
 
 //class QmitkMovieMakerControls;
 class QmitkStepperAdapter;
 class vtkCamera;
 class QTimer;
 class QTime;
 
 /**
  * \brief View for creating movies (AVIs)
  */
 class QmitkScreenshotMaker: public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
   /** \brief Constructor. */
   QmitkScreenshotMaker(QObject *parent=nullptr, const char *name=nullptr);
 
   /** \brief Destructor. */
   ~QmitkScreenshotMaker() override;
 
   /** \brief Method for creating the widget containing the application
    * controls, like sliders, buttons etc.
    */
   void CreateQtPartControl(QWidget *parent) override;
   //  virtual QWidget * CreateControlWidget(QWidget *parent);
 
   ///
   /// Sets the focus to an internal widget.
   ///
   void SetFocus() override;
 
   /** \brief Method for creating the connections of main and control widget.
    */
   virtual void CreateConnections();
 
   /** \brief Method for creating an QAction object, i.e. button & menu entry.
    * @param parent the parent QWidget
    */
   //  virtual QAction * CreateAction(QActionGroup *parent);
 
   ///
   /// Called when a RenderWindowPart becomes available.
   ///
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
   ///
   /// Called when a RenderWindowPart becomes unavailable.
   ///
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
+  ///
+  /// Called when a RenderWindowPart changes.
+  ///
+  void RenderWindowPartInputChanged(mitk::IRenderWindowPart* renderWindowPart) override;
 
   signals:
 
 protected slots:
 
   void GenerateScreenshot();
   void GenerateMultiplanarScreenshots();
   void Generate3DHighresScreenshot();
   void GenerateMultiplanar3DHighresScreenshot();
   void SelectBackgroundColor();
 
 protected:
 
   QObject *parentWidget;
   QWidget* m_Parent;
   vtkEventQtSlotConnect * connections;
   vtkRenderWindow * renderWindow;
   mitk::VtkPropRenderer::Pointer m_PropRenderer;
 
   Ui::QmitkScreenshotMakerControls* m_Controls;
 
 private:
 
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
+  void UpdateDirectionBox(mitk::IRenderWindowPart* renderWindowPart);
 
   vtkCamera* GetCam();
   void GenerateHR3DAtlasScreenshots(QString fileName, QString filter = "");
   void GenerateMultiplanarScreenshots(QString fileName);
 
   mitk::DataNode::Pointer GetTopLayerNode();
   void MultichannelScreenshot(mitk::VtkPropRenderer* renderer, QString fileName, QString filter);
 
   /*!
   \brief taking a screenshot "from" the specified renderer
   \param magnificationFactor specifying the quality of the screenshot (the magnification of the actual RenderWindow size)
   \param fileName file location and name where the screenshot should be saved
   */
   void TakeScreenshot(vtkRenderer* renderer, unsigned int magnificationFactor, QString fileName, QString filter = "");
 
   QColor m_BackgroundColor;
 
   mitk::DataNode* m_SelectedNode;
   QString           m_LastPath;
   QString           m_LastFile;
   QString           m_PNGExtension = "PNG File (*.png)";
   QString           m_JPGExtension = "JPEG File (*.jpg)";
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMakerControls.ui b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMakerControls.ui
index ceeffda16d..217a534a99 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMakerControls.ui
+++ b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMakerControls.ui
@@ -1,185 +1,169 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkScreenshotMakerControls</class>
  <widget class="QWidget" name="QmitkScreenshotMakerControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>315</width>
     <height>368</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>ScreenshotMaker</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupBox_2">
      <property name="title">
       <string>2D Screenshots</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <item row="1" column="1">
        <widget class="QPushButton" name="m_Shot">
         <property name="text">
          <string>Multiplanar</string>
         </property>
        </widget>
       </item>
       <item row="2" column="0" colspan="2">
-       <widget class="QComboBox" name="m_DirectionBox">
-        <item>
-         <property name="text">
-          <string>axial</string>
-         </property>
-        </item>
-        <item>
-         <property name="text">
-          <string>coronal</string>
-         </property>
-        </item>
-        <item>
-         <property name="text">
-          <string>sagittal</string>
-         </property>
-        </item>
-       </widget>
+       <widget class="QComboBox" name="m_DirectionBox"/>
       </item>
       <item row="1" column="0">
        <widget class="QPushButton" name="btnScreenshot">
         <property name="text">
          <string>Single</string>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QCheckBox" name="m_AllChannelsBox">
         <property name="text">
          <string> All Components</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>3D Screenshots (High-res)</string>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="0" column="0">
        <widget class="QPushButton" name="m_HRScreenshot">
         <property name="text">
          <string>Single</string>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QPushButton" name="m_AllViews">
         <property name="text">
          <string>Multiplanar</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0" colspan="2">
        <layout class="QHBoxLayout" name="horizontalLayout_2">
         <item>
          <widget class="QLabel" name="label">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Upsampling:</string>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QSpinBox" name="m_MagFactor">
           <property name="minimum">
            <number>1</number>
           </property>
           <property name="value">
            <number>4</number>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_3">
      <property name="title">
       <string>Options</string>
      </property>
      <layout class="QHBoxLayout" name="horizontalLayout">
       <item>
        <widget class="QLabel" name="label_2">
         <property name="text">
          <string>Background Color:</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QPushButton" name="m_BackgroundColor">
         <property name="minimumSize">
          <size>
           <width>30</width>
           <height>30</height>
          </size>
         </property>
         <property name="maximumSize">
          <size>
           <width>30</width>
           <height>30</height>
          </size>
         </property>
         <property name="text">
          <string/>
         </property>
        </widget>
       </item>
       <item>
        <spacer name="horizontalSpacer">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer>
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>31</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources/>
  <connections/>
 </ui>