diff --git a/Modules/QtWidgets/include/QmitkCustomMultiWidget.h b/Modules/QtWidgets/include/QmitkCustomMultiWidget.h
index a58cce5214..4b9d0dc783 100644
--- a/Modules/QtWidgets/include/QmitkCustomMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkCustomMultiWidget.h
@@ -1,208 +1,213 @@
 /*===================================================================
 
 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 QMITKCUSTOMMULTIWIDGET_H
 #define QMITKCUSTOMMULTIWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDataStorage.h>
 
 // qt
 #include <qwidget.h>
 
 class QHBoxLayout;
 class QVBoxLayout;
 class QGridLayout;
 class QSpacerItem;
 class QmitkLevelWindowWidget;
 class QmitkRenderWindow;
 class vtkCornerAnnotation;
 
 namespace mitk
 {
   class RenderingManager;
 }
 
 /**
 * @brief The 'QmitkCustomMultiWidget' is a 'QWidget' that is used to display multiple render windows at once.
 *
 *     Render windows can dynamically be added and removed to change the layout of the multi widget.
 */
 class MITKQTWIDGETS_EXPORT QmitkCustomMultiWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkCustomMultiWidget(QWidget* parent = 0,
                          Qt::WindowFlags f = 0,
                          mitk::RenderingManager* renderingManager = nullptr,
                          mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard,
                          const QString& multiWidgetName = "custommulti");
 
   virtual ~QmitkCustomMultiWidget();
   
   void SetDataStorage(mitk::DataStorage* dataStorage);
 
-  std::map<QString, QmitkRenderWindowWidget*> GetRenderWindowWidgets() const;
-  QmitkRenderWindowWidget* GetRenderWindowWidget(unsigned int widgetNumber) const;
+  using RenderWindowWidgetMap = std::map<QString, QmitkRenderWindowWidget*>;
+  using RenderWindowHash = QHash<QString, QmitkRenderWindow*>;
+  RenderWindowWidgetMap GetRenderWindowWidgets() const;
+  QmitkRenderWindowWidget* GetRenderWindowWidget(const QString& widgetID) const;
+
+  QmitkRenderWindow* GetRenderWindow(const QString& widgetID) const;
+
   QmitkRenderWindowWidget* GetActiveRenderWindowWidget() const;
   QmitkRenderWindowWidget* GetFirstRenderWindowWidget() const;
   QmitkRenderWindowWidget* GetLastRenderWindowWidget() const;
   
   unsigned int GetNumberOfRenderWindowWidgets() const;
 
-  void RequestUpdate(unsigned int widgetNumber);
+  void RequestUpdate(const QString& widgetID);
   void RequestUpdateAll();
-  void ForceImmediateUpdate(unsigned int widgetNumber);
+  void ForceImmediateUpdate(const QString& widgetID);
   void ForceImmediateUpdateAll();
 
-  const mitk::Point3D GetCrossPosition(unsigned int widgetNumber) const;
+  const mitk::Point3D GetCrossPosition(const QString& widgetID) const;
 
 public slots:
 
-  void ShowLevelWindowWidget(unsigned int widgetNumber, bool show);
+  void ShowLevelWindowWidget(const QString& widgetID, bool show);
   void ShowAllLevelWindowWidgets(bool show);
   /**
   * @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 widgetNumber   The widget identifier.
+  * @param widgetID   The widget identifier.
   */
-  void SetBackgroundColorGradient(const mitk::Color& upper, const mitk::Color& lower, unsigned int widgetNumber);
+  void SetBackgroundColorGradient(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.
   */
   // #TODO: 'backgroundgradientcolor'
   void SetAllBackgroundColorGradients(const mitk::Color& upper, const mitk::Color& lower);
   void FillAllBackgroundColorGradientsWithBlack();
-  void ShowBackgroundColorGradient(unsigned int widgetNumber, bool show);
+  void ShowBackgroundColorGradient(const QString& widgetID, bool show);
   void ShowAllBackgroundColorGradients(bool show);
   /**
   * @rief Return a render window (widget) specific background color gradient
   *
-  * @param widgetNumber   The widget identifier.
+  * @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> GetBackgroundColorGradient(unsigned int widgetNumber) const;
-  bool GetBackgroundColorGradientFlag(unsigned int widgetNumber) const;
+  std::pair<mitk::Color, mitk::Color> GetBackgroundColorGradient(const QString& widgetID) const;
+  bool GetBackgroundColorGradientFlag(const QString& widgetID) const;
 
   void SetDepartmentLogoPath(const char* path);
-  void ShowDepartmentLogo(unsigned int widgetNumber, bool show);
+  void ShowDepartmentLogo(const QString& widgetID, bool show);
   void ShowAllDepartmentLogos(bool show);
 
-  void SetDecorationColor(unsigned int widgetNumber, const mitk::Color& color);
-  mitk::Color GetDecorationColor(unsigned int widgetNumber) const;
+  void SetDecorationColor(const QString& widgetID, const mitk::Color& color);
+  mitk::Color GetDecorationColor(const QString& widgetID) const;
 
-  void ShowColoredRectangle(unsigned int widgetNumber, bool show);
+  void ShowColoredRectangle(const QString& widgetID, bool show);
   void ShowAllColoredRectangles(bool show);
-  bool IsColoredRectangleVisible(unsigned int widgetNumber) const;
+  bool IsColoredRectangleVisible(const QString& widgetID) const;
 
-  void ShowCornerAnnotation(unsigned int widgetNumber, bool show);
+  void ShowCornerAnnotation(const QString& widgetID, bool show);
   void ShowAllCornerAnnotations(bool show);
-  bool IsCornerAnnotationVisible(unsigned int widgetNumber) const;
-  void SetCornerAnnotationText(unsigned int widgetNumber, const std::string& cornerAnnotation);
-  std::string GetCornerAnnotationText(unsigned int widgetNumber) const;
+  bool IsCornerAnnotationVisible(const QString& widgetID) const;
+  void SetCornerAnnotationText(const QString& widgetID, const std::string& cornerAnnotation);
+  std::string GetCornerAnnotationText(const QString& widgetID) const;
 
   /**
   * @brief Listener to the CrosshairPositionEvent
   *
   *   Ensures the CrosshairPositionEvent is handled only once and at the end of the Qt-Event loop
   */
   void HandleCrosshairPositionEvent();
   /**
   * @brief Receives the signal from HandleCrosshairPositionEvent, executes the StatusBar update
   *
   */
   void HandleCrosshairPositionEventDelayed();
 
   void Fit();
 
   void EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p);
 
-  void MoveCrossToPosition(unsigned int widgetNumber, const mitk::Point3D& newPosition);
+  void MoveCrossToPosition(const QString& widgetID, const mitk::Point3D& newPosition);
 
   void ResetCrosshair();
 
   // mouse events
-  void wheelEvent(QWheelEvent *e) override;
+  void wheelEvent(QWheelEvent* e) override;
 
-  void mousePressEvent(QMouseEvent *e) override;
+  void mousePressEvent(QMouseEvent* e) override;
 
-  void moveEvent(QMoveEvent *e) override;
+  void moveEvent(QMoveEvent* e) override;
 
 signals:
 
   void WheelMoved(QWheelEvent *);
   void Moved();
 
 public:
 
   enum
   {
     AXIAL,
     SAGITTAL,
     CORONAL,
     THREE_D
   };
 
 private:
 
   void InitializeGUI();
   void InitializeWidget();
   void AddRenderWindowWidget();
   
   // #TODO: see T24173
   mitk::DataNode::Pointer GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
 
   QGridLayout* m_CustomMultiWidgetLayout;
-  std::map<QString, QmitkRenderWindowWidget*> m_RenderWindowWidgets;
+  RenderWindowWidgetMap m_RenderWindowWidgets;
 
   QmitkRenderWindowWidget* m_ActiveRenderWindowWidget;
 
   int m_PlaneMode;
 
   mitk::RenderingManager* m_RenderingManager;
   mitk::BaseRenderer::RenderingMode::Type m_RenderingMode;
   QString m_MultiWidgetName;
 
   //mitk::MouseModeSwitcher::Pointer m_MouseModeSwitcher;
   mitk::SliceNavigationController *m_TimeNavigationController;
 
   mitk::DataStorage::Pointer m_DataStorage;
 
   bool m_PendingCrosshairPositionEvent;
   bool m_CrosshairNavigationEnabled;
 
 };
 
 #endif // QMITKCUSTOMMULTIWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkCustomMultiWidget.cpp b/Modules/QtWidgets/src/QmitkCustomMultiWidget.cpp
index 6ac6436a3f..c604990c25 100644
--- a/Modules/QtWidgets/src/QmitkCustomMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkCustomMultiWidget.cpp
@@ -1,688 +1,719 @@
 /*===================================================================
 
 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 "QmitkCustomMultiWidget.h"
 
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 #include <QVBoxLayout>
 
+#include <mitkUIDGenerator.h>
+
 #include "mitkImagePixelReadAccessor.h"
 #include "mitkPixelTypeMultiplex.h"
 #include <mitkManualPlacementAnnotationRenderer.h>
 #include <mitkCameraController.h>
 #include <mitkDataStorage.h>
 #include <mitkImage.h>
 #include <mitkInteractionConst.h>
 #include <mitkLine.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkPlaneGeometryDataMapper2D.h>
 #include <mitkPointSet.h>
 #include <mitkProperties.h>
 #include <mitkStatusBar.h>
 #include <mitkVtkLayerController.h>
 #include <vtkSmartPointer.h>
 #include <vtkQImageToImageSource.h>
 
 #include <iomanip>
 
 // qt
 #include <QGridLayout>
 
 QmitkCustomMultiWidget::QmitkCustomMultiWidget(QWidget* parent,
                                                Qt::WindowFlags f/* = 0*/,
                                                mitk::RenderingManager* renderingManager/* = nullptr*/,
                                                mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/,
                                                const QString& multiWidgetName/* = "custommulti"*/)
   : QWidget(parent, f)
   , m_CustomMultiWidgetLayout(nullptr)
   , m_RenderingManager(renderingManager)
   , m_RenderingMode(renderingMode)
   , m_MultiWidgetName(multiWidgetName)
   , m_TimeNavigationController(nullptr)
   , m_PendingCrosshairPositionEvent(false)
   , m_CrosshairNavigationEnabled(false)
 {
   if (nullptr == m_RenderingManager)
   {
     m_RenderingManager = mitk::RenderingManager::GetInstance();
   }
   m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
 
   // create widget manually
   // create and set layout
   InitializeGUI();
   // create at least one render window initially
   AddRenderWindowWidget();
 
   resize(QSize(364, 477).expandedTo(minimumSizeHint()));
 
   InitializeWidget();
 }
 
 QmitkCustomMultiWidget::~QmitkCustomMultiWidget()
 {
-  for (const auto& mapEntry : m_RenderWindowWidgets)
+  for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
-    m_TimeNavigationController->Disconnect(mapEntry.second->GetRenderWindow()->GetSliceNavigationController());
+    m_TimeNavigationController->Disconnect(renderWindowWidget.second->GetRenderWindow()->GetSliceNavigationController());
   }
 }
 
 void QmitkCustomMultiWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (dataStorage == m_DataStorage)
   {
     return;
   }
 
   m_DataStorage = dataStorage;
   for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
     renderWindowWidget.second->SetDataStorage(m_DataStorage);
   }
 }
 
-std::map<QString, QmitkRenderWindowWidget*> QmitkCustomMultiWidget::GetRenderWindowWidgets() const
+QmitkCustomMultiWidget::RenderWindowWidgetMap QmitkCustomMultiWidget::GetRenderWindowWidgets() const
 {
   return m_RenderWindowWidgets;
 }
 
-QmitkRenderWindowWidget* QmitkCustomMultiWidget::GetRenderWindowWidget(unsigned int widgetNumber) const
+QmitkRenderWindowWidget* QmitkCustomMultiWidget::GetRenderWindowWidget(const QString& widgetID) const
 {
-  return m_RenderWindowWidgets.find(QString::number(widgetNumber))->second;
+  RenderWindowWidgetMap::const_iterator it = m_RenderWindowWidgets.find(widgetID);
+  if (it == m_RenderWindowWidgets.end())
+  {
+    return nullptr;
+  }
+
+  return it->second;
+}
+
+QmitkRenderWindow* QmitkCustomMultiWidget::GetRenderWindow(const QString& widgetID) const
+{
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
+  {
+    return renderWindowWidget->GetRenderWindow();
+  }
+
+  return nullptr;
 }
 
 QmitkRenderWindowWidget* QmitkCustomMultiWidget::GetActiveRenderWindowWidget() const
 {
-  return m_ActiveRenderWindowWidget;
+  //return m_ActiveRenderWindowWidget;
+  return m_RenderWindowWidgets.begin()->second;
 }
 
 QmitkRenderWindowWidget* QmitkCustomMultiWidget::GetFirstRenderWindowWidget() const
 {
   return m_RenderWindowWidgets.begin()->second;
 }
 
 QmitkRenderWindowWidget* QmitkCustomMultiWidget::GetLastRenderWindowWidget() const
 {
   return m_RenderWindowWidgets.rbegin()->second;
 }
 
 unsigned int QmitkCustomMultiWidget::GetNumberOfRenderWindowWidgets() const
 {
   return m_RenderWindowWidgets.size();
 }
 
-void QmitkCustomMultiWidget::RequestUpdate(unsigned int widgetNumber)
+void QmitkCustomMultiWidget::RequestUpdate(const QString& widgetID)
 {
-  GetRenderWindowWidget(widgetNumber)->RequestUpdate();
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
+  {
+    return renderWindowWidget->RequestUpdate();
+  }
 }
 
 void QmitkCustomMultiWidget::RequestUpdateAll()
 {
   // #TODO: Update only render windows that show the same image?
   // #TODO: Update only type specific render windows (2D / 3D)?
-  size_t numberOfRenderWindowWidgets = m_RenderWindowWidgets.size();
-  for (size_t i = 0; i < numberOfRenderWindowWidgets; ++i)
+  for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
-    RequestUpdate(i);
+    renderWindowWidget.second->RequestUpdate();
   }
 }
 
-void QmitkCustomMultiWidget::ForceImmediateUpdate(unsigned int widgetNumber)
+void QmitkCustomMultiWidget::ForceImmediateUpdate(const QString& widgetID)
 {
-  GetRenderWindowWidget(widgetNumber)->ForceImmediateUpdate();
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
+  {
+    renderWindowWidget->ForceImmediateUpdate();
+  }
 }
 
 void QmitkCustomMultiWidget::ForceImmediateUpdateAll()
 {
   // #TODO: Update only render windows that show the same image?
   // #TODO: Update only type specific render windows (2D / 3D)?
-  size_t numberOfRenderWindowWidgets = m_RenderWindowWidgets.size();
-  for (size_t i = 0; i < numberOfRenderWindowWidgets; ++i)
+  for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
-    ForceImmediateUpdate(i);
+    renderWindowWidget.second->ForceImmediateUpdate();
   }
 }
 
-const mitk::Point3D QmitkCustomMultiWidget::GetCrossPosition(unsigned int widgetNumber) const
+const mitk::Point3D QmitkCustomMultiWidget::GetCrossPosition(const QString& widgetID) const
 {
   /*
   const mitk::PlaneGeometry *plane1 = mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane2 = mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane3 = mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ((plane1 != NULL) && (plane2 != NULL) && (plane1->IntersectionLine(plane2, line)))
   {
   mitk::Point3D point;
   if ((plane3 != NULL) && (plane3->IntersectionPoint(line, point)))
   {
   return point;
   }
   }
   // TODO BUG POSITIONTRACKER;
   mitk::Point3D p;
   return p;
   // return m_LastLeftClickPositionSupplier->GetCurrentPoint();
   */
   return mitk::Point3D();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PUBLIC SLOTS
 //////////////////////////////////////////////////////////////////////////
-// TODO: Use widget directly instead of number?
-void QmitkCustomMultiWidget::ShowLevelWindowWidget(unsigned int widgetNumber, bool show)
+void QmitkCustomMultiWidget::ShowLevelWindowWidget(const QString& widgetID, bool show)
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Level window widget can not be shown for an unknown widget.";
+    renderWindowWidget->ShowLevelWindowWidget(show);
     return;
   }
 
-  GetRenderWindowWidget(widgetNumber)->ShowLevelWindowWidget(show);
+  MITK_ERROR << "Level window widget can not be shown for an unknown widget.";
 }
 
-// TODO: Use foreach on widgets map instead of iterator i and "widget number"?
 void QmitkCustomMultiWidget::ShowAllLevelWindowWidgets(bool show)
 {
-  size_t numberOfRenderWindowWidgets = m_RenderWindowWidgets.size();
-  for (size_t i = 0; i < numberOfRenderWindowWidgets; ++i)
+  for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
-    ShowLevelWindowWidget(i, show);
+    renderWindowWidget.second->ShowLevelWindowWidget(show);
   }
 }
 
-void QmitkCustomMultiWidget::SetBackgroundColorGradient(const mitk::Color& upper, const mitk::Color& lower, unsigned int widgetNumber)
+void QmitkCustomMultiWidget::SetBackgroundColorGradient(const mitk::Color& upper, const mitk::Color& lower, const QString& widgetID)
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Background color gradient can not be set for an unknown widget.";
+    renderWindowWidget->SetBackgroundColorGradient(upper, lower);
     return;
   }
 
-  GetRenderWindowWidget(widgetNumber)->SetBackgroundColorGradient(upper, lower);
+  MITK_ERROR << "Background color gradient can not be set for an unknown widget.";
 }
 
 void QmitkCustomMultiWidget::SetAllBackgroundColorGradients(const mitk::Color& upper, const mitk::Color& lower)
 {
-  size_t numberOfRenderWindowWidgets = m_RenderWindowWidgets.size();
-  for (size_t i = 0; i < numberOfRenderWindowWidgets; ++i)
+  for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
-    SetBackgroundColorGradient(upper, lower, i);
+    renderWindowWidget.second->SetBackgroundColorGradient(upper, lower);
   }
 }
 
 void QmitkCustomMultiWidget::FillAllBackgroundColorGradientsWithBlack()
 {
   float black[3] = { 0.0f, 0.0f, 0.0f };
   SetAllBackgroundColorGradients(black, black);
 }
 
-void QmitkCustomMultiWidget::ShowBackgroundColorGradient(unsigned int widgetNumber, bool show)
+void QmitkCustomMultiWidget::ShowBackgroundColorGradient(const QString& widgetID, bool show)
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Background color gradient can not be shown for an unknown widget.";
+    renderWindowWidget->ShowBackgroundColorGradient(show);
     return;
   }
 
-  GetRenderWindowWidget(widgetNumber)->ShowBackgroundColorGradient(show);
+  MITK_ERROR << "Background color gradient can not be shown for an unknown widget.";
 }
 
 void QmitkCustomMultiWidget::ShowAllBackgroundColorGradients(bool show)
 {
-  size_t numberOfRenderWindowWidgets = m_RenderWindowWidgets.size();
-  for (size_t i = 0; i < numberOfRenderWindowWidgets; ++i)
+  for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
-    ShowBackgroundColorGradient(i, show);
+    renderWindowWidget.second->ShowBackgroundColorGradient(show);
   }
 }
 
-std::pair<mitk::Color, mitk::Color> QmitkCustomMultiWidget::GetBackgroundColorGradient(unsigned int widgetNumber) const
+std::pair<mitk::Color, mitk::Color> QmitkCustomMultiWidget::GetBackgroundColorGradient(const QString& widgetID) const
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    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));
+    return renderWindowWidget->GetRendererBackgroundColorGradient();
   }
 
-  return GetRenderWindowWidget(widgetNumber)->GetRendererBackgroundColorGradient();
+  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 QmitkCustomMultiWidget::GetBackgroundColorGradientFlag(unsigned int widgetNumber) const
+bool QmitkCustomMultiWidget::GetBackgroundColorGradientFlag(const QString& widgetID) const
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Background color gradient flag can not be retrieved for an unknown widget. Returning 'false'.";
-    return false;
+    return renderWindowWidget->GetBackgroundColorGradientFlag();
   }
 
-  return GetRenderWindowWidget(widgetNumber)->GetBackgroundColorGradientFlag();
+  MITK_ERROR << "Background color gradient flag can not be retrieved for an unknown widget. Returning 'false'.";
+  return false;
 }
 
 void QmitkCustomMultiWidget::SetDepartmentLogoPath(const char* path)
 {
   /* old
   m_LogoRendering->SetLogoImagePath(path);
   mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
   m_LogoRendering->Update(renderer);
   RequestUpdate();
   */
   /* new
   QImage* qimage = new QImage(path);
   vtkSmartPointer<vtkQImageToImageSource> qImageToVtk;
   qImageToVtk = vtkSmartPointer<vtkQImageToImageSource>::New();
 
   qImageToVtk->SetQImage(qimage);
   qImageToVtk->Update();
 
   m_LogoRendering->SetLogoImage(qImageToVtk->GetOutput());
   mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
   m_LogoRendering->Update(renderer);
   RequestUpdate();
   */
 }
 
-void QmitkCustomMultiWidget::ShowDepartmentLogo(unsigned int widgetNumber, bool show)
+void QmitkCustomMultiWidget::ShowDepartmentLogo(const QString& widgetID, bool show)
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Department logo can not be shown for an unknown widget.";
-    return;
+    GetRenderWindowWidget(widgetID)->ShowDepartmentLogo(show);
+    RequestUpdate(widgetID);
   }
 
-  GetRenderWindowWidget(widgetNumber)->ShowDepartmentLogo(show);
-  RequestUpdate(widgetNumber);
+  MITK_ERROR << "Department logo can not be shown for an unknown widget.";
+  return;
 }
 
 void QmitkCustomMultiWidget::ShowAllDepartmentLogos(bool show)
 {
-  size_t numberOfRenderWindowWidgets = m_RenderWindowWidgets.size();
-  for (size_t i = 0; i < numberOfRenderWindowWidgets; ++i)
+  for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
-    ShowDepartmentLogo(i, show);
+    renderWindowWidget.second->ShowDepartmentLogo(show);
   }
 }
 
-void QmitkCustomMultiWidget::SetDecorationColor(unsigned int widgetNumber, const mitk::Color& color)
+void QmitkCustomMultiWidget::SetDecorationColor(const QString& widgetID, const mitk::Color& color)
 {
-  // #TODO: change specific plane color of a render window widget (parameter: unsigned int planeNumber)?
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Decoration color can not be set for an unknown widget.";
-    return;
+    renderWindowWidget->SetDecorationColor(color);
   }
-  GetRenderWindowWidget(widgetNumber)->SetDecorationColor(color);
+
+  MITK_ERROR << "Decoration color can not be set for an unknown widget.";
 }
 
-mitk::Color QmitkCustomMultiWidget::GetDecorationColor(unsigned int widgetNumber) const
+mitk::Color QmitkCustomMultiWidget::GetDecorationColor(const QString& widgetID) const
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    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);
+    renderWindowWidget->GetDecorationColor();
   }
 
-  return GetRenderWindowWidget(widgetNumber)->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 QmitkCustomMultiWidget::ShowColoredRectangle(unsigned int widgetNumber, bool show)
+void QmitkCustomMultiWidget::ShowColoredRectangle(const QString& widgetID, bool show)
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Colored rectangle can not be set for an unknown widget.";
-    return;
+    renderWindowWidget->ShowColoredRectangle(show);
   }
 
-  GetRenderWindowWidget(widgetNumber)->ShowColoredRectangle(show);
+  MITK_ERROR << "Colored rectangle can not be set for an unknown widget.";
 }
 
 void QmitkCustomMultiWidget::ShowAllColoredRectangles(bool show)
 {
-  size_t numberOfRenderWindowWidgets = m_RenderWindowWidgets.size();
-  for (size_t i = 0; i < numberOfRenderWindowWidgets; ++i)
+  for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
-    ShowColoredRectangle(i, show);
+    renderWindowWidget.second->ShowColoredRectangle(show);
   }
 }
 
-bool QmitkCustomMultiWidget::IsColoredRectangleVisible(unsigned int widgetNumber) const
+bool QmitkCustomMultiWidget::IsColoredRectangleVisible(const QString& widgetID) const
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Colored rectangle visibility can not be retrieved for an unknown widget. Returning 'false'.";
-    return false;
+    renderWindowWidget->IsColoredRectangleVisible();
   }
 
-  return GetRenderWindowWidget(widgetNumber)->IsColoredRectangleVisible();
+  MITK_ERROR << "Colored rectangle visibility can not be retrieved for an unknown widget. Returning 'false'.";
+  return false;
 }
 
-void QmitkCustomMultiWidget::SetCornerAnnotationText(unsigned int widgetNumber, const std::string& cornerAnnotation)
+void QmitkCustomMultiWidget::SetCornerAnnotationText(const QString& widgetID, const std::string& cornerAnnotation)
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Corner annotation text can not be retrieved for an unknown widget.";
-    return;
+    renderWindowWidget->SetCornerAnnotationText(cornerAnnotation);
   }
 
-  GetRenderWindowWidget(widgetNumber)->SetCornerAnnotationText(cornerAnnotation);
+  MITK_ERROR << "Corner annotation text can not be retrieved for an unknown widget.";
 }
 
-std::string QmitkCustomMultiWidget::GetCornerAnnotationText(unsigned int widgetNumber) const
+std::string QmitkCustomMultiWidget::GetCornerAnnotationText(const QString& widgetID) const
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Corner annotation text can not be retrieved for an unknown widget.";
-    return "";
+    renderWindowWidget->GetCornerAnnotationText();
   }
 
-  return GetRenderWindowWidget(widgetNumber)->GetCornerAnnotationText();
+  MITK_ERROR << "Corner annotation text can not be retrieved for an unknown widget.";
+  return "";
 }
 
-void QmitkCustomMultiWidget::ShowCornerAnnotation(unsigned int widgetNumber, bool show)
+void QmitkCustomMultiWidget::ShowCornerAnnotation(const QString& widgetID, bool show)
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Corner annotation can not be set for an unknown widget.";
-    return;
+    renderWindowWidget->ShowCornerAnnotation(show);
   }
 
-  GetRenderWindowWidget(widgetNumber)->ShowCornerAnnotation(show);
+  MITK_ERROR << "Corner annotation can not be set for an unknown widget.";
 }
 
 void QmitkCustomMultiWidget::ShowAllCornerAnnotations(bool show)
 {
-  size_t numberOfRenderWindowWidgets = m_RenderWindowWidgets.size();
-  for (size_t i = 0; i < numberOfRenderWindowWidgets; ++i)
+  for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
-    ShowCornerAnnotation(i, show);
+    renderWindowWidget.second->ShowCornerAnnotation(show);
   }
 }
 
-bool QmitkCustomMultiWidget::IsCornerAnnotationVisible(unsigned int widgetNumber) const
+bool QmitkCustomMultiWidget::IsCornerAnnotationVisible(const QString& widgetID) const
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Corner annotation visibility can not be retrieved for an unknown widget. Returning 'false'.";
-    return false;
+    renderWindowWidget->IsCornerAnnotationVisible();
   }
 
-  return GetRenderWindowWidget(widgetNumber)->IsCornerAnnotationVisible();
+  MITK_ERROR << "Corner annotation visibility can not be retrieved for an unknown widget. Returning 'false'.";
+  return false;
 }
 
 void QmitkCustomMultiWidget::HandleCrosshairPositionEvent()
 {
   /*
   if (!m_PendingCrosshairPositionEvent)
   {
     m_PendingCrosshairPositionEvent = true;
     QTimer::singleShot(0, this, SLOT(HandleCrosshairPositionEventDelayed()));
   }
   */
 }
 
 void QmitkCustomMultiWidget::HandleCrosshairPositionEventDelayed()
 {
   /*
   m_PendingCrosshairPositionEvent = false;
 
   // find image with highest layer
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
 
   mitk::DataNode::Pointer node;
   mitk::DataNode::Pointer topSourceNode;
   mitk::Image::Pointer image;
   bool isBinary = false;
   node = this->GetTopLayerNode(nodes);
   int component = 0;
   if (node.IsNotNull())
   {
     node->GetBoolProperty("binary", isBinary);
     if (isBinary)
     {
       mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = m_DataStorage->GetSources(node, NULL, true);
       if (!sourcenodes->empty())
       {
         topSourceNode = this->GetTopLayerNode(sourcenodes);
       }
       if (topSourceNode.IsNotNull())
       {
         image = dynamic_cast<mitk::Image *>(topSourceNode->GetData());
         topSourceNode->GetIntProperty("Image.Displayed Component", component);
       }
       else
       {
         image = dynamic_cast<mitk::Image *>(node->GetData());
         node->GetIntProperty("Image.Displayed Component", component);
       }
     }
     else
     {
       image = dynamic_cast<mitk::Image *>(node->GetData());
       node->GetIntProperty("Image.Displayed Component", component);
     }
   }
 
   mitk::Point3D crosshairPos = this->GetCrossPosition();
   std::string statusText;
   std::stringstream stream;
   itk::Index<3> p;
   mitk::BaseRenderer *baseRenderer = GetRenderWindow()->GetSliceNavigationController()->GetRenderer();
   unsigned int timestep = baseRenderer->GetTimeStep();
 
   if (image.IsNotNull() && (image->GetTimeSteps() > timestep))
   {
     image->GetGeometry()->WorldToIndex(crosshairPos, p);
     stream.precision(2);
     stream << "Position: <" << std::fixed << crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", "
       << std::fixed << crosshairPos[2] << "> mm";
     stream << "; Index: <" << p[0] << ", " << p[1] << ", " << p[2] << "> ";
 
     mitk::ScalarType pixelValue;
 
     mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess,
       image->GetChannelDescriptor().GetPixelType(),
       image,
       image->GetVolumeData(baseRenderer->GetTimeStep()),
       p,
       pixelValue,
       component);
 
     if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
     {
       stream << "; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific << pixelValue << "  ";
     }
     else
     {
       stream << "; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << pixelValue << "  ";
     }
   }
   else
   {
     stream << "No image information at this position!";
   }
 
   statusText = stream.str();
   mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
   */
 }
 
 void QmitkCustomMultiWidget::Fit()
 {
   // #TODO: what is this function's purpose?
 
   /*
   vtkSmartPointer<vtkRenderer> vtkrenderer;
   size_t numberOfRenderWindowWidgets = m_RenderWindowWidgets.size();
   for (size_t i = 0; i < numberOfRenderWindowWidgets; ++i)
   {
-  vtkRenderer* renderer = GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer();
+  vtkRenderer* renderer = GetRenderWindow(widgetID)->GetRenderer()->GetVtkRenderer();
   mitk::BaseRenderer* baseRenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow(i)->GetRenderWindow());
   vtkrenderer = baseRenderer->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
   vtkrenderer->ResetCamera();
   }
 
   baseRenderer->GetCameraController()->Fit();
   }
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
   vtkObject::SetGlobalWarningDisplay(w);
   */
 }
 
 void QmitkCustomMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
 {
   // #TODO: what is this function's purpose?
 
   /*
   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 QmitkCustomMultiWidget::MoveCrossToPosition(unsigned int widgetNumber, const mitk::Point3D& newPosition)
+void QmitkCustomMultiWidget::MoveCrossToPosition(const QString& widgetID, const mitk::Point3D& newPosition)
 {
-  if (widgetNumber > m_RenderWindowWidgets.size())
+  QmitkRenderWindowWidget* renderWindowWidget = GetRenderWindowWidget(widgetID);
+  if (nullptr != renderWindowWidget)
   {
-    MITK_ERROR << "Geometry plane can not be shown for an unknown widget.";
-    return;
+    GetRenderWindowWidget(widgetID)->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
+    GetRenderWindowWidget(widgetID)->RequestUpdate();
   }
 
-  GetRenderWindowWidget(widgetNumber)->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
-  GetRenderWindowWidget(widgetNumber)->RequestUpdate();
+  MITK_ERROR << "Geometry plane can not be shown for an unknown widget.";
+
 }
 
 void QmitkCustomMultiWidget::ResetCrosshair()
 {
   // #TODO: new concept: we do not want to initialize all views;
   //        we do not want to rely on the geometry planes
   /*
   if (m_DataStorage.IsNotNull())
   {
     m_RenderingManager->InitializeViewsByBoundingObjects(m_DataStorage);
     // m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
     // reset interactor to normal slicing
     SetWidgetPlaneMode(PLANE_MODE_SLICING);
   }
   */
 }
 
 //////////////////////////////////////////////////////////////////////////
 // MOUSE EVENTS
 //////////////////////////////////////////////////////////////////////////
-void QmitkCustomMultiWidget::wheelEvent(QWheelEvent *e)
+void QmitkCustomMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
-void QmitkCustomMultiWidget::mousePressEvent(QMouseEvent *e)
+void QmitkCustomMultiWidget::mousePressEvent(QMouseEvent* e)
 {
 }
 
-void QmitkCustomMultiWidget::moveEvent(QMoveEvent *e)
+void QmitkCustomMultiWidget::moveEvent(QMoveEvent* e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the overlays as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkCustomMultiWidget::InitializeGUI()
 {
   m_CustomMultiWidgetLayout = new QGridLayout(this);
   m_CustomMultiWidgetLayout->setContentsMargins(0, 0, 0, 0);
   setLayout(m_CustomMultiWidgetLayout);
 }
 
 void QmitkCustomMultiWidget::InitializeWidget()
 {
   // #TODO: some things have to be handled globally (hold for all render window (widgets)
   // analyse those things and design a controlling mechanism
 
   // setup the department logo rendering
   /*
   m_LogoRendering = mitk::LogoOverlay::New();
   mitk::BaseRenderer::Pointer renderer4 = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
   m_LogoRendering->SetOpacity(0.5);
   mitk::Point2D offset;
   offset.Fill(0.03);
   m_LogoRendering->SetOffsetVector(offset);
   m_LogoRendering->SetRelativeSize(0.15);
   m_LogoRendering->SetCornerPosition(1);
   m_LogoRendering->SetLogoImagePath("DefaultLogo");
   renderer4->GetOverlayManager()->AddOverlay(m_LogoRendering.GetPointer(), renderer4);
   */
 }
 
 void QmitkCustomMultiWidget::AddRenderWindowWidget()
 {
   // #TODO: add QSplitter?
   // #TODO: include technique, to set the image to level-slide on using the render window manager
 
   // create the render window widget and connect signals / slots
-  QString UID = m_MultiWidgetName + "UID";
+  mitk::UIDGenerator generator;
+  std::string renderWindowUID = generator.GetUID();
+  QString UID = m_MultiWidgetName + "_" + QString::fromStdString(renderWindowUID);
   QmitkRenderWindowWidget* renderWindowWidget = new QmitkRenderWindowWidget(this, UID, m_DataStorage);
 
   // create connections
   connect(renderWindowWidget, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
   connect(renderWindowWidget, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
 
   // store the newly created render window widget with the UID
   m_RenderWindowWidgets.insert(std::pair<QString, QmitkRenderWindowWidget*>(UID, renderWindowWidget));
 
   mitk::SliceNavigationController* sliceNavigationController = renderWindowWidget->GetSliceNavigationController();
   if (nullptr != sliceNavigationController)
   {
     m_TimeNavigationController->ConnectGeometryTimeEvent(sliceNavigationController, false);
     sliceNavigationController->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   }
 
   // #TODO: define the grid cell to add the new render window widget
   // add the newly created render window widget to this multi widget
   m_CustomMultiWidgetLayout->addWidget(renderWindowWidget);
 }
 
 mitk::DataNode::Pointer QmitkCustomMultiWidget::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
 {
   // #TODO: see T24173
   return nodes->front();
 }
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
index be9fa79b73..ced3f61f5e 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
@@ -1,240 +1,240 @@
 /*===================================================================
 
 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 <vtkTextProperty.h>
 
 // qt widgets module
 #include <QmitkCustomMultiWidget.h>
 
 QmitkRenderWindowWidget::QmitkRenderWindowWidget(QWidget* parent/* = nullptr*/, const QString& UID/* = ""*/, mitk::DataStorage* dataStorage/* = nullptr*/)
   : QWidget(parent)
   , m_UID(UID)
   , m_DataStorage(dataStorage)
   , m_RenderWindow(nullptr)
   , m_LevelWindowWidget(nullptr)
 {
   InitializeGUI();
   // TODO: signals / slots
 }
 
 QmitkRenderWindowWidget::~QmitkRenderWindowWidget()
 {
   // nothing here
 }
 
 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
 {
   if (nullptr == m_RenderWindow)
   {
     return nullptr;
   }
 
   return m_RenderWindow->GetSliceNavigationController();
 }
 
 void QmitkRenderWindowWidget::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(m_RenderWindow->GetRenderWindow());
 }
 
 void QmitkRenderWindowWidget::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(m_RenderWindow->GetRenderWindow());
 }
 
 void QmitkRenderWindowWidget::SetBackgroundColorGradient(const mitk::Color& upper, const mitk::Color& lower)
 {
   vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
   if (nullptr == vtkRenderer)
   {
     return;
   }
 
   m_BackgroundColorGradient.first = upper;
   m_BackgroundColorGradient.second = lower;
   vtkRenderer->SetBackground(lower[0], lower[1], lower[2]);
   vtkRenderer->SetBackground2(upper[0], upper[1], upper[2]);
 
   ShowBackgroundColorGradient(true);
 }
 
 void QmitkRenderWindowWidget::ShowBackgroundColorGradient(bool show)
 {
   if (show)
   {
     m_RenderWindow->GetRenderer()->GetVtkRenderer()->GradientBackgroundOn();
   }
   else
   {
     m_RenderWindow->GetRenderer()->GetVtkRenderer()->GradientBackgroundOff();
 
   }
   m_BackgroundColorGradientFlag = show;
 }
 
 void QmitkRenderWindowWidget::ShowLevelWindowWidget(bool show)
 {
   m_LevelWindowWidget->disconnect(this);
   if (show)
   {
     m_LevelWindowWidget->SetDataStorage(m_DataStorage);
     m_LevelWindowWidget->show();
   }
   else
   {
     m_LevelWindowWidget->disconnect(this);
     m_LevelWindowWidget->hide();
   }
 }
 
 void QmitkRenderWindowWidget::ShowDepartmentLogo(bool show)
 {
   m_LogoAnnotation->SetVisibility(show);
 }
 
 void QmitkRenderWindowWidget::SetDecorationColor(const mitk::Color& color)
 {
   m_DecorationColor = color;
   m_RectangleProp->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
   m_CornerAnnotation->GetTextProperty()->SetColor(color[0], color[1], color[2]);
 }
 
 void QmitkRenderWindowWidget::ShowColoredRectangle(bool show)
 {
   m_RectangleProp->SetVisibility(show);
 }
 
 bool QmitkRenderWindowWidget::IsColoredRectangleVisible() const
 {
   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::InitializeGUI()
 {
   m_Layout = new QHBoxLayout(this);
   m_Layout->setMargin(0);
   setLayout(m_Layout);
   setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
   // create render window for this render window widget
   m_RenderingManager = mitk::RenderingManager::GetInstance(); // TODO: do not always use the standard global rendering manager
   m_RenderingMode = mitk::BaseRenderer::RenderingMode::Standard; // TODO: do not always use the standard rendering mode
-  m_RenderWindow = new QmitkRenderWindow(this, "widget - " + m_UID, nullptr, m_RenderingManager, m_RenderingMode);
+  m_RenderWindow = new QmitkRenderWindow(this, m_UID, nullptr, m_RenderingManager, m_RenderingMode);
   m_RenderWindow->SetLayoutIndex(QmitkCustomMultiWidget::SAGITTAL); // TODO: allow to change layout type later
   m_RenderWindow->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
 
   // create level window widget for this render window widget
   m_LevelWindowWidget = new QmitkLevelWindowWidget(this);
   //m_LevelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
   QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
   sizePolicy.setHorizontalStretch(0);
   sizePolicy.setVerticalStretch(0);
   sizePolicy.setHeightForWidth(m_LevelWindowWidget->sizePolicy().hasHeightForWidth());
   m_LevelWindowWidget->setSizePolicy(sizePolicy);
   m_LevelWindowWidget->setMaximumWidth(50);
 
   m_Layout->addWidget(m_RenderWindow);
   m_Layout->addWidget(m_LevelWindowWidget);
 
   // set colors, add logo etc.
   InitializeDecorations();
 
   if (m_RenderingManager == nullptr)
   {
     m_RenderingManager = mitk::RenderingManager::GetInstance();
   }
   m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
 
   // connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(GetRenderWindow()->GetSliceNavigationController(), false);
 
   // reverse connection between sliceNavigationControllers and m_TimeNavigationController
   GetRenderWindow()->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
 }
 
 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 };
   SetBackgroundColorGradient(black, black);
 
   // initialize decoration color, rectangle and annotation text
   float white[3] = { 1.0f, 1.0f, 1.0f };
   m_DecorationColor = white;
   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);
   }
 
   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);
   }
 }
\ No newline at end of file