diff --git a/Modules/AppUtil/src/mitkProvisioningInfo.cpp b/Modules/AppUtil/src/mitkProvisioningInfo.cpp
index 7b5990b3e7..696fe1a621 100644
--- a/Modules/AppUtil/src/mitkProvisioningInfo.cpp
+++ b/Modules/AppUtil/src/mitkProvisioningInfo.cpp
@@ -1,207 +1,207 @@
 /*============================================================================
 
 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 "mitkProvisioningInfo.h"
 
 #include <mitkLog.h>
 
 #include <QCoreApplication>
 #include <QFile>
 #include <QFileInfo>
 #include <QRegularExpression>
 #include <QTextStream>
 
 namespace mitk
 {
 #ifdef CMAKE_INTDIR
   const QString ProvisioningInfo::intermediateOutDir = QString(CMAKE_INTDIR);
 #else
   const QString ProvisioningInfo::intermediateOutDir = QString();
 #endif
 
   ProvisioningInfo::ProvisioningInfo(const QString &file) { this->readProvisioningFile(file); }
-  QStringList ProvisioningInfo::getPluginDirs() const { return pluginDirs.toList(); }
+  QStringList ProvisioningInfo::getPluginDirs() const { return pluginDirs.values(); }
   QList<QUrl> ProvisioningInfo::getPluginsToInstall() const { return pluginsToInstall; }
   QList<QUrl> ProvisioningInfo::getPluginsToStart() const { return pluginsToStart; }
   void ProvisioningInfo::readProvisioningFile(const QString &filePath)
   {
     QFile file(filePath);
     file.open(QFile::ReadOnly);
     QTextStream fileStream(&file);
     QRegularExpression sep("\\s+");
     QString line;
     int count = 1;
     do
     {
       line = fileStream.readLine().trimmed();
       if (!line.isEmpty() && !line.startsWith('#'))
       {
         QString keyword = line.section(sep, 0, 0);
         QString value = line.mid(keyword.size()).trimmed();
         value = substituteKeywords(value);
 
         if (keyword.isEmpty())
         {
           MITK_WARN << "Keyword missing in line " << count << " of provisioning file " << filePath.toStdString();
           continue;
         }
 
         Keyword key = UNKNOWN;
         if (keyword.compare("READ", Qt::CaseInsensitive) == 0)
         {
           key = READ;
         }
         else if (keyword.compare("INSTALL", Qt::CaseInsensitive) == 0)
         {
           key = INSTALL;
         }
         else if (keyword.compare("START", Qt::CaseInsensitive) == 0)
         {
           key = START;
         }
         else if (keyword.compare("STOP", Qt::CaseInsensitive) == 0)
         {
           key = STOP;
         }
 
         if (key == UNKNOWN)
         {
           MITK_WARN << "Keyword " << keyword.toStdString() << " in line " << count << " of provisioning file "
                     << filePath.toStdString() << " unknown";
           continue;
         }
 
         if (value.isEmpty())
         {
           MITK_WARN << "Value after keyword " << keyword.toStdString() << " missing in line " << count
                     << " of provisioning file " << filePath.toStdString();
           continue;
         }
 
         switch (key)
         {
           case READ:
           {
             QUrl readFileUrl(value);
             if (!readFileUrl.isValid())
             {
               MITK_WARN << "The READ URL " << value.toStdString()
                         << "is invalid: " << readFileUrl.errorString().toStdString();
               break;
             }
             this->readProvisioningFile(readFileUrl.toLocalFile());
             break;
           }
           case INSTALL:
           {
             this->addPluginToInstall(value);
             break;
           }
           case START:
           {
             this->addPluginToStart(value);
             break;
           }
           case STOP:
           {
             break;
           }
           case UNKNOWN:
           {
             break; // error handled above
           }
         }
       }
       ++count;
     } while (!line.isNull());
   }
 
   QUrl ProvisioningInfo::addPluginToInstall(const QString &file)
   {
     QUrl pluginUrl(file);
     if (!pluginUrl.isValid())
     {
       MITK_WARN << "The plugin URL " << file.toStdString() << " is invalid:" << pluginUrl.errorString().toStdString();
       return QUrl();
     }
 
     QFileInfo fileInfo(pluginUrl.toLocalFile());
     if (!fileInfo.exists())
     {
       QString fileName = fileInfo.fileName();
       QString filePath = fileInfo.absolutePath();
       if (!intermediateOutDir.isEmpty())
       {
         // search in the intermediate output dir
         QString filePath2 = filePath + "/" + intermediateOutDir;
         fileInfo = QFileInfo(filePath2 + "/" + fileName);
         if (!fileInfo.exists())
         {
           MITK_WARN << "The plugin " << fileName.toStdString() << " was not found in " << filePath.toStdString()
                     << " or " << filePath2.toStdString();
           return QUrl();
         }
         pluginUrl = QUrl::fromLocalFile(fileInfo.canonicalFilePath());
         pluginDirs.insert(fileInfo.canonicalPath());
       }
       else
       {
         MITK_WARN << "The plugin " << fileName.toStdString() << " was not found in " << filePath.toStdString();
         return QUrl();
       }
     }
     else
     {
       pluginDirs.insert(fileInfo.canonicalPath());
     }
 
     pluginsToInstall.append(pluginUrl);
     return pluginUrl;
   }
 
   void ProvisioningInfo::addPluginToStart(const QString &file)
   {
     QUrl pluginUrl = this->addPluginToInstall(file);
     if (!pluginUrl.isEmpty())
     {
       pluginsToStart.append(pluginUrl);
     }
   }
 
   QString ProvisioningInfo::substituteKeywords(const QString &value) const
   {
     QString appPath = QCoreApplication::applicationDirPath();
     if (appPath.endsWith('/'))
     {
       appPath.chop(1);
     }
 
 #ifdef CMAKE_INTDIR
     // Strip the intermediate dir from the application path
     QString intDir(CMAKE_INTDIR);
     if (appPath.endsWith(intDir))
     {
       appPath.chop(intDir.size() + 1);
     }
 #endif
 
 #ifdef _WIN32
     if (value.contains("@EXECUTABLE_DIR") && value.contains("blueberry_osgi"))
     {
       // special case for org_blueberry_osgi in install trees for Windows
       return QString(value).replace("@EXECUTABLE_DIR", appPath, Qt::CaseInsensitive).replace("plugins/", "");
     }
 #endif
 
     return QString(value).replace("@EXECUTABLE_DIR", appPath, Qt::CaseInsensitive);
   }
 }
diff --git a/Modules/Chart/src/mitkChartExampleTestHelper.cpp b/Modules/Chart/src/mitkChartExampleTestHelper.cpp
index 06bebf4bb2..50e8fed921 100644
--- a/Modules/Chart/src/mitkChartExampleTestHelper.cpp
+++ b/Modules/Chart/src/mitkChartExampleTestHelper.cpp
@@ -1,353 +1,353 @@
 /*============================================================================
 
 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 "mitkChartExampleTestHelper.h"
 
 // std includes
 #include <string>
 
 std::unique_ptr<QmitkChartxyData> mitk::ChartExampleTestHelper::GetDataOne()
 {
   auto myDataOne = std::make_unique<QmitkChartxyData>();
 
   std::vector< std::pair<double, double> > data;
 
   for (int i = 0; i < 10; i++)
   {
     data.emplace_back(i, i);
   }
 
   myDataOne->SetData(data);
   myDataOne->SetLabel("DataOne");
   myDataOne->SetChartType("bar");
   myDataOne->SetColor("red");
   myDataOne->SetLineStyle("solid");
 
   return myDataOne;
 }
 
 std::unique_ptr<QmitkChartxyData> mitk::ChartExampleTestHelper::GetDataTwo()
 {
   auto myDataTwo = std::make_unique<QmitkChartxyData>();
 
   std::vector< std::pair<double, double> > data;
 
   for (int i = 10; i < 20; i++)
   {
     data.emplace_back(i, i);
   }
 
   myDataTwo->SetData(data);
   myDataTwo->SetLabel("DataTwo");
   myDataTwo->SetChartType("bar");
   myDataTwo->SetColor("green");
   myDataTwo->SetLineStyle("solid");
 
   return myDataTwo;
 }
 
 std::unique_ptr<QmitkChartxyData> mitk::ChartExampleTestHelper::GetDataThree()
 {
   auto myDataThree = std::make_unique<QmitkChartxyData>();
 
   std::vector< std::pair<double, double> > data;
 
   for (int i = 20; i < 30; i++)
   {
     data.emplace_back(i, i);
   }
 
   myDataThree->SetData(data);
   myDataThree->SetLabel("DataThree");
   myDataThree->SetChartType("bar");
   myDataThree->SetColor("blue");
   myDataThree->SetLineStyle("solid");
 
   return myDataThree;
 }
 
 std::unique_ptr<QmitkChartxyData> mitk::ChartExampleTestHelper::GetDataFour()
 {
   auto myDataFour = std::make_unique<QmitkChartxyData>();
 
   std::vector< std::pair<double, double> > data;
 
   for (int i = 30; i < 40; i++)
   {
     data.emplace_back(i, i);
   }
 
   myDataFour->SetData(data);
   myDataFour->SetLabel("DataFour");
   myDataFour->SetChartType("bar");
   myDataFour->SetColor("yellow");
   myDataFour->SetLineStyle("solid");
 
   return myDataFour;
 }
 
 std::unique_ptr<QmitkChartxyData> mitk::ChartExampleTestHelper::GetDataFive()
 {
   auto myDataFive = std::make_unique<QmitkChartxyData>();
 
   std::vector< std::pair<double, double> > data;
 
   for (int i = 40; i < 50; i++)
   {
     data.emplace_back(i, i);
   }
 
   myDataFive->SetData(data);
   myDataFive->SetLabel("DataFive");
   myDataFive->SetChartType("bar");
   myDataFive->SetColor("black");
   myDataFive->SetLineStyle("solid");
 
   return myDataFive;
 }
 
 QmitkChartWidget::ChartType mitk::ChartExampleTestHelper::ReturnChartTypeByString(std::string chartTypeString)
 {
   if (chartTypeString == "bar")
   {
     return QmitkChartWidget::ChartType::bar;
   }
 
   if (chartTypeString == "line")
   {
     return QmitkChartWidget::ChartType::line;
   }
 
   if (chartTypeString == "spline")
   {
     return QmitkChartWidget::ChartType::spline;
   }
 
   if (chartTypeString == "pie")
   {
     return QmitkChartWidget::ChartType::pie;
   }
 
   if (chartTypeString == "area")
   {
     return QmitkChartWidget::ChartType::area;
   }
 
   if (chartTypeString == "area_spline")
   {
     return QmitkChartWidget::ChartType::area_spline;
   }
 
   if (chartTypeString == "scatter")
   {
     return QmitkChartWidget::ChartType::scatter;
   }
 
   return QmitkChartWidget::ChartType::bar;
 }
 
 QmitkChartWidget::ChartColor mitk::ChartExampleTestHelper::ReturnChartColorByString(std::string chartColorString)
 {
   if (chartColorString == "red")
   {
     return QmitkChartWidget::ChartColor::red;
   }
 
   if (chartColorString == "orange")
   {
     return QmitkChartWidget::ChartColor::orange;
   }
 
   if (chartColorString == "yellow")
   {
     return QmitkChartWidget::ChartColor::yellow;
   }
 
   if (chartColorString == "green")
   {
     return QmitkChartWidget::ChartColor::green;
   }
 
   if (chartColorString == "blue")
   {
     return QmitkChartWidget::ChartColor::blue;
   }
 
   if (chartColorString == "purple")
   {
     return QmitkChartWidget::ChartColor::purple;
   }
 
   if (chartColorString == "brown")
   {
     return QmitkChartWidget::ChartColor::brown;
   }
 
   if (chartColorString == "magenta")
   {
     return QmitkChartWidget::ChartColor::magenta;
   }
 
   if (chartColorString == "tan")
   {
     return QmitkChartWidget::ChartColor::tan;
   }
 
   if (chartColorString == "cyan")
   {
     return QmitkChartWidget::ChartColor::cyan;
   }
 
   if (chartColorString == "olive")
   {
     return QmitkChartWidget::ChartColor::olive;
   }
 
   if (chartColorString == "maroon")
   {
     return QmitkChartWidget::ChartColor::maroon;
   }
 
   if (chartColorString == "navy")
   {
     return QmitkChartWidget::ChartColor::navy;
   }
 
   if (chartColorString == "aquamarine")
   {
     return QmitkChartWidget::ChartColor::aquamarine;
   }
 
   if (chartColorString == "turqouise")
   {
     return QmitkChartWidget::ChartColor::turqouise;
   }
 
   if (chartColorString == "silver")
   {
     return QmitkChartWidget::ChartColor::silver;
   }
 
   if (chartColorString == "lime")
   {
     return QmitkChartWidget::ChartColor::lime;
   }
 
   if (chartColorString == "teal")
   {
     return QmitkChartWidget::ChartColor::teal;
   }
 
   if (chartColorString == "indigo")
   {
     return QmitkChartWidget::ChartColor::indigo;
   }
 
   if (chartColorString == "violet")
   {
     return QmitkChartWidget::ChartColor::violet;
   }
 
   if (chartColorString == "pink")
   {
     return QmitkChartWidget::ChartColor::pink;
   }
 
   if (chartColorString == "black")
   {
     return QmitkChartWidget::ChartColor::black;
   }
 
   if (chartColorString == "white")
   {
     return QmitkChartWidget::ChartColor::white;
   }
 
   if (chartColorString == "grey")
   {
     return QmitkChartWidget::ChartColor::grey;
   }
 
   return QmitkChartWidget::ChartColor::red;
 }
 
 QmitkChartWidget::LineStyle mitk::ChartExampleTestHelper::ReturnChartStyleByString(std::string chartStyleString)
 {
   if (chartStyleString == "solid")
   {
     return QmitkChartWidget::LineStyle::solid;
   }
 
   if (chartStyleString == "dashed")
   {
     return QmitkChartWidget::LineStyle::dashed;
   }
 
   return QmitkChartWidget::LineStyle::solid;
 }
 
 void mitk::ChartExampleTestHelper::Add(int dataSet)
 {
   std::unique_ptr<QmitkChartxyData> myData;
   if (dataSet == 1)
   {
     myData = mitk::ChartExampleTestHelper::GetDataOne();
   }
 
   if (dataSet == 2)
   {
     myData = mitk::ChartExampleTestHelper::GetDataTwo();
   }
 
   if (dataSet == 3)
   {
     myData = mitk::ChartExampleTestHelper::GetDataThree();
   }
 
   if (dataSet == 4)
   {
     myData = mitk::ChartExampleTestHelper::GetDataFour();
   }
 
   if (dataSet == 5)
   {
     myData = mitk::ChartExampleTestHelper::GetDataFive();
   }
 
   std::vector< std::pair<double, double> > data = mitk::ChartExampleTestHelper::ToStdPairList(myData->GetXData(), myData->GetYData());
   auto label = myData->GetLabel().toString().toStdString();
   auto type = myData->GetChartType().toString().toStdString();
   auto color = myData->GetColor().toString().toStdString();
   auto style = myData->GetLineStyle().toString().toStdString();
 
   qmitkChartWidget.AddChartExampleData(data, label, type, color, style);
 }
 
 std::vector< std::pair<double, double> > mitk::ChartExampleTestHelper::ToStdPairList(QVariantList xData, QVariantList yData)
 {
-  auto xDataConverted = xData.toVector().toStdVector();
-  auto yDataConverted = yData.toVector().toStdVector();
+  std::vector<QVariant> xDataConverted(xData.begin(), xData.end());
+  std::vector<QVariant> yDataConverted(yData.begin(), yData.end());
 
   std::vector< std::pair<double, double> > data;
   for (size_t i = 0; i < xDataConverted.size(); i++)
   {
     data.emplace_back(xDataConverted[i].toDouble(), yDataConverted[i].toDouble());
   }
 
   return data;
 }
 
 void mitk::ChartExampleTestHelper::ClearMemory()
 {
   // Clear the vector
   qmitkChartWidget.Clear();
 }
diff --git a/Modules/QtWidgets/src/QmitkDnDDataNodeWidget.cpp b/Modules/QtWidgets/src/QmitkDnDDataNodeWidget.cpp
index 2b48e0e411..4481fcc6b8 100644
--- a/Modules/QtWidgets/src/QmitkDnDDataNodeWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkDnDDataNodeWidget.cpp
@@ -1,69 +1,70 @@
 /*============================================================================
 
 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 <QmitkDnDDataNodeWidget.h>
 
 // mitk qt widgets module
 #include "QmitkMimeTypes.h"
 
 // qt
 #include <QMimeData>
 #include <QDragEnterEvent>
 #include <QDragMoveEvent>
 #include <QDropEvent>
 
 QmitkDnDDataNodeWidget::QmitkDnDDataNodeWidget(QWidget* parent /*= nullptr*/)
   : QFrame(parent)
 {
   this->setAcceptDrops(true);
 }
 
 QmitkDnDDataNodeWidget::~QmitkDnDDataNodeWidget()
 {
   // nothing here
 }
 
 void QmitkDnDDataNodeWidget::dragEnterEvent(QDragEnterEvent* event)
 {
   if (this != event->source())
   {
     event->acceptProposedAction();
   }
   else
   {
     event->ignore();
   }
 }
 
 void QmitkDnDDataNodeWidget::dragMoveEvent(QDragMoveEvent* event)
 {
   if (event->mimeData()->hasFormat(QmitkMimeTypes::DataNodePtrs))
   {
     event->acceptProposedAction();
   }
   else
   {
     event->ignore();
   }
 }
 
 void QmitkDnDDataNodeWidget::dropEvent(QDropEvent* event)
 {
   QList<mitk::DataNode*> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(event->mimeData());
   if (!dataNodeList.empty())
   {
-    emit NodesDropped(dataNodeList.toVector().toStdVector());
+    std::vector<mitk::DataNode*> nodes(dataNodeList.begin(), dataNodeList.end());
+    emit NodesDropped(nodes);
   }
 
   event->acceptProposedAction();
 }
 
diff --git a/Modules/QtWidgets/src/QmitkRenderWindow.cpp b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
index ddb449d628..a478536dc4 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindow.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
@@ -1,515 +1,516 @@
 /*============================================================================
 
 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 "QmitkRenderWindow.h"
 
 #include "mitkInteractionKeyEvent.h"
 #include "mitkInternalEvent.h"
 #include "mitkMouseDoubleClickEvent.h"
 #include "mitkMouseMoveEvent.h"
 #include "mitkMousePressEvent.h"
 #include "mitkMouseReleaseEvent.h"
 #include "mitkMouseWheelEvent.h"
 #include <mitkStatusBar.h>
 
 #include <QCursor>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QKeyEvent>
 #include <QMouseEvent>
 #include <QResizeEvent>
 #include <QSurfaceFormat>
 #include <QTimer>
 #include <QWheelEvent>
 #include <QWindow>
 
 #include <QmitkMimeTypes.h>
 #include <QmitkRenderWindowMenu.h>
 #include <QmitkStyleManager.h>
 
 QmitkRenderWindow::QmitkRenderWindow(QWidget *parent, const QString &name, mitk::VtkPropRenderer *)
   : QVTKOpenGLNativeWidget(parent)
   , m_ResendQtEvents(true)
   , m_MenuWidget(nullptr)
   , m_MenuWidgetActivated(false)
   , m_LayoutIndex(QmitkRenderWindowMenu::LayoutIndex::Axial)
   , m_GeometryViolationWarningOverlay(nullptr)
 {
   m_InternalRenderWindow = vtkSmartPointer<vtkGenericOpenGLRenderWindow>::New();
   m_InternalRenderWindow->SetMultiSamples(0);
   m_InternalRenderWindow->SetAlphaBitPlanes(0);
 
   setRenderWindow(m_InternalRenderWindow);
 
   Initialize(name.toStdString().c_str());
 
   setFocusPolicy(Qt::StrongFocus);
   setMouseTracking(true);
   QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   setSizePolicy(sizePolicy);
 
   // setup overlay widget to show a warning message with a button
   m_GeometryViolationWarningOverlay = new QmitkButtonOverlayWidget(this);
   m_GeometryViolationWarningOverlay->setVisible(false);
   m_GeometryViolationWarningOverlay->SetOverlayText(
     QStringLiteral("<font color=\"red\"><p style=\"text-align:center\">Interaction is not possible because the "
                    "render window geometry<br>does not match the interaction reference geometry.</p></center></font>"));
   m_GeometryViolationWarningOverlay->SetButtonText("Reset geometry");
   m_GeometryViolationWarningOverlay->SetButtonIcon(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/reset.svg")));
 
   connect(m_GeometryViolationWarningOverlay, &QmitkButtonOverlayWidget::Clicked,
           this, &QmitkRenderWindow::ResetGeometry);
 }
 
 QmitkRenderWindow::~QmitkRenderWindow()
 {
   Destroy(); // Destroy mitkRenderWindowBase
 }
 
 void QmitkRenderWindow::SetResendQtEvents(bool resend)
 {
   m_ResendQtEvents = resend;
 }
 
 void QmitkRenderWindow::SetLayoutIndex(QmitkRenderWindowMenu::LayoutIndex layoutIndex)
 {
   m_LayoutIndex = layoutIndex;
   if (nullptr != m_MenuWidget)
   {
     m_MenuWidget->SetLayoutIndex(layoutIndex);
   }
 }
 
 QmitkRenderWindowMenu::LayoutIndex QmitkRenderWindow::GetLayoutIndex()
 {
   if (nullptr != m_MenuWidget)
   {
     return m_MenuWidget->GetLayoutIndex();
   }
   else
   {
     return QmitkRenderWindowMenu::LayoutIndex::Axial;
   }
 }
 
 void QmitkRenderWindow::UpdateLayoutDesignList(QmitkRenderWindowMenu::LayoutDesign layoutDesign)
 {
   if (nullptr != m_MenuWidget)
   {
     m_MenuWidget->UpdateLayoutDesignList(layoutDesign);
   }
 }
 
 void QmitkRenderWindow::UpdateCrosshairVisibility(bool visible)
 {
   m_MenuWidget->UpdateCrosshairVisibility(visible);
 }
 
 void QmitkRenderWindow::UpdateCrosshairRotationMode(int mode)
 {
   m_MenuWidget->UpdateCrosshairRotationMode(mode);
 }
 
 void QmitkRenderWindow::ActivateMenuWidget(bool state)
 {
   if (nullptr == m_MenuWidget)
   {
     m_MenuWidget = new QmitkRenderWindowMenu(this, {}, m_Renderer);
     m_MenuWidget->SetLayoutIndex(m_LayoutIndex);
   }
 
   if (m_MenuWidgetActivated == state)
   {
     // no new state; nothing to do
     return;
   }
 
   m_MenuWidgetActivated = state;
 
   if (m_MenuWidgetActivated)
   {
     connect(m_MenuWidget, &QmitkRenderWindowMenu::LayoutDesignChanged, this, &QmitkRenderWindow::LayoutDesignChanged);
     connect(m_MenuWidget, &QmitkRenderWindowMenu::ResetView, this, &QmitkRenderWindow::ResetView);
     connect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairVisibilityChanged, this, &QmitkRenderWindow::CrosshairVisibilityChanged);
     connect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairRotationModeChanged, this, &QmitkRenderWindow::CrosshairRotationModeChanged);
   }
   else
   {
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::LayoutDesignChanged, this, &QmitkRenderWindow::LayoutDesignChanged);
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::ResetView, this, &QmitkRenderWindow::ResetView);
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairVisibilityChanged, this, &QmitkRenderWindow::CrosshairVisibilityChanged);
     disconnect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairRotationModeChanged, this, &QmitkRenderWindow::CrosshairRotationModeChanged);
 
     m_MenuWidget->hide();
   }
 }
 
 void QmitkRenderWindow::ShowOverlayMessage(bool show)
 {
   m_GeometryViolationWarningOverlay->setVisible(show);
 }
 
 void QmitkRenderWindow::moveEvent(QMoveEvent *event)
 {
   QVTKOpenGLNativeWidget::moveEvent(event);
 
   // after a move the overlays need to be positioned
   emit moved();
 }
 
 void QmitkRenderWindow::showEvent(QShowEvent *event)
 {
   QVTKOpenGLNativeWidget::showEvent(event);
 
   // this singleshot is necessary to have the overlays positioned correctly after initial show
   // simple call of moved() is no use here!!
   QTimer::singleShot(0, this, SIGNAL(moved()));
 }
 
 bool QmitkRenderWindow::event(QEvent* e)
 {
   mitk::InteractionEvent::Pointer mitkEvent = nullptr;
   mitk::Point2D mousePosition;
   bool updateStatusBar = false;
   switch (e->type())
   {
     case QEvent::MouseMove:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mousePosition = this->GetMousePosition(me);
       mitkEvent = mitk::MouseMoveEvent::New(m_Renderer, mousePosition, GetButtonState(me), GetModifiers(me));
       updateStatusBar = true;
       break;
     }
     case QEvent::MouseButtonPress:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mitkEvent = mitk::MousePressEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
       break;
     }
     case QEvent::MouseButtonRelease:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mitkEvent = mitk::MouseReleaseEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
       break;
     }
     case QEvent::MouseButtonDblClick:
     {
       auto me = static_cast<QMouseEvent *>(e);
       mitkEvent = mitk::MouseDoubleClickEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
       break;
     }
     case QEvent::Wheel:
     {
       auto we = static_cast<QWheelEvent *>(e);
       mousePosition = this->GetMousePosition(we);
       mitkEvent = mitk::MouseWheelEvent::New(m_Renderer, mousePosition, GetButtonState(we), GetModifiers(we), GetDelta(we));
       updateStatusBar = true;
       break;
     }
     case QEvent::KeyPress:
     {
       auto ke = static_cast<QKeyEvent*>(e);
       mitkEvent = mitk::InteractionKeyEvent::New(m_Renderer, GetKeyLetter(ke), GetModifiers(ke));
       break;
     }
     case QEvent::Resize:
     {
       if (nullptr != m_MenuWidget)
         m_MenuWidget->MoveWidgetToCorrectPos();
     }
     default:
     {
       break;
     }
   }
 
   if (mitkEvent != nullptr)
   {
     if (this->HandleEvent(mitkEvent.GetPointer())) {
       return m_ResendQtEvents ? false : true;
     }
   }
 
   if (updateStatusBar)
   {
     this->UpdateStatusBar(mousePosition);
   }
 
   return QVTKOpenGLNativeWidget::event(e);
 }
 
 void QmitkRenderWindow::enterEvent(QEvent *e)
 {
   auto* baseRenderer = mitk::BaseRenderer::GetInstance(this->GetVtkRenderWindow());
   this->ShowOverlayMessage(!baseRenderer->GetReferenceGeometryAligned());
 
   if (nullptr != m_MenuWidget)
     m_MenuWidget->ShowMenu();
 
   QVTKOpenGLNativeWidget::enterEvent(e);
 }
 
 void QmitkRenderWindow::leaveEvent(QEvent *e)
 {
   auto statusBar = mitk::StatusBar::GetInstance();
   statusBar->DisplayGreyValueText("");
   this->ShowOverlayMessage(false);
 
   if (nullptr != m_MenuWidget)
     m_MenuWidget->HideMenu();
 
   QVTKOpenGLNativeWidget::leaveEvent(e);
 }
 
 void QmitkRenderWindow::resizeGL(int w, int h)
 {
   QVTKOpenGLNativeWidget::resizeGL(w, h);
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(renderWindow());
 }
 
 void QmitkRenderWindow::dragEnterEvent(QDragEnterEvent *event)
 {
   if (event->mimeData()->hasFormat("application/x-mitk-datanodes"))
   {
     event->accept();
   }
 }
 
 void QmitkRenderWindow::dropEvent(QDropEvent *event)
 {
   QList<mitk::DataNode *> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(event->mimeData());
   if (!dataNodeList.empty())
   {
-    emit NodesDropped(this, dataNodeList.toVector().toStdVector());
+    std::vector dataNodes(dataNodeList.begin(), dataNodeList.end());
+    emit NodesDropped(this, dataNodes);
   }
 }
 
 void QmitkRenderWindow::DeferredHideMenu()
 {
   MITK_DEBUG << "QmitkRenderWindow::DeferredHideMenu";
 
   if (nullptr != m_MenuWidget)
   {
     m_MenuWidget->HideMenu();
   }
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QMouseEvent *me) const
 {
   mitk::Point2D point;
   const auto scale = this->devicePixelRatioF();
   point[0] = me->x()*scale;
   // We need to convert the y component, as the display and vtk have other definitions for the y direction
   point[1] = m_Renderer->GetSizeY() - me->y()*scale;
   return point;
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QWheelEvent *we) const
 {
   mitk::Point2D point;
   const auto scale = this->devicePixelRatioF();
   point[0] = we->x()*scale;
   // We need to convert the y component, as the display and vtk have other definitions for the y direction
   point[1] = m_Renderer->GetSizeY() - we->y()*scale;
   return point;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetEventButton(QMouseEvent *me) const
 {
   mitk::InteractionEvent::MouseButtons eventButton;
   switch (me->button())
   {
   case Qt::LeftButton:
     eventButton = mitk::InteractionEvent::LeftMouseButton;
     break;
   case Qt::RightButton:
     eventButton = mitk::InteractionEvent::RightMouseButton;
     break;
   case Qt::MidButton:
     eventButton = mitk::InteractionEvent::MiddleMouseButton;
     break;
   default:
     eventButton = mitk::InteractionEvent::NoButton;
     break;
   }
   return eventButton;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QMouseEvent *me) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (me->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (me->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (me->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 mitk::InteractionEvent::ModifierKeys QmitkRenderWindow::GetModifiers(QInputEvent *me) const
 {
   mitk::InteractionEvent::ModifierKeys modifiers = mitk::InteractionEvent::NoKey;
 
   if (me->modifiers() & Qt::ALT)
   {
     modifiers = modifiers | mitk::InteractionEvent::AltKey;
   }
   if (me->modifiers() & Qt::CTRL)
   {
     modifiers = modifiers | mitk::InteractionEvent::ControlKey;
   }
   if (me->modifiers() & Qt::SHIFT)
   {
     modifiers = modifiers | mitk::InteractionEvent::ShiftKey;
   }
   return modifiers;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QWheelEvent *we) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (we->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (we->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (we->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 std::string QmitkRenderWindow::GetKeyLetter(QKeyEvent *ke) const
 {
   // Converting Qt Key Event to string element.
   std::string key = "";
   int tkey = ke->key();
   if (tkey < 128)
   { // standard ascii letter
     key = (char)toupper(tkey);
   }
   else
   { // special keys
     switch (tkey)
     {
     case Qt::Key_Return:
       key = mitk::InteractionEvent::KeyReturn;
       break;
     case Qt::Key_Enter:
       key = mitk::InteractionEvent::KeyEnter;
       break;
     case Qt::Key_Escape:
       key = mitk::InteractionEvent::KeyEsc;
       break;
     case Qt::Key_Delete:
       key = mitk::InteractionEvent::KeyDelete;
       break;
     case Qt::Key_Up:
       key = mitk::InteractionEvent::KeyArrowUp;
       break;
     case Qt::Key_Down:
       key = mitk::InteractionEvent::KeyArrowDown;
       break;
     case Qt::Key_Left:
       key = mitk::InteractionEvent::KeyArrowLeft;
       break;
     case Qt::Key_Right:
       key = mitk::InteractionEvent::KeyArrowRight;
       break;
 
     case Qt::Key_F1:
       key = mitk::InteractionEvent::KeyF1;
       break;
     case Qt::Key_F2:
       key = mitk::InteractionEvent::KeyF2;
       break;
     case Qt::Key_F3:
       key = mitk::InteractionEvent::KeyF3;
       break;
     case Qt::Key_F4:
       key = mitk::InteractionEvent::KeyF4;
       break;
     case Qt::Key_F5:
       key = mitk::InteractionEvent::KeyF5;
       break;
     case Qt::Key_F6:
       key = mitk::InteractionEvent::KeyF6;
       break;
     case Qt::Key_F7:
       key = mitk::InteractionEvent::KeyF7;
       break;
     case Qt::Key_F8:
       key = mitk::InteractionEvent::KeyF8;
       break;
     case Qt::Key_F9:
       key = mitk::InteractionEvent::KeyF9;
       break;
     case Qt::Key_F10:
       key = mitk::InteractionEvent::KeyF10;
       break;
     case Qt::Key_F11:
       key = mitk::InteractionEvent::KeyF11;
       break;
     case Qt::Key_F12:
       key = mitk::InteractionEvent::KeyF12;
       break;
 
     case Qt::Key_End:
       key = mitk::InteractionEvent::KeyEnd;
       break;
     case Qt::Key_Home:
       key = mitk::InteractionEvent::KeyPos1;
       break;
     case Qt::Key_Insert:
       key = mitk::InteractionEvent::KeyInsert;
       break;
     case Qt::Key_PageDown:
       key = mitk::InteractionEvent::KeyPageDown;
       break;
     case Qt::Key_PageUp:
       key = mitk::InteractionEvent::KeyPageUp;
       break;
     case Qt::Key_Space:
       key = mitk::InteractionEvent::KeySpace;
       break;
     }
   }
   return key;
 }
 
 int QmitkRenderWindow::GetDelta(QWheelEvent *we) const
 {
   return we->delta();
 }
 
 void QmitkRenderWindow::UpdateStatusBar(mitk::Point2D pointerPositionOnScreen)
 {
   mitk::Point3D worldPosition;
   m_Renderer->ForceImmediateUpdate();
   m_Renderer->DisplayToWorld(pointerPositionOnScreen, worldPosition);
   auto statusBar = mitk::StatusBar::GetInstance();
   statusBar->DisplayRendererInfo(worldPosition, m_Renderer->GetTime());
 }
diff --git a/Plugins/org.blueberry.core.runtime/src/dynamichelpers/berryExtensionTracker.cpp b/Plugins/org.blueberry.core.runtime/src/dynamichelpers/berryExtensionTracker.cpp
index 516f9f51e7..ffae990899 100644
--- a/Plugins/org.blueberry.core.runtime/src/dynamichelpers/berryExtensionTracker.cpp
+++ b/Plugins/org.blueberry.core.runtime/src/dynamichelpers/berryExtensionTracker.cpp
@@ -1,330 +1,330 @@
 /*============================================================================
 
 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 "berryExtensionTracker.h"
 
 #include <berryIExtension.h>
 #include <berryIExtensionPoint.h>
 #include <berryIExtensionPointFilter.h>
 #include <berryIExtensionRegistry.h>
 #include <berryIExtensionChangeHandler.h>
 #include <berryIRegistryEventListener.h>
 #include <berryListenerList.h>
 #include <berryLog.h>
 #include "internal/berrySimpleExtensionPointFilter.h"
 #include <berryPlatform.h>
 
 #include <QSet>
 #include <QHash>
 #include <QMutex>
 
 namespace berry {
 
 struct ExtensionTracker::Impl
 {
   struct HandlerWrapper;
 
   ExtensionTracker* const q;
   QHash<IExtension::Pointer, QSet<Object::Pointer> > extensionToStrongObjects;
   QHash<IExtension::Pointer, QSet<Object::WeakPtr> > extensionToWeakObjects;
   //ListenerList<HandlerWrapper> handlers;
   QHash<IExtensionChangeHandler*, HandlerWrapper*> handlerToWrapper;
   QMutex mutex;
   bool closed;
   IExtensionRegistry* registry; // the registry that this tacker works with
 
   Impl(ExtensionTracker* q, IExtensionRegistry* theRegistry)
     : q(q)
     , closed(false)
     , registry(theRegistry)
   {}
 
 };
 
 struct ExtensionTracker::Impl::HandlerWrapper : public IRegistryEventListener
 {
   ExtensionTracker* const q;
   IExtensionChangeHandler* const handler;
 
   HandlerWrapper(ExtensionTracker* q, IExtensionChangeHandler* handler)
     : q(q)
     , handler(handler)
   {}
 
   bool operator==(const HandlerWrapper& target) const
   {
     return handler == target.handler;
   }
 
   void Added(const QList<IExtension::Pointer>& extensions) override
   {
     for (int i = 0; i < extensions.size(); ++i)
     {
       q->ApplyAdd(handler, extensions[i]);
     }
   }
 
   void Removed(const QList<IExtension::Pointer>& extensions) override
   {
     QList<QList<Object::Pointer> > removedObjects;
     {
       QMutexLocker lock(&q->d->mutex);
       for (int i = 0; i < extensions.size(); ++i)
       {
         QSet<Object::Pointer> associatedObjects = q->d->extensionToStrongObjects.take(extensions[i]);
         foreach(const Object::WeakPtr& ptr, q->d->extensionToWeakObjects.take(extensions[i]))
         {
           if (!ptr.Expired())
           {
             associatedObjects.insert(ptr.Lock());
           }
         }
-        removedObjects.push_back(associatedObjects.toList());
+        removedObjects.push_back(associatedObjects.values());
       }
     }
     for (int i = 0; i < extensions.size(); ++i)
     {
       q->ApplyRemove(handler, extensions[i], removedObjects[i]);
     }
   }
 
   void Added(const QList<IExtensionPoint::Pointer>& /*extensionPoints*/) override
   {
     // do nothing
   }
 
   void Removed(const QList<IExtensionPoint::Pointer>& /*extensionPoints*/) override
   {
     // do nothing
   }
 };
 
 ExtensionTracker::ExtensionTracker()
 {
   this->Init(Platform::GetExtensionRegistry());
 }
 
 ExtensionTracker::~ExtensionTracker()
 {
 }
 
 ExtensionTracker::ExtensionTracker(IExtensionRegistry* theRegistry)
   : d()
 {
   this->Init(theRegistry);
 }
 
 void ExtensionTracker::Init(IExtensionRegistry* registry)
 {
   d.reset(new Impl(this, registry));
   if (registry == nullptr)
   {
     //RuntimeLog.log(new Status(IStatus.ERROR, RegistryMessages.OWNER_NAME, 0, RegistryMessages.registry_no_default, null));
     BERRY_ERROR << "Extension tracker was unable to obtain BlueBerry extension registry.";
     d->closed = true;
   }
 }
 
 void ExtensionTracker::RegisterHandler(IExtensionChangeHandler* handler, const IExtensionPointFilter& filter)
 {
   QMutexLocker lock(&d->mutex);
   if (d->closed) return;
   auto iter = d->handlerToWrapper.insert(handler, new Impl::HandlerWrapper(this, handler));
   d->registry->AddListener(iter.value(), filter);
 }
 
 void ExtensionTracker::RegisterHandler(IExtensionChangeHandler* handler, const QString& extensionPointId)
 {
   this->RegisterHandler(handler, extensionPointId.isEmpty() ? IExtensionPointFilter(nullptr)
                                                             : IExtensionPointFilter(new SimpleExtensionPointFilter(extensionPointId)));
 }
 
 void ExtensionTracker::UnregisterHandler(IExtensionChangeHandler* handler)
 {
   QMutexLocker lock(&d->mutex);
   if (d->closed) return;
   IRegistryEventListener* listener = d->handlerToWrapper.take(handler);
   d->registry->RemoveListener(listener);
   delete listener;
 }
 
 void ExtensionTracker::RegisterObject(const SmartPointer<IExtension>& element, const SmartPointer<Object>& object, IExtensionTracker::ReferenceType referenceType)
 {
   if (element.IsNull() || object.IsNull()) return;
 
   QMutexLocker lock(&d->mutex);
   if (d->closed) return;
 
   if (referenceType == REF_STRONG)
   {
     d->extensionToStrongObjects[element].insert(object);
   }
   else if (referenceType == REF_WEAK)
   {
     d->extensionToWeakObjects[element].insert(Object::WeakPtr(object));
   }
 }
 
 QList<SmartPointer<Object> > ExtensionTracker::GetObjects(const IExtension::Pointer& element) const
 {
   QSet<Object::Pointer> objectSet;
 
   QMutexLocker lock(&d->mutex);
-  if (d->closed) return objectSet.toList();
+  if (d->closed) return objectSet.values();
 
   auto iter = d->extensionToStrongObjects.find(element);
   if (iter != d->extensionToStrongObjects.end())
   {
     objectSet.unite(iter.value());
   }
   auto iter2 = d->extensionToWeakObjects.find(element);
   if (iter2 != d->extensionToWeakObjects.end())
   {
     foreach(const Object::WeakPtr& ptr, iter2.value())
     {
       if (!ptr.Expired()) objectSet.insert(ptr.Lock());
     }
   }
-  return objectSet.toList();
+  return objectSet.values();
 }
 
 void ExtensionTracker::Close()
 {
   QMutexLocker lock(&d->mutex);
   if (d->closed) return;
   foreach(Impl::HandlerWrapper* wrapper, d->handlerToWrapper.values())
   {
     d->registry->RemoveListener(wrapper);
     delete wrapper;
   }
   d->extensionToStrongObjects.clear();
   d->extensionToWeakObjects.clear();
   d->handlerToWrapper.clear();
 
   d->closed = true;
 }
 
 void ExtensionTracker::UnregisterObject(const SmartPointer<IExtension>& extension, const SmartPointer<Object>& object)
 {
   QMutexLocker lock(&d->mutex);
   if (d->closed) return;
 
   auto iter = d->extensionToStrongObjects.find(extension);
   if (iter != d->extensionToStrongObjects.end())
   {
     iter.value().remove(object);
   }
   auto iter2 = d->extensionToWeakObjects.find(extension);
   if (iter2 != d->extensionToWeakObjects.end())
   {
     iter2.value().remove(Object::WeakPtr(object));
   }
 }
 
 QList<SmartPointer<Object> > ExtensionTracker::UnregisterObject(const SmartPointer<IExtension>& extension)
 {
   QSet<Object::Pointer> objectSet;
 
   QMutexLocker lock(&d->mutex);
-  if (d->closed) return objectSet.toList();
+  if (d->closed) return objectSet.values();
 
   auto iter = d->extensionToStrongObjects.find(extension);
   if (iter != d->extensionToStrongObjects.end())
   {
     objectSet.unite(iter.value());
     d->extensionToStrongObjects.erase(iter);
   }
   auto iter2 = d->extensionToWeakObjects.find(extension);
   if (iter2 != d->extensionToWeakObjects.end())
   {
     foreach(const Object::WeakPtr& ptr, iter2.value())
     {
       if (!ptr.Expired()) objectSet.insert(ptr.Lock());
     }
     d->extensionToWeakObjects.erase(iter2);
   }
 
-  return objectSet.toList();
+  return objectSet.values();
 }
 
 IExtensionPointFilter ExtensionTracker::CreateExtensionPointFilter(const SmartPointer<IExtensionPoint>& xpt)
 {
   struct F : IExtensionPointFilter::Concept {
     const IExtensionPoint::Pointer m_Xpt;
 
     F(const IExtensionPoint::Pointer& xp)
       : m_Xpt(xp)
     {}
 
     bool Matches(const IExtensionPoint* target) const override
     {
       return m_Xpt == target;
     }
   };
 
   return IExtensionPointFilter(new F(xpt));
 }
 
 IExtensionPointFilter ExtensionTracker::CreateExtensionPointFilter(const QList<SmartPointer<IExtensionPoint> >& xpts)
 {
   struct F : IExtensionPointFilter::Concept {
     const QList<IExtensionPoint::Pointer> m_Xpts;
 
     F(const QList<IExtensionPoint::Pointer>& xps)
       : m_Xpts(xps)
     {}
 
     bool Matches(const IExtensionPoint* target) const override
     {
       for (int i = 0; i < m_Xpts.size(); i++)
       {
         if (m_Xpts[i] == target)
         {
           return true;
         }
       }
       return false;
     }
   };
 
   return IExtensionPointFilter(new F(xpts));
 }
 
 IExtensionPointFilter ExtensionTracker::CreateNamespaceFilter(const QString& id)
 {
   struct F : IExtensionPointFilter::Concept {
     const QString m_Id;
 
     F(const QString& id)
       : m_Id(id)
     {}
 
     bool Matches(const IExtensionPoint* target) const override
     {
       return m_Id == target->GetNamespaceIdentifier();
     }
   };
 
   return IExtensionPointFilter(new F(id));
 }
 
 void ExtensionTracker::ApplyAdd(IExtensionChangeHandler* handler, const SmartPointer<IExtension>& extension)
 {
   handler->AddExtension(this, extension);
 }
 
 void ExtensionTracker::ApplyRemove(IExtensionChangeHandler* handler, const SmartPointer<IExtension>& removedExtension, const QList<Object::Pointer>& removedObjects)
 {
   handler->RemoveExtension(removedExtension, removedObjects);
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryCommandService.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryCommandService.cpp
index 889118ab0a..b23926e210 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryCommandService.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryCommandService.cpp
@@ -1,313 +1,313 @@
 /*============================================================================
 
 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 "berryCommandService.h"
 
 #include <berryCommand.h>
 #include <berryCommandManager.h>
 #include <berryCommandCategory.h>
 #include <berryParameterizedCommand.h>
 #include <berryUIElement.h>
 
 #include "berryPersistentState.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryElementReference.h"
 
 #include <berryIHandler.h>
 #include <berryIElementUpdater.h>
 #include <berryIElementReference.h>
 #include <berryISafeRunnable.h>
 #include <berrySafeRunner.h>
 #include <berryObjectString.h>
 
 #include <QStringList>
 
 namespace berry {
 
 const std::string CommandService::PREFERENCE_KEY_PREFIX = "org.blueberry.ui.commands/state";
 
 std::string CommandService::CreatePreferenceKey(const SmartPointer<Command>& command,
                                                 const QString& stateId)
 {
   return PREFERENCE_KEY_PREFIX + '/' + command->GetId().toStdString() + '/' + stateId.toStdString();
 }
 
 CommandService::CommandService( CommandManager* commandManager)
   : commandManager(commandManager)
   , commandPersistence(this)
 {
   if (commandManager == nullptr)
   {
     throw std::invalid_argument("Cannot create a command service with a null manager");
   }
 }
 
 CommandService::~CommandService()
 {
   this->Dispose();
 }
 
 void CommandService::AddExecutionListener(IExecutionListener* listener)
 {
   commandManager->AddExecutionListener(listener);
 }
 
 void CommandService::DefineUncategorizedCategory(const QString& name,
                                  const QString& description)
 {
   commandManager->DefineUncategorizedCategory(name, description);
 }
 
 SmartPointer<ParameterizedCommand> CommandService::Deserialize(const QString& serializedParameterizedCommand) const
 {
   return commandManager->Deserialize(serializedParameterizedCommand);
 }
 
 void CommandService::Dispose()
 {
   /*
    * All state on all commands needs to be disposed. This is so that the
    * state has a chance to persist any changes.
    */
   const QList<Command::Pointer> commands = commandManager->GetAllCommands();
   foreach (const Command::Pointer& command, commands)
   {
     const QList<QString> stateIds = command->GetStateIds();
     foreach(const QString& stateId, stateIds)
     {
       const State::Pointer state = command->GetState(stateId);
       if (PersistentState::Pointer persistentState = state.Cast<PersistentState>())
       {
         if (persistentState->ShouldPersist())
         {
           persistentState->Save(WorkbenchPlugin::GetDefault()->GetPreferences(),
                                 CreatePreferenceKey(command, stateId));
         }
       }
     }
   }
   commandCallbacks.clear();
 }
 
 SmartPointer<CommandCategory> CommandService::GetCategory(const QString& categoryId) const
 {
   return commandManager->GetCategory(categoryId);
 }
 
 SmartPointer<Command> CommandService::GetCommand(const QString& commandId) const
 {
   return commandManager->GetCommand(commandId);
 }
 
 QList<SmartPointer<CommandCategory> > CommandService::GetDefinedCategories() const
 {
   return commandManager->GetDefinedCategories();
 }
 
 QStringList CommandService::GetDefinedCategoryIds() const
 {
-  return commandManager->GetDefinedCategoryIds().toList();
+  return commandManager->GetDefinedCategoryIds().values();
 }
 
 QStringList CommandService::GetDefinedCommandIds() const
 {
-  return commandManager->GetDefinedCommandIds().toList();
+  return commandManager->GetDefinedCommandIds().values();
 }
 
 QList<SmartPointer<Command> > CommandService::GetDefinedCommands() const
 {
   return commandManager->GetDefinedCommands();
 }
 
 QStringList CommandService::GetDefinedParameterTypeIds() const
 {
-  return commandManager->GetDefinedParameterTypeIds().toList();
+  return commandManager->GetDefinedParameterTypeIds().values();
 }
 
 QList<SmartPointer<ParameterType> > CommandService::GetDefinedParameterTypes() const
 {
   return commandManager->GetDefinedParameterTypes();
 }
 
 QString CommandService::GetHelpContextId(const SmartPointer<const Command>& command) const
 {
   return commandManager->GetHelpContextId(command);
 }
 
 QString CommandService::GetHelpContextId(const QString& commandId) const
 {
   Command::Pointer command = GetCommand(commandId);
   return commandManager->GetHelpContextId(command);
 }
 
 SmartPointer<ParameterType> CommandService::GetParameterType(const QString& parameterTypeId) const
 {
   return commandManager->GetParameterType(parameterTypeId);
 }
 
 void CommandService::ReadRegistry()
 {
   commandPersistence.Read();
 }
 
 void CommandService::RemoveExecutionListener(IExecutionListener* listener)
 {
   commandManager->RemoveExecutionListener(listener);
 }
 
 void CommandService::SetHelpContextId(const SmartPointer<IHandler>& handler,
                       const QString& helpContextId)
 {
   commandManager->SetHelpContextId(handler, helpContextId);
 }
 
 void CommandService::RefreshElements(const QString& commandId,
                      const QHash<QString, Object::Pointer>&  filter)
 {
   Command::Pointer cmd = GetCommand(commandId);
 
   if (!cmd->IsDefined() || !(cmd->GetHandler().Cast<IElementUpdater>()))
   {
     return;
   }
   IElementUpdater::Pointer updater = cmd->GetHandler().Cast<IElementUpdater>();
 
   if (commandCallbacks.isEmpty())
   {
     return;
   }
 
   if(!commandCallbacks.contains(commandId))
   {
     return;
   }
 
   foreach (IElementReference::Pointer callbackRef, commandCallbacks[commandId])
   {
     struct _SafeRunnable : public ISafeRunnable
     {
       IElementUpdater* updater;
       IElementReference* callbackRef;
 
       _SafeRunnable(IElementUpdater* updater, IElementReference* callbackRef)
         : updater(updater), callbackRef(callbackRef)
       {}
 
       void HandleException(const ctkException& exc) override
       {
         WorkbenchPlugin::Log(QString("Failed to update callback: ") +
                              callbackRef->GetCommandId() + exc.what());
       }
 
       void Run() override
       {
         updater->UpdateElement(callbackRef->GetElement().GetPointer(), callbackRef->GetParameters());
       }
     };
 
     QHash<QString,Object::Pointer> parms = callbackRef->GetParameters();
 
     ISafeRunnable::Pointer run(new _SafeRunnable(updater.GetPointer(), callbackRef.GetPointer()));
     if (filter.isEmpty())
     {
       SafeRunner::Run(run);
     }
     else
     {
       bool match = true;
       QHashIterator<QString, Object::Pointer> i(filter);
       while (i.hasNext())
       {
         i.next();
         Object::Pointer value = parms[i.key()];
         if (i.value() != value)
         {
           match = false;
           break;
         }
       }
       if (match)
       {
         SafeRunner::Run(run);
       }
     }
   }
 }
 
 SmartPointer<IElementReference> CommandService::RegisterElementForCommand(
     const SmartPointer<ParameterizedCommand>& command,
     const SmartPointer<UIElement>& element)
 {
   if (!command->GetCommand()->IsDefined())
   {
     throw NotDefinedException(
         "Cannot define a callback for undefined command "
             + command->GetCommand()->GetId());
   }
   if (element.IsNull())
   {
     throw NotDefinedException("No callback defined for command "
         + command->GetCommand()->GetId());
   }
 
   QHash<QString, QString> paramMap = command->GetParameterMap();
   QHash<QString, Object::Pointer> parms;
   for (QHash<QString, QString>::const_iterator i = paramMap.begin();
        i != paramMap.end(); ++i)
   {
     Object::Pointer value(new ObjectString(i.value()));
     parms.insert(i.key(), value);
   }
   IElementReference::Pointer ref(new ElementReference(command->GetId(),
                                                       element, parms));
   RegisterElement(ref);
   return ref;
 }
 
 void CommandService::RegisterElement(const SmartPointer<IElementReference>& elementReference)
 {
   QList<IElementReference::Pointer>& parameterizedCommands = commandCallbacks[elementReference->GetCommandId()];
   parameterizedCommands.push_back(elementReference);
 
   // If the active handler wants to update the callback, it can do
   // so now
   Command::Pointer command = GetCommand(elementReference->GetCommandId());
   if (command->IsDefined())
   {
     if (IElementUpdater::Pointer updater = command->GetHandler().Cast<IElementUpdater>())
     {
       updater->UpdateElement(elementReference->GetElement().GetPointer(),
                              elementReference->GetParameters());
     }
   }
 }
 
 void CommandService::UnregisterElement(const SmartPointer<IElementReference>& elementReference)
 {
   if (commandCallbacks.contains(elementReference->GetCommandId()))
   {
     QList<IElementReference::Pointer>& parameterizedCommands = commandCallbacks[elementReference->GetCommandId()];
     parameterizedCommands.removeAll(elementReference);
     if (parameterizedCommands.isEmpty())
     {
       commandCallbacks.remove(elementReference->GetCommandId());
     }
   }
 }
 
 const CommandPersistence* CommandService::GetCommandPersistence() const
 {
   return &commandPersistence;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryEditorRegistry.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryEditorRegistry.cpp
index c4c35cbdda..920abd7639 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryEditorRegistry.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryEditorRegistry.cpp
@@ -1,1295 +1,1295 @@
 /*============================================================================
 
 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 "berryEditorRegistry.h"
 
 #include "berryWorkbenchPlugin.h"
 #include "berryEditorRegistryReader.h"
 #include "berryWorkbenchRegistryConstants.h"
 
 namespace berry
 {
 
 const QString EditorRegistry::EMPTY_EDITOR_ID =
     "org.blueberry.ui.internal.emptyEditorTab";
 
 QHash<QString, FileEditorMapping::Pointer>
     EditorRegistry::EditorMap::defaultMap;
 
 QHash<QString, FileEditorMapping::Pointer> EditorRegistry::EditorMap::map;
 
 EditorRegistry::RelatedRegistry::RelatedRegistry(EditorRegistry* reg) :
   editorRegistry(reg)
 {
 
 }
 
 QList<IEditorDescriptor::Pointer> EditorRegistry::RelatedRegistry::GetRelatedObjects(
     const QString& fileName)
 {
   IFileEditorMapping::Pointer mapping = editorRegistry->GetMappingFor(fileName);
   if (mapping.IsNull())
   {
     return QList<IEditorDescriptor::Pointer>();
   }
 
   return mapping->GetEditors();
 }
 
 EditorRegistry::EditorRegistry() :
   relatedRegistry(this)
 {
   this->InitialIdToEditorMap(mapIDtoEditor);
   this->InitializeFromStorage();
   //IExtensionTracker tracker = PlatformUI.getWorkbench().getExtensionTracker();
   //tracker.registerHandler(this,
   //    ExtensionTracker.createExtensionPointFilter(getExtensionPointFilter()));
 }
 
 void EditorRegistry::AddEditorFromPlugin(EditorDescriptor::Pointer editor,
     const QList<QString>& extensions,
     const QList<QString>& filenames,
     const QList<QString>&  /*contentTypeVector*/, bool bDefault)
 {
 
   //PlatformUI.getWorkbench().getExtensionTracker().registerObject(editor.getConfigurationElement().getDeclaringExtension(), editor, IExtensionTracker.REF_WEAK);
   // record it in our quick reference list
   sortedEditorsFromPlugins.push_back(editor);
 
   // add it to the table of mappings
   for (QList<QString>::const_iterator itr = extensions.begin(); itr
       != extensions.end(); ++itr)
   {
     QString fileExtension = *itr;
 
     if (!fileExtension.isEmpty())
     {
       FileEditorMapping::Pointer mapping = this->GetMappingFor("*." + fileExtension);
       if (mapping.IsNull())
       { // no mapping for that extension
         mapping = new FileEditorMapping(fileExtension);
         typeEditorMappings.PutDefault(this->MappingKeyFor(mapping), mapping);
       }
       mapping->AddEditor(editor);
       if (bDefault)
       {
         mapping->SetDefaultEditor(editor);
       }
     }
   }
 
   // add it to the table of mappings
   for (QList<QString>::const_iterator itr = filenames.begin(); itr
       != filenames.end(); ++itr)
   {
     QString filename = *itr;
 
     if (!filename.isEmpty())
     {
       FileEditorMapping::Pointer mapping = this->GetMappingFor(filename);
       if (mapping.IsNull())
       { // no mapping for that extension
         QString name;
         QString extension;
         int index = filename.indexOf('.');
         if (index == -1)
         {
           name = filename;
           extension = "";
         }
         else
         {
           name = filename.left(index);
           extension = filename.mid(index + 1);
         }
         mapping = new FileEditorMapping(name, extension);
         typeEditorMappings.PutDefault(this->MappingKeyFor(mapping), mapping);
       }
       mapping->AddEditor(editor);
       if (bDefault)
       {
         mapping->SetDefaultEditor(editor);
       }
     }
   }
 
   //  for (QList<QString>::const_iterator itr = contentTypeVector.begin();
   //         itr != contentTypeVector.end(); ++itr)
   //  {
   //    QString contentTypeId = *itr;
   //    if (!contentTypeId.empty())
   //    {
   //      IContentType contentType = Platform.getContentTypeManager().getContentType(contentTypeId);
   //      if (contentType != null)
   //      {
   //        IEditorDescriptor [] editorArray = (IEditorDescriptor[]) contentTypeToEditorMappings.get(contentType);
   //        if (editorArray == null)
   //        {
   //          editorArray = new IEditorDescriptor[]
   //          { editor};
   //          contentTypeToEditorMappings.put(contentType, editorArray);
   //        }
   //        else
   //        {
   //          IEditorDescriptor [] newArray = new IEditorDescriptor[editorArray.length + 1];
   //          if (bDefault)
   //          { // default editors go to the front of the line
   //            newArray[0] = editor;
   //            System.arraycopy(editorArray, 0, newArray, 1, editorArray.length);
   //          }
   //          else
   //          {
   //            newArray[editorArray.length] = editor;
   //            System.arraycopy(editorArray, 0, newArray, 0, editorArray.length);
   //          }
   //          contentTypeToEditorMappings.put(contentType, newArray);
   //        }
   //      }
   //    }
   //  }
 
   // Update editor map.
   mapIDtoEditor[editor->GetId()] = editor;
 }
 
 void EditorRegistry::AddExternalEditorsToEditorMap()
 {
   // Add registered editors (may include external editors).
   QList<FileEditorMapping::Pointer> maps =
       typeEditorMappings.AllMappings();
   for (int i = 0; i < maps.size(); ++i)
   {
     FileEditorMapping::Pointer map = maps[i];
     QList<IEditorDescriptor::Pointer> descArray = map->GetEditors();
     for (QList<IEditorDescriptor::Pointer>::iterator itr =
         descArray.begin(); itr != descArray.end(); ++itr)
     {
       mapIDtoEditor[(*itr)->GetId()] = itr->Cast<EditorDescriptor> ();
     }
   }
 }
 
 IEditorDescriptor::Pointer EditorRegistry::FindEditor(const QString& id)
 {
   return mapIDtoEditor[id];
 }
 
 IEditorDescriptor::Pointer EditorRegistry::GetDefaultEditor()
 {
   // the default editor will always be the system external editor
   // this should never return null
   return this->FindEditor(IEditorRegistry::SYSTEM_EXTERNAL_EDITOR_ID);
 }
 
 IEditorDescriptor::Pointer EditorRegistry::GetDefaultEditor(
     const QString& fileName)
 {
   //return this->GetDefaultEditor(filename, guessAtContentType(filename));
   return this->GetEditorForContentType(fileName /*, contentType*/);
 }
 
 IEditorDescriptor::Pointer EditorRegistry::GetEditorForContentType(
     const QString& filename
 /*IContentType contentType*/)
 {
   IEditorDescriptor::Pointer desc;
   ;
   QList<IEditorDescriptor::Pointer> contentTypeResults =
       this->FindRelatedObjects(/*contentType,*/filename, relatedRegistry);
   if (contentTypeResults.size() > 0)
   {
     desc = contentTypeResults.front();
   }
   return desc;
 }
 
 QList<IEditorDescriptor::Pointer> EditorRegistry::FindRelatedObjects(
     /*IContentType type,*/const QString& fileName,
     RelatedRegistry&  /*registry*/)
 {
   QList<IEditorDescriptor::Pointer> allRelated;
   QList<IEditorDescriptor::Pointer> nonDefaultFileEditors;
   QList<IEditorDescriptor::Pointer> related;
 
   if (!fileName.isEmpty())
   {
     FileEditorMapping::Pointer mapping = this->GetMappingFor(fileName);
     if (!mapping.IsNull())
     {
       // backwards compatibility - add editors flagged as "default"
       related = mapping->GetDeclaredDefaultEditors();
       for (QList<IEditorDescriptor::Pointer>::iterator itr =
           related.begin(); itr != related.end(); ++itr)
       {
         // we don't want to return duplicates
         if (std::find(allRelated.begin(), allRelated.end(), *itr)
             == allRelated.end())
         {
           allRelated.push_back(*itr);
         }
       }
 
       // add all filename editors to the nonDefaultList
       // we'll later try to add them all after content types are resolved
       // duplicates (ie: default editors) will be ignored
       QList<IEditorDescriptor::Pointer> tmpList = mapping->GetEditors();
       nonDefaultFileEditors.append(tmpList);
     }
 
     int index = fileName.indexOf('.');
     if (index != -1)
     {
       QString extension = "*" + fileName.mid(index);
       mapping = this->GetMappingFor(extension);
       if (!mapping.IsNull())
       {
         related = mapping->GetDeclaredDefaultEditors();
         for (QList<IEditorDescriptor::Pointer>::iterator itr =
             related.begin(); itr != related.end(); ++itr)
         {
           // we don't want to return duplicates
           if (std::find(allRelated.begin(), allRelated.end(), *itr)
               == allRelated.end())
           {
             allRelated.push_back(*itr);
           }
         }
         QList<IEditorDescriptor::Pointer> tmpList = mapping->GetEditors();
         nonDefaultFileEditors.append(tmpList);
       }
     }
   }
 
   //    if (type != null) {
   //      // now add any objects directly related to the content type
   //      related = registry.getRelatedObjects(type);
   //      for (int i = 0; i < related.length; i++) {
   //        // we don't want to return duplicates
   //        if (!allRelated.contains(related[i])) {
   //          // if it's not filtered, add it to the list
   //          if (!WorkbenchActivityHelper.filterItem(related[i])) {
   //            allRelated.add(related[i]);
   //          }
   //        }
   //      }
   //
   //    }
 
   //    if (type != null) {
   //      // now add any indirectly related objects, walking up the content type hierarchy
   //      while ((type = type.getBaseType()) != null) {
   //        related = registry.getRelatedObjects(type);
   //        for (int i = 0; i < related.length; i++) {
   //          // we don't want to return duplicates
   //          if (!allRelated.contains(related[i])) {
   //            // if it's not filtered, add it to the list
   //            if (!WorkbenchActivityHelper.filterItem(related[i])) {
   //              allRelated.add(related[i]);
   //            }
   //          }
   //        }
   //      }
   //    }
 
   // add all non-default editors to the list
   for (QList<IEditorDescriptor::Pointer>::iterator i =
       nonDefaultFileEditors.begin(); i != nonDefaultFileEditors.end(); ++i)
   {
     IEditorDescriptor::Pointer editor = *i;
     if (std::find(allRelated.begin(), allRelated.end(), editor)
         == allRelated.end())
     {
       allRelated.push_back(editor);
     }
   }
 
   return allRelated;
 }
 
 QList<IEditorDescriptor::Pointer> EditorRegistry::GetEditors(
     const QString& filename)
 {
   //return getEditors(filename, guessAtContentType(filename));
   return this->FindRelatedObjects(/*contentType,*/filename, relatedRegistry);
 }
 
 QList<IFileEditorMapping::Pointer> EditorRegistry::GetFileEditorMappings()
 {
   QList<FileEditorMapping::Pointer>
       array(typeEditorMappings.AllMappings());
   std::sort(array.begin(), array.end(), CmpFileEditorMapping());
 
   QList<IFileEditorMapping::Pointer> result;
   for (QList<FileEditorMapping::Pointer>::iterator itr = array.begin(); itr
       != array.end(); ++itr)
   {
     result.push_back(itr->Cast<IFileEditorMapping> ());
   }
   return result;
 }
 
 FileEditorMapping::Pointer EditorRegistry::GetMappingFor(const QString& ext)
 {
   QString key = this->MappingKeyFor(ext);
   return typeEditorMappings.Get(key);
 }
 
 QList<FileEditorMapping::Pointer> EditorRegistry::GetMappingForFilename(
     const QString& filename)
 {
   QList<FileEditorMapping::Pointer> mapping;
 
   // Lookup on entire filename
   mapping[0] = this->GetMappingFor(filename);
 
   // Lookup on filename's extension
   int index = filename.indexOf('.');
   if (index != -1)
   {
     QString extension = filename.mid(index);
     mapping[1] = this->GetMappingFor("*" + extension);
   }
 
   return mapping;
 }
 
 //    QList<IEditorDescriptor::Pointer> EditorRegistry::GetSortedEditorsFromOS()
 //    {
 //      List externalEditors = new ArrayList();
 //      Program[] programs = Program.getPrograms();
 //
 //      for (int i = 0; i < programs.length; i++)
 //      {
 //        //1FPLRL2: ITPUI:WINNT - NOTEPAD editor cannot be launched
 //        //Some entries start with %SystemRoot%
 //        //For such cases just use the file name as they are generally
 //        //in directories which are on the path
 //        /*
 //         * if (fileName.charAt(0) == '%') { fileName = name + ".exe"; }
 //         */
 //
 //        EditorDescriptor editor = new EditorDescriptor();
 //        editor.setOpenMode(EditorDescriptor.OPEN_EXTERNAL);
 //        editor.setProgram(programs[i]);
 //
 //        // determine the program icon this editor would need (do not let it
 //        // be cached in the workbench registry)
 //        ImageDescriptor desc = new ExternalProgramImageDescriptor(
 //            programs[i]);
 //        editor.setImageDescriptor(desc);
 //        externalEditors.add(editor);
 //      }
 //
 //      Object[] tempArray = sortEditors(externalEditors);
 //      IEditorDescriptor[] array = new IEditorDescriptor[externalEditors
 //      .size()];
 //      for (int i = 0; i < tempArray.length; i++)
 //      {
 //        array[i] = (IEditorDescriptor) tempArray[i];
 //      }
 //      return array;
 //    }
 
 QList<IEditorDescriptor::Pointer> EditorRegistry::GetSortedEditorsFromPlugins()
 {
   QList<IEditorDescriptor::Pointer> result;
   for (QList<EditorDescriptor::Pointer>::iterator itr =
       sortedEditorsFromPlugins.begin(); itr != sortedEditorsFromPlugins.end(); ++itr)
   {
     result.push_back((*itr).Cast<IEditorDescriptor> ());
   }
   return result;
 }
 
 void EditorRegistry::InitialIdToEditorMap(
     QHash<QString, EditorDescriptor::Pointer>& map)
 {
   this->AddSystemEditors(map);
 }
 
 void EditorRegistry::AddSystemEditors(
     QHash<QString, EditorDescriptor::Pointer>& map)
 {
   // there will always be a system external editor descriptor
   EditorDescriptor::Pointer editor(new EditorDescriptor());
   editor->SetID(IEditorRegistry::SYSTEM_EXTERNAL_EDITOR_ID);
   editor->SetName("System Editor");
   editor->SetOpenMode(EditorDescriptor::OPEN_EXTERNAL);
   // @issue we need a real icon for this editor?
   map[IEditorRegistry::SYSTEM_EXTERNAL_EDITOR_ID] = editor;
 
   // there may be a system in-place editor if supported by platform
   //      if (ComponentSupport.inPlaceEditorSupported())
   //      {
   //        editor = new EditorDescriptor();
   //        editor.setID(IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID);
   //        editor.setName(WorkbenchMessages.SystemInPlaceDescription_name);
   //        editor.setOpenMode(EditorDescriptor.OPEN_INPLACE);
   //        // @issue we need a real icon for this editor?
   //        map.put(IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID, editor);
   //      }
 
   EditorDescriptor::Pointer emptyEditorDescriptor(new EditorDescriptor());
   emptyEditorDescriptor->SetID(EMPTY_EDITOR_ID);
   emptyEditorDescriptor->SetName("(Empty)"); //$NON-NLS-1$
   //emptyEditorDescriptor.setImageDescriptor(WorkbenchImages
   //.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_ELEMENT));
   map[EMPTY_EDITOR_ID] = emptyEditorDescriptor;
 }
 
 void EditorRegistry::InitializeFromStorage()
 {
 
   //Get editors from the registry
   EditorRegistryReader registryReader;
   registryReader.AddEditors(this);
   this->SortInternalEditors();
   this->RebuildInternalEditorMap();
 
   //      IPreferenceStore store = PlatformUI.getPreferenceStore();
   //      String defaultEditors = store
   //      .getString(IPreferenceConstants.DEFAULT_EDITORS);
   //      String chachedDefaultEditors = store
   //      .getString(IPreferenceConstants.DEFAULT_EDITORS_CACHE);
 
   //If defaults has changed load it afterwards so it overrides the users
   // associations.
   //if (defaultEditors == null
   //    || defaultEditors.equals(chachedDefaultEditors))
   //{
   this->SetProductDefaults("");//defaultEditors);
   this->LoadAssociations(); //get saved earlier state
   //      }
   //      else
   //      {
   //        loadAssociations(); //get saved earlier state
   //        setProductDefaults(defaultEditors);
   //        store.putValue(IPreferenceConstants.DEFAULT_EDITORS_CACHE,
   //            defaultEditors);
   //      }
   this->AddExternalEditorsToEditorMap();
 }
 
 void EditorRegistry::SetProductDefaults(const QString& defaultEditors)
 {
   if (defaultEditors.isEmpty())
   {
     return;
   }
 
   //      Poco::StringTokenizer extEditors(defaultEditors,
   //          IPreferenceConstants::SEPARATOR, Poco::StringTokenizer::TOK_TRIM | Poco::StringTokenizer::TOK_IGNORE_EMPTY);
   //      while (extEditors.hasMoreTokens())
   //      {
   //        String extEditor = extEditors.nextToken().trim();
   //        int index = extEditor.indexOf(':');
   //        if (extEditor.length() < 3 || index <= 0 || index
   //            >= (extEditor.length() - 1))
   //        {
   //          //Extension and id must have at least one char.
   //          WorkbenchPlugin
   //          .log("Error setting default editor. Could not parse '" + extEditor
   //              + "'. Default editors should be specified as '*.ext1:editorId1;*.ext2:editorId2'"); //$NON-NLS-1$ //$NON-NLS-2$
   //          return;
   //        }
   //        String ext = extEditor.substring(0, index).trim();
   //        String editorId = extEditor.substring(index + 1).trim();
   //        FileEditorMapping mapping = getMappingFor(ext);
   //        if (mapping == null)
   //        {
   //          WorkbenchPlugin
   //          .log("Error setting default editor. Could not find mapping for '"
   //              + ext + "'."); //$NON-NLS-1$ //$NON-NLS-2$
   //          continue;
   //        }
   //        EditorDescriptor editor = (EditorDescriptor) findEditor(editorId);
   //        if (editor == null)
   //        {
   //          WorkbenchPlugin
   //          .log("Error setting default editor. Could not find editor: '"
   //              + editorId + "'."); //$NON-NLS-1$ //$NON-NLS-2$
   //          continue;
   //        }
   //        mapping.setDefaultEditor(editor);
   //      }
 }
 
 bool EditorRegistry::ReadEditors(
     QHash<QString, EditorDescriptor::Pointer>&  /*editorTable*/)
 {
   //Get the workbench plugin's working directory
   QString workbenchStatePath = WorkbenchPlugin::GetDefault()->GetDataLocation();
   if (workbenchStatePath.isNull())
   {
     return false;
   }
   //      IPreferenceStore store = WorkbenchPlugin.getDefault()
   //      .getPreferenceStore();
   //      Reader reader = null;
   //      try
   //      {
   //        // Get the editors defined in the preferences store
   //        String xmlString = store.getString(IPreferenceConstants.EDITORS);
   //        if (xmlString == null || xmlString.length() == 0)
   //        {
   //          FileInputStream stream = new FileInputStream(workbenchStatePath
   //              .append(IWorkbenchConstants.EDITOR_FILE_NAME)
   //              .toOSString());
   //          reader = new BufferedReader(new InputStreamReader(stream,
   //                  "utf-8")); //$NON-NLS-1$
   //        }
   //        else
   //        {
   //          reader = new StringReader(xmlString);
   //        }
   //        XMLMemento memento = XMLMemento.createReadRoot(reader);
   //        EditorDescriptor editor;
   //        IMemento[] edMementos = memento
   //        .getChildren(IWorkbenchConstants.TAG_DESCRIPTOR);
   //        // Get the editors and validate each one
   //        for (int i = 0; i < edMementos.length; i++)
   //        {
   //          editor = new EditorDescriptor();
   //          boolean valid = editor.loadValues(edMementos[i]);
   //          if (!valid)
   //          {
   //            continue;
   //          }
   //          if (editor.getPluginID() != null)
   //          {
   //            //If the editor is from a plugin we use its ID to look it
   //            // up in the mapping of editors we
   //            //have obtained from plugins. This allows us to verify that
   //            // the editor is still valid
   //            //and allows us to get the editor description from the
   //            // mapping table which has
   //            //a valid config element field.
   //            EditorDescriptor validEditorDescritor = (EditorDescriptor) mapIDtoEditor
   //            .get(editor.getId());
   //            if (validEditorDescritor != null)
   //            {
   //              editorTable.put(validEditorDescritor.getId(),
   //                  validEditorDescritor);
   //            }
   //          }
   //          else
   //          { //This is either from a program or a user defined
   //            // editor
   //            ImageDescriptor descriptor;
   //            if (editor.getProgram() == null)
   //            {
   //              descriptor = new ProgramImageDescriptor(editor
   //                  .getFileName(), 0);
   //            }
   //            else
   //            {
   //              descriptor = new ExternalProgramImageDescriptor(editor
   //                  .getProgram());
   //            }
   //            editor.setImageDescriptor(descriptor);
   //            editorTable.put(editor.getId(), editor);
   //          }
   //        }
   //      }
   //      catch (IOException e)
   //      {
   //        try
   //        {
   //          if (reader != null)
   //          {
   //            reader.close();
   //          }
   //        }
   //        catch (IOException ex)
   //        {
   //          e.printStackTrace();
   //        }
   //        //Ignore this as the workbench may not yet have saved any state
   //        return false;
   //      }
   //      catch (WorkbenchException e)
   //      {
   //        ErrorDialog.openError((Shell) null, WorkbenchMessages.EditorRegistry_errorTitle,
   //            WorkbenchMessages.EditorRegistry_errorMessage,
   //            e.getStatus());
   //        return false;
   //      }
 
   return true;
 }
 
 void EditorRegistry::ReadResources(
     QHash<QString, EditorDescriptor::Pointer>& /*editorTable*/,
     std::ostream&  /*reader*/)
 {
   //      XMLMemento memento = XMLMemento.createReadRoot(reader);
   //      String versionString = memento.getString(IWorkbenchConstants.TAG_VERSION);
   //      boolean versionIs31 = "3.1".equals(versionString); //$NON-NLS-1$
   //
   //      IMemento[] extMementos = memento
   //      .getChildren(IWorkbenchConstants.TAG_INFO);
   //      for (int i = 0; i < extMementos.length; i++)
   //      {
   //        String name = extMementos[i]
   //        .getString(IWorkbenchConstants.TAG_NAME);
   //        if (name == null)
   //        {
   //          name = "*"; //$NON-NLS-1$
   //        }
   //        String extension = extMementos[i]
   //        .getString(IWorkbenchConstants.TAG_EXTENSION);
   //        IMemento[] idMementos = extMementos[i]
   //        .getChildren(IWorkbenchConstants.TAG_EDITOR);
   //        String[] editorIDs = new String[idMementos.length];
   //        for (int j = 0; j < idMementos.length; j++)
   //        {
   //          editorIDs[j] = idMementos[j]
   //          .getString(IWorkbenchConstants.TAG_ID);
   //        }
   //        idMementos = extMementos[i]
   //        .getChildren(IWorkbenchConstants.TAG_DELETED_EDITOR);
   //        String[] deletedEditorIDs = new String[idMementos.length];
   //        for (int j = 0; j < idMementos.length; j++)
   //        {
   //          deletedEditorIDs[j] = idMementos[j]
   //          .getString(IWorkbenchConstants.TAG_ID);
   //        }
   //        FileEditorMapping mapping = getMappingFor(name + "." + extension); //$NON-NLS-1$
   //        if (mapping == null)
   //        {
   //          mapping = new FileEditorMapping(name, extension);
   //        }
   //        List editors = new ArrayList();
   //        for (int j = 0; j < editorIDs.length; j++)
   //        {
   //          if (editorIDs[j] != null)
   //          {
   //            EditorDescriptor editor = (EditorDescriptor) editorTable
   //            .get(editorIDs[j]);
   //            if (editor != null)
   //            {
   //              editors.add(editor);
   //            }
   //          }
   //        }
   //        List deletedEditors = new ArrayList();
   //        for (int j = 0; j < deletedEditorIDs.length; j++)
   //        {
   //          if (deletedEditorIDs[j] != null)
   //          {
   //            EditorDescriptor editor = (EditorDescriptor) editorTable
   //            .get(deletedEditorIDs[j]);
   //            if (editor != null)
   //            {
   //              deletedEditors.add(editor);
   //            }
   //          }
   //        }
   //
   //        List defaultEditors = new ArrayList();
   //
   //        if (versionIs31)
   //        { // parse the new format
   //          idMementos = extMementos[i]
   //          .getChildren(IWorkbenchConstants.TAG_DEFAULT_EDITOR);
   //          String[] defaultEditorIds = new String[idMementos.length];
   //          for (int j = 0; j < idMementos.length; j++)
   //          {
   //            defaultEditorIds[j] = idMementos[j]
   //            .getString(IWorkbenchConstants.TAG_ID);
   //          }
   //          for (int j = 0; j < defaultEditorIds.length; j++)
   //          {
   //            if (defaultEditorIds[j] != null)
   //            {
   //              EditorDescriptor editor = (EditorDescriptor) editorTable
   //              .get(defaultEditorIds[j]);
   //              if (editor != null)
   //              {
   //                defaultEditors.add(editor);
   //              }
   //            }
   //          }
   //        }
   //        else
   //        { // guess at pre 3.1 format defaults
   //          if (!editors.isEmpty())
   //          {
   //            EditorDescriptor editor = (EditorDescriptor) editors.get(0);
   //            if (editor != null)
   //            {
   //              defaultEditors.add(editor);
   //            }
   //          }
   //          defaultEditors.addAll(Arrays.asList(mapping.getDeclaredDefaultEditors()));
   //        }
   //
   //        // Add any new editors that have already been read from the registry
   //        // which were not deleted.
   //        IEditorDescriptor[] editorsArray = mapping.getEditors();
   //        for (int j = 0; j < editorsArray.length; j++)
   //        {
   //          if (!contains(editors, editorsArray[j])
   //              && !deletedEditors.contains(editorsArray[j]))
   //          {
   //            editors.add(editorsArray[j]);
   //          }
   //        }
   //        // Map the editor(s) to the file type
   //        mapping.setEditorsList(editors);
   //        mapping.setDeletedEditorsList(deletedEditors);
   //        mapping.setDefaultEditors(defaultEditors);
   //        typeEditorMappings.put(mappingKeyFor(mapping), mapping);
   //      }
 }
 
 bool EditorRegistry::Contains(
     const QList<IEditorDescriptor::Pointer>& editorsArray,
     IEditorDescriptor::Pointer editorDescriptor)
 {
   IEditorDescriptor::Pointer currentEditorDescriptor;
   for (QList<IEditorDescriptor::Pointer>::const_iterator i =
       editorsArray.begin(); i != editorsArray.end(); ++i)
   {
     currentEditorDescriptor = *i;
     if (currentEditorDescriptor->GetId() == editorDescriptor->GetId())
     {
       return true;
     }
   }
   return false;
 
 }
 
 bool EditorRegistry::ReadResources(
     QHash<QString, EditorDescriptor::Pointer>&  /*editorTable*/)
 {
   //Get the workbench plugin's working directory
   QString workbenchStatePath = WorkbenchPlugin::GetDefault()->GetDataLocation();
   // XXX: nobody cares about this return value
   if (workbenchStatePath.isNull())
   {
     return false;
   }
   //      IPreferenceStore store = WorkbenchPlugin.getDefault()
   //      .getPreferenceStore();
   //      Reader reader = null;
   //      try
   //      {
   //        // Get the resource types
   //        String xmlString = store.getString(IPreferenceConstants.RESOURCES);
   //        if (xmlString == null || xmlString.length() == 0)
   //        {
   //          FileInputStream stream = new FileInputStream(workbenchStatePath
   //              .append(IWorkbenchConstants.RESOURCE_TYPE_FILE_NAME)
   //              .toOSString());
   //          reader = new BufferedReader(new InputStreamReader(stream,
   //                  "utf-8")); //$NON-NLS-1$
   //        }
   //        else
   //        {
   //          reader = new StringReader(xmlString);
   //        }
   //        // Read the defined resources into the table
   //        readResources(editorTable, reader);
   //      }
   //      catch (IOException e)
   //      {
   //        try
   //        {
   //          if (reader != null)
   //          {
   //            reader.close();
   //          }
   //        }
   //        catch (IOException ex)
   //        {
   //          ex.printStackTrace();
   //        }
   //        MessageDialog.openError((Shell) null, WorkbenchMessages.EditorRegistry_errorTitle,
   //            WorkbenchMessages.EditorRegistry_errorMessage);
   //        return false;
   //      }
   //      catch (WorkbenchException e)
   //      {
   //        ErrorDialog.openError((Shell) null, WorkbenchMessages.EditorRegistry_errorTitle,
   //            WorkbenchMessages.EditorRegistry_errorMessage,
   //            e.getStatus());
   //        return false;
   //      }
   return true;
 
 }
 
 bool EditorRegistry::LoadAssociations()
 {
   QHash<QString, EditorDescriptor::Pointer> editorTable;
   if (!this->ReadEditors(editorTable))
   {
     return false;
   }
   return this->ReadResources(editorTable);
 }
 
 QString EditorRegistry::MappingKeyFor(const QString& type)
 {
   // keep everything lower case for case-sensitive platforms
   return type.toLower();
 }
 
 QString EditorRegistry::MappingKeyFor(FileEditorMapping::Pointer mapping)
 {
   return this->MappingKeyFor(mapping->GetName()
       + (mapping->GetExtension().size() == 0 ? "" : "."
           + mapping->GetExtension())); //$NON-NLS-1$ //$NON-NLS-2$
 }
 
 void EditorRegistry::RebuildEditorMap()
 {
   this->RebuildInternalEditorMap();
   this->AddExternalEditorsToEditorMap();
 }
 
 void EditorRegistry::RebuildInternalEditorMap()
 {
   EditorDescriptor::Pointer desc;
 
   // Allocate a new map.
   mapIDtoEditor.clear();
   this->InitialIdToEditorMap(mapIDtoEditor);
 
   // Add plugin editors.
   for (QList<EditorDescriptor::Pointer>::iterator itr =
       sortedEditorsFromPlugins.begin(); itr != sortedEditorsFromPlugins.end(); ++itr)
   {
     desc = *itr;
     mapIDtoEditor[desc->GetId()] = desc;
   }
 }
 
 void EditorRegistry::SaveAssociations()
 {
   //Save the resource type descriptions
   //      List editors = new ArrayList();
   //      IPreferenceStore store = WorkbenchPlugin.getDefault()
   //      .getPreferenceStore();
   //
   //      XMLMemento memento = XMLMemento
   //      .createWriteRoot(IWorkbenchConstants.TAG_EDITORS);
   //      memento.putString(IWorkbenchConstants.TAG_VERSION, "3.1"); //$NON-NLS-1$
   //      FileEditorMapping maps[] = typeEditorMappings.userMappings();
   //      for (int mapsIndex = 0; mapsIndex < maps.length; mapsIndex++)
   //      {
   //        FileEditorMapping type = maps[mapsIndex];
   //        IMemento editorMemento = memento
   //        .createChild(IWorkbenchConstants.TAG_INFO);
   //        editorMemento.putString(IWorkbenchConstants.TAG_NAME, type
   //        .getName());
   //        editorMemento.putString(IWorkbenchConstants.TAG_EXTENSION, type
   //        .getExtension());
   //        IEditorDescriptor[] editorArray = type.getEditors();
   //        for (int i = 0; i < editorArray.length; i++)
   //        {
   //          EditorDescriptor editor = (EditorDescriptor) editorArray[i];
   //          if (!editors.contains(editor))
   //          {
   //            editors.add(editor);
   //          }
   //          IMemento idMemento = editorMemento
   //          .createChild(IWorkbenchConstants.TAG_EDITOR);
   //          idMemento.putString(IWorkbenchConstants.TAG_ID, editorArray[i]
   //          .getId());
   //        }
   //        editorArray = type.getDeletedEditors();
   //        for (int i = 0; i < editorArray.length; i++)
   //        {
   //          EditorDescriptor editor = (EditorDescriptor) editorArray[i];
   //          if (!editors.contains(editor))
   //          {
   //            editors.add(editor);
   //          }
   //          IMemento idMemento = editorMemento
   //          .createChild(IWorkbenchConstants.TAG_DELETED_EDITOR);
   //          idMemento.putString(IWorkbenchConstants.TAG_ID, editorArray[i]
   //          .getId());
   //        }
   //        editorArray = type.getDeclaredDefaultEditors();
   //        for (int i = 0; i < editorArray.length; i++)
   //        {
   //          EditorDescriptor editor = (EditorDescriptor) editorArray[i];
   //          if (!editors.contains(editor))
   //          {
   //            editors.add(editor);
   //          }
   //          IMemento idMemento = editorMemento
   //          .createChild(IWorkbenchConstants.TAG_DEFAULT_EDITOR);
   //          idMemento.putString(IWorkbenchConstants.TAG_ID, editorArray[i]
   //          .getId());
   //        }
   //      }
   //      Writer writer = null;
   //      try
   //      {
   //        writer = new StringWriter();
   //        memento.save(writer);
   //        writer.close();
   //        store.setValue(IPreferenceConstants.RESOURCES, writer.toString());
   //      }
   //      catch (IOException e)
   //      {
   //        try
   //        {
   //          if (writer != null)
   //          {
   //            writer.close();
   //          }
   //        }
   //        catch (IOException ex)
   //        {
   //          ex.printStackTrace();
   //        }
   //        MessageDialog.openError((Shell) null, "Saving Problems", //$NON-NLS-1$
   //            "Unable to save resource associations."); //$NON-NLS-1$
   //        return;
   //      }
   //
   //      memento = XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_EDITORS);
   //      Iterator itr = editors.iterator();
   //      while (itr.hasNext())
   //      {
   //        EditorDescriptor editor = (EditorDescriptor) itr.next();
   //        IMemento editorMemento = memento
   //        .createChild(IWorkbenchConstants.TAG_DESCRIPTOR);
   //        editor.saveValues(editorMemento);
   //      }
   //      writer = null;
   //      try
   //      {
   //        writer = new StringWriter();
   //        memento.save(writer);
   //        writer.close();
   //        store.setValue(IPreferenceConstants.EDITORS, writer.toString());
   //      }
   //      catch (IOException e)
   //      {
   //        try
   //        {
   //          if (writer != null)
   //          {
   //            writer.close();
   //          }
   //        }
   //        catch (IOException ex)
   //        {
   //          ex.printStackTrace();
   //        }
   //        MessageDialog.openError((Shell) null,
   //            "Error", "Unable to save resource associations."); //$NON-NLS-1$ //$NON-NLS-2$
   //        return;
   //      }
 }
 
 void EditorRegistry::SetFileEditorMappings(
     const QList<FileEditorMapping::Pointer>& newResourceTypes)
 {
   typeEditorMappings.Clear();
   for (int i = 0; i < newResourceTypes.size(); i++)
   {
     FileEditorMapping::Pointer mapping = newResourceTypes[i];
     typeEditorMappings.Put(this->MappingKeyFor(mapping), mapping);
   }
   //extensionImages = new HashMap();
   this->RebuildEditorMap();
   //firePropertyChange(PROP_CONTENTS);
 }
 
 void EditorRegistry::SetDefaultEditor(const QString& fileName,
     const QString& editorId)
 {
   EditorDescriptor::Pointer desc = this->FindEditor(editorId).Cast<
       EditorDescriptor> ();
   QList<FileEditorMapping::Pointer> mapping = this->GetMappingForFilename(
       fileName);
   if (!mapping[0].IsNull())
   {
     mapping[0]->SetDefaultEditor(desc);
   }
   if (!mapping[1].IsNull())
   {
     mapping[1]->SetDefaultEditor(desc);
   }
 }
 
 QList<IEditorDescriptor::Pointer> EditorRegistry::SortEditors(
     const QList<IEditorDescriptor::Pointer>& unsortedList)
 {
   QList<IEditorDescriptor::Pointer> result(unsortedList);
   std::sort(result.begin(), result.end(), CmpIEditorDescriptor());
 
   return result;
 }
 
 void EditorRegistry::SortInternalEditors()
 {
   qSort(sortedEditorsFromPlugins.begin(), sortedEditorsFromPlugins.end(), CmpEditorDescriptor());
 }
 
 void EditorRegistry::EditorMap::PutDefault(const QString& key,
     FileEditorMapping::Pointer value)
 {
   defaultMap[key] = value;
 }
 
 void EditorRegistry::EditorMap::Put(const QString& key,
     FileEditorMapping::Pointer value)
 {
   QHash<QString, FileEditorMapping::Pointer>::iterator result =
       defaultMap.find(key);
   if (result != defaultMap.end())
   {
     map[key] = value;
   }
 }
 
 FileEditorMapping::Pointer EditorRegistry::EditorMap::Get(
     const QString& key)
 {
   QHash<QString, FileEditorMapping::Pointer>::const_iterator result =
       map.find(key);
   if (result == map.end())
   {
     return defaultMap[key];
   }
   return result.value();
 }
 
 void EditorRegistry::EditorMap::Clear()
 {
   defaultMap.clear();
   map.clear();
 }
 
 QList<FileEditorMapping::Pointer> EditorRegistry::EditorMap::AllMappings()
 {
   QSet<FileEditorMapping::Pointer> resultSet;
   QHash<QString, FileEditorMapping::Pointer>::const_iterator iter;
   for (iter = defaultMap.begin(); iter != defaultMap.end(); ++iter)
   {
     resultSet.insert(iter.value());
   }
   for (iter = map.begin(); iter != map.end(); ++iter)
   {
     resultSet.insert(iter.value());
   }
 
-  return resultSet.toList();
+  return resultSet.values();
 }
 
 QList<FileEditorMapping::Pointer> EditorRegistry::EditorMap::UserMappings()
 {
   return map.values();
 }
 
 bool EditorRegistry::IsSystemInPlaceEditorAvailable(const QString&  /*filename*/)
 {
   //return ComponentSupport.inPlaceEditorAvailable(filename);
   return false;
 }
 
 bool EditorRegistry::IsSystemExternalEditorAvailable(
     const QString&  /*filename*/)
 {
   //      QString::size_type nDot = filename.find_last_of('.');
   //      if (nDot != QString::npos)
   //      {
   //        QString strName = filename.substr(nDot);
   //        return Program.findProgram(strName) != null;
   //      }
   return false;
 }
 
 void EditorRegistry::RemoveEditorFromMapping(
     QHash<QString, FileEditorMapping::Pointer>& map,
     IEditorDescriptor::Pointer desc)
 {
   FileEditorMapping::Pointer mapping;
   for (QHash<QString, FileEditorMapping::Pointer>::iterator iter =
       map.begin(); iter != map.end(); ++iter)
   {
     mapping = iter.value();
     QList<IEditorDescriptor::Pointer> editors(mapping->GetEditors());
     QList<IEditorDescriptor::Pointer>::iterator result = std::find(
         editors.begin(), editors.end(), desc);
     if (result != editors.end())
     {
       mapping->RemoveEditor(result->Cast<EditorDescriptor> ());
       editors.erase(result);
     }
 
     if (editors.empty())
     {
       map.erase(iter);
       break;
     }
   }
 }
 
 IExtensionPoint::Pointer EditorRegistry::GetExtensionPointFilter()
 {
   return Platform::GetExtensionRegistry()->GetExtensionPoint(
         PlatformUI::PLUGIN_ID(), WorkbenchRegistryConstants::PL_EDITOR);
 }
 
 QList<IFileEditorMapping::Pointer> EditorRegistry::GetUnifiedMappings()
 {
   QList<IFileEditorMapping::Pointer>
       standardMappings(
           dynamic_cast<EditorRegistry*> (PlatformUI::GetWorkbench() ->GetEditorRegistry())->GetFileEditorMappings());
 
   QList<IFileEditorMapping::Pointer> allMappings(standardMappings);
   // mock-up content type extensions into IFileEditorMappings
   //      IContentType [] contentTypes = Platform.getContentTypeManager().getAllContentTypes();
   //      for (int i = 0; i < contentTypes.length; i++)
   //      {
   //        IContentType type = contentTypes[i];
   //        String [] extensions = type.getFileSpecs(IContentType.FILE_EXTENSION_SPEC);
   //        for (int j = 0; j < extensions.length; j++)
   //        {
   //          String extension = extensions[j];
   //          boolean found = false;
   //          for (Iterator k = allMappings.iterator(); k.hasNext();)
   //          {
   //            IFileEditorMapping mapping = (IFileEditorMapping) k.next();
   //            if ("*".equals(mapping.getName())
   //                && extension.equals(mapping.getExtension()))
   //            { //$NON-NLS-1$
   //              found = true;
   //              break;
   //            }
   //          }
   //          if (!found)
   //          {
   //            MockMapping mockMapping = new MockMapping(type, "*", extension); //$NON-NLS-1$
   //            allMappings.add(mockMapping);
   //          }
   //        }
   //
   //        String [] filenames = type.getFileSpecs(IContentType.FILE_NAME_SPEC);
   //        for (int j = 0; j < filenames.length; j++)
   //        {
   //          String wholename = filenames[j];
   //          int idx = wholename.indexOf('.');
   //          String name = idx == -1 ? wholename : wholename.substring(0, idx);
   //          String extension = idx == -1 ? "" : wholename.substring(idx + 1); //$NON-NLS-1$
   //
   //          boolean found = false;
   //          for (Iterator k = allMappings.iterator(); k.hasNext();)
   //          {
   //            IFileEditorMapping mapping = (IFileEditorMapping) k.next();
   //            if (name.equals(mapping.getName())
   //                && extension.equals(mapping.getExtension()))
   //            {
   //              found = true;
   //              break;
   //            }
   //          }
   //          if (!found)
   //          {
   //            MockMapping mockMapping = new MockMapping(type, name, extension);
   //            allMappings.add(mockMapping);
   //          }
   //        }
   //      }
 
   return allMappings;
 }
 
 MockMapping::MockMapping(/*IContentType type,*/const QString& name,
     const QString& ext) :
   extension(ext), filename(name)
 {
   //this.contentType = type;
 }
 
 IEditorDescriptor::Pointer MockMapping::GetDefaultEditor()
 {
   //      QList<IEditorDescriptor::Pointer> candidates = PlatformUI::GetWorkbench()->GetEditorRegistry()
   //      ->GetEditorsForContentType(contentType);
   //      if (candidates.empty())
   //      {
   //        return IEditorDescriptor::Pointer();
   //      }
   //      return candidates[0];
 
   return IEditorDescriptor::Pointer();
 }
 
 QList<IEditorDescriptor::Pointer> MockMapping::GetEditors() const
 {
   //      QList<IEditorDescriptor::Pointer> editorsForContentType = (dynamic_cast<EditorRegistry*>(PlatformUI
   //          ::GetWorkbench()->GetEditorRegistry())
   //      ->GetEditorsForContentType(contentType);
   //      return editorsForContentType;
   return QList<IEditorDescriptor::Pointer>();
 }
 
 QList<IEditorDescriptor::Pointer> MockMapping::GetDeletedEditors() const
 {
   return QList<IEditorDescriptor::Pointer>();
 }
 
 QString MockMapping::GetExtension() const
 {
   return extension;
 }
 
 QString MockMapping::GetLabel() const
 {
   return filename + '.' + extension;
 }
 
 QString MockMapping::GetName() const
 {
   return filename;
 }
 
 bool MockMapping::operator==(const Object* obj) const
 {
   if (const MockMapping* other = dynamic_cast<const MockMapping*>(obj))
   {
     if (this == other)
     {
       return true;
     }
 
     //MockMapping mapping = (MockMapping) obj;
     if (!(this->filename == other->filename))
     {
       return false;
     }
 
     if (!(this->extension == other->extension))
     {
       return false;
     }
 
     if (!(this->GetEditors() == other->GetEditors()))
     {
       return false;
     }
     return this->GetDeletedEditors() == other->GetDeletedEditors();
   }
 
   return false;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryEvaluationAuthority.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryEvaluationAuthority.cpp
index ee9098c4cd..5a700c2801 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryEvaluationAuthority.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryEvaluationAuthority.cpp
@@ -1,244 +1,244 @@
 /*============================================================================
 
 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 "berryEvaluationAuthority.h"
 
 #include "berryCommandTracing.h"
 #include "berryExpressionInfo.h"
 #include "berryExpression.h"
 #include "berryEvaluationReference.h"
 #include "berryPolicy.h"
 #include "berryWorkbenchPlugin.h"
 
 #include <berryObjects.h>
 #include <berryISources.h>
 #include <berryIEvaluationService.h>
 
 #include <QStringList>
 #include <QString>
 
 namespace berry {
 
 const QString EvaluationAuthority::COMPONENT = "EVALUATION";
 
 
 QStringList EvaluationAuthority::GetNames(const SmartPointer<IEvaluationReference>& ref) const
 {
   ExpressionInfo info;
   ref->GetExpression()->CollectExpressionInfo(&info);
   QSet<QString> allNames = info.GetAccessedVariableNames();
   if (info.HasDefaultVariableAccess())
   {
     allNames << ISources::ACTIVE_CURRENT_SELECTION_NAME();
   }
 
   allNames.unite(info.GetAccessedPropertyNames());
-  return allNames.toList();
+  return allNames.values();
 }
 
 void EvaluationAuthority::RefsWithSameExpression(const QList<SmartPointer<EvaluationReference> >& refs)
 {
   int k = 0;
   while (k < refs.size() && !refs[k]->IsPostingChanges())
   {
     k++;
   }
   if (k >= refs.size())
   {
     return;
   }
   EvaluationReference::Pointer ref = refs[k];
   bool oldValue = Evaluate(ref);
   ref->ClearResult();
   const bool newValue = Evaluate(ref);
   if (oldValue != newValue)
   {
     FirePropertyChange(ref, ValueOf(oldValue), ValueOf(newValue));
   }
   for (k++; k < refs.size(); k++)
   {
     ref = refs[k];
     // this is not as expensive as it looks
     if (ref->IsPostingChanges())
     {
       oldValue = Evaluate(ref);
       if (oldValue != newValue)
       {
         ref->SetResult(newValue);
         FirePropertyChange(ref, ValueOf(oldValue),
                            ValueOf(newValue));
       }
     }
   }
 }
 
 void EvaluationAuthority::StartSourceChange(const QStringList& sourceNames)
 {
   if (Policy::DEBUG_SOURCES())
   {
     CommandTracing::PrintTrace(COMPONENT, "start source changed: " + sourceNames.join(", "));
   }
   notifying++;
   if (notifying == 1)
   {
     FireServiceChange(IEvaluationService::PROP_NOTIFYING, ValueOf(false),
                       ValueOf(true));
   }
 }
 
 void EvaluationAuthority::EndSourceChange(const QStringList& sourceNames)
 {
   if (Policy::DEBUG_SOURCES())
   {
     CommandTracing::PrintTrace(COMPONENT, "end source changed: " + sourceNames.join(", "));
   }
   if (notifying == 1)
   {
     FireServiceChange(IEvaluationService::PROP_NOTIFYING, ValueOf(true),
                       ValueOf(false));
   }
   notifying--;
 }
 
 void EvaluationAuthority::FirePropertyChange(const SmartPointer<IEvaluationReference>& ref,
                                              Object::Pointer oldValue, Object::Pointer newValue)
 {
   PropertyChangeEvent::Pointer event(new PropertyChangeEvent(ref, ref->GetProperty(), oldValue,
                                                              newValue));
   ref->GetListener()->PropertyChange(event);
 }
 
 void EvaluationAuthority::FireServiceChange(const QString& property, Object::Pointer oldValue,
                                             Object::Pointer newValue)
 {
   PropertyChangeEvent::Pointer event(
         new PropertyChangeEvent(Object::Pointer(this), property, oldValue, newValue));
   serviceListeners.propertyChange(event);
 }
 
 void EvaluationAuthority::ServiceChangeException(const std::exception &exc)
 {
   WorkbenchPlugin::Log(exc.what());
 }
 
 Object::Pointer EvaluationAuthority::ValueOf(bool result)
 {
   return ObjectBool::Pointer(new ObjectBool(result));
 }
 
 void EvaluationAuthority::SourceChanged(int /*sourcePriority*/)
 {
   // no-op, we want the other one
 }
 
 void EvaluationAuthority::SourceChanged(const QStringList& sourceNames)
 {
   struct SourceChangeScope {
     EvaluationAuthority* const ea;
     const QStringList& sourceNames;
     SourceChangeScope(EvaluationAuthority* ea, const QStringList& sourceNames)
       : ea(ea), sourceNames(sourceNames)
     {
       ea->StartSourceChange(sourceNames);
     }
     ~SourceChangeScope()
     {
       ea->EndSourceChange(sourceNames);
     }
   };
 
   SourceChangeScope(this, sourceNames);
   // evaluations to recompute
   for (int i = 0; i < sourceNames.size(); i++)
   {
     if (cachesBySourceName.contains(sourceNames[i]))
     {
       const ExprToEvalsMapType& cachesByExpression = cachesBySourceName[sourceNames[i]];
       QList<QSet<EvaluationReference::Pointer> > expressionCaches = cachesByExpression.values();
       for (int j = 0; j < expressionCaches.size(); j++)
       {
         if (!(expressionCaches[j].isEmpty()))
         {
-          QList<EvaluationReference::Pointer> refs = expressionCaches[j].toList();
+          QList<EvaluationReference::Pointer> refs = expressionCaches[j].values();
           RefsWithSameExpression(refs);
         }
       }
     }
   }
 }
 
 EvaluationAuthority::EvaluationAuthority()
   : serviceExceptionHandler(this, &EvaluationAuthority::ServiceChangeException), notifying(0)
 {
   serviceListeners.propertyChange.SetExceptionHandler(serviceExceptionHandler);
 }
 
 SmartPointer<const Shell> EvaluationAuthority::GetActiveShell() const
 {
   return GetVariable(ISources::ACTIVE_SHELL_NAME()).Cast<const Shell>();
 }
 
 void EvaluationAuthority::AddEvaluationListener(const SmartPointer<IEvaluationReference>& ref)
 {
   // we update the source priority bucket sort of activations.
   QStringList sourceNames = GetNames(ref);
   for (int i = 0; i < sourceNames.size(); i++)
   {
     ExprToEvalsMapType& cachesByExpression = cachesBySourceName[sourceNames[i]];
     const Expression::Pointer expression = ref->GetExpression();
     cachesByExpression[expression].insert(ref.Cast<EvaluationReference>());
   }
 
   bool result = Evaluate(ref);
   FirePropertyChange(ref, Object::Pointer(nullptr), ValueOf(result));
 }
 
 void EvaluationAuthority::RemoveEvaluationListener(const SmartPointer<IEvaluationReference>& ref)
 {
   // Next we update the source priority bucket sort of activations.
   QStringList sourceNames = GetNames(ref);
   for (int i = 0; i < sourceNames.size(); i++)
   {
     if (cachesBySourceName.contains(sourceNames[i]))
     {
       ExprToEvalsMapType& cachesByExpression = cachesBySourceName[sourceNames[i]];
       if (cachesByExpression.contains(ref->GetExpression()))
       {
         QSet<EvaluationReference::Pointer>& caches = cachesByExpression[ref->GetExpression()];
         caches.remove(ref.Cast<EvaluationReference>());
         if (caches.isEmpty())
         {
           cachesByExpression.remove(ref->GetExpression());
         }
       }
       if (cachesByExpression.isEmpty())
       {
         cachesBySourceName.remove(sourceNames[i]);
       }
     }
   }
   bool result = Evaluate(ref);
   FirePropertyChange(ref, ValueOf(result), Object::Pointer(nullptr));
 }
 
 void EvaluationAuthority::AddServiceListener(IPropertyChangeListener* listener)
 {
   serviceListeners.AddListener(listener);
 }
 
 void EvaluationAuthority::RemoveServiceListener(IPropertyChangeListener* listener)
 {
   serviceListeners.RemoveListener(listener);
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryNestableHandlerService.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryNestableHandlerService.cpp
index 00d07f3fc2..fcfad52895 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryNestableHandlerService.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryNestableHandlerService.cpp
@@ -1,81 +1,81 @@
 /*============================================================================
 
 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 "berryNestableHandlerService.h"
 
 #include "berryExpression.h"
 #include "berryIHandlerActivation.h"
 #include "berryISourceProvider.h"
 
 namespace berry {
 
 NestableHandlerService::NestableHandlerService(IHandlerService* parentHandlerService,
                        const SmartPointer<Expression>& defaultExpression)
   : SlaveHandlerService(parentHandlerService, defaultExpression)
   , active(false)
 {
 }
 
 void NestableHandlerService::Activate()
 {
   if (active)
   {
     return;
   }
 
   QList<IHandlerActivation::Pointer> localActivations = localActivationsToParentActivations.keys();
   for (int i = 0; i < localActivations.size(); i++)
   {
     // Ignore activations that have been cleared since the copy
     // was made.
     if (localActivationsToParentActivations.contains(localActivations[i]))
     {
       SlaveHandlerService::DoActivation(localActivations[i]);
     }
   }
   active = true;
 }
 
 void NestableHandlerService::Deactivate()
 {
   if (!active)
   {
     return;
   }
 
-  DeactivateHandlers(parentActivations.toList());
+  DeactivateHandlers(parentActivations.values());
   parentActivations.clear();
 
   QList<IHandlerActivation::Pointer> localActivations = localActivationsToParentActivations.keys();
   for (int i = 0; i < localActivations.size(); i++)
   {
     if (localActivationsToParentActivations.contains(localActivations[i]))
     {
       localActivationsToParentActivations.insert(localActivations[i], nullptr);
     }
   }
 
   active = false;
 }
 
 SmartPointer<IHandlerActivation> NestableHandlerService::DoActivation(
     const SmartPointer<IHandlerActivation>& localActivation)
 {
   if (active)
   {
     return SlaveHandlerService::DoActivation(localActivation);
   }
   localActivationsToParentActivations.insert(localActivation, nullptr);
   return localActivation;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berrySaveablesList.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berrySaveablesList.cpp
index 9a7fda5765..9c5b90e430 100755
--- a/Plugins/org.blueberry.ui.qt/src/internal/berrySaveablesList.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berrySaveablesList.cpp
@@ -1,628 +1,628 @@
 /*============================================================================
 
 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 "berrySaveablesList.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryDefaultSaveable.h"
 
 #include "berryWorkbenchPart.h"
 
 namespace berry
 {
 
 bool SaveablesList::AddModel(Object::Pointer source, Saveable::Pointer model)
 {
   if (model == 0)
   {
     this->LogWarning("Ignored attempt to add invalid saveable", source, model); //$NON-NLS-1$
     return false;
   }
   bool result = false;
   Saveable::Set& modelsForSource = modelMap[source.GetPointer()];
 
   if (modelsForSource.find(model) == modelsForSource.end())
   {
     modelsForSource.insert(model);
     result = this->IncrementRefCount(modelRefCounts, model);
   }
   else
   {
     this->LogWarning("Ignored attempt to add saveable that was already registered",
         source, model); //$NON-NLS-1$
   }
   return result;
 }
 
 bool SaveablesList::IncrementRefCount(
     QHash<Saveable::Pointer, int>& referenceMap, Saveable::Pointer key)
 {
   bool result = false;
   int& refCount = referenceMap[key];
   if (refCount == 0)
   {
     result = true;
   }
   refCount++;
   return result;
 }
 
 bool SaveablesList::DecrementRefCount(
     QHash<Saveable::Pointer, int>& referenceMap, Saveable::Pointer key)
 {
   bool result = false;
   int& refCount = referenceMap[key];
   poco_assert(refCount != 0);
   if (refCount == 1)
   {
     referenceMap.remove(key);
     result = true;
   }
   else
   {
     --refCount;
   }
   return result;
 }
 
 bool SaveablesList::RemoveModel(Object::Pointer source, Saveable::Pointer model)
 {
   bool result = false;
   QHash<Object*, Saveable::Set>::iterator it = modelMap.find(source.GetPointer());
   if (it == modelMap.end())
   {
     this->LogWarning(
         "Ignored attempt to remove a saveable when no saveables were known",
         source, model); //$NON-NLS-1$
   }
   else
   {
     Saveable::Set& modelsForSource = it.value();
     if (modelsForSource.remove(model))
     {
       result = this->DecrementRefCount(modelRefCounts, model);
       if (modelsForSource.empty())
       {
         modelMap.remove(source.GetPointer());
       }
     }
     else
     {
       this->LogWarning(
           "Ignored attempt to remove a saveable that was not registered",
           source, model); //$NON-NLS-1$
     }
   }
   return result;
 }
 
 void SaveablesList::LogWarning(const QString& message,
     Object::Pointer source, Saveable::Pointer model)
 {
   // create a new exception
   QString text = message + "; " + "unknown saveable: " + model->GetName()
           + " from part: " + source->GetClassName();
   // record the current stack trace to help with debugging
   //assertionFailedException.fillInStackTrace();
   WorkbenchPlugin::Log(text);
 }
 
 void SaveablesList::UpdateNonPartSource(ISaveablesSource::Pointer source)
 {
   QList<Saveable::Pointer> saveables = source->GetSaveables();
   if (saveables.empty())
   {
     nonPartSources.remove(source);
   }
   else
   {
     nonPartSources.insert(source);
   }
 }
 
 void SaveablesList::RemoveModels(Object::Pointer source,
     const QList<Saveable::Pointer>& modelArray)
 {
   QList<Saveable::Pointer> removed;
   for (int i = 0; i < modelArray.size(); i++)
   {
     Saveable::Pointer model = modelArray[i];
     if (this->RemoveModel(source, model))
     {
       removed.push_back(model);
     }
   }
   if (removed.size() > 0)
   {
     Object::Pointer source(this);
     SaveablesLifecycleEvent::Pointer event(new SaveablesLifecycleEvent(source,
         SaveablesLifecycleEvent::POST_OPEN, removed, false));
     this->FireModelLifecycleEvent(event);
   }
 }
 
 void SaveablesList::AddModels(Object::Pointer source,
     const QList<Saveable::Pointer>& modelArray)
 {
   QList<Saveable::Pointer> added;
   for (int i = 0; i < modelArray.size(); i++)
   {
     Saveable::Pointer model = modelArray[i];
     if (this->AddModel(source, model))
     {
       added.push_back(model);
     }
   }
   if (added.size() > 0)
   {
     Object::Pointer source(this);
     SaveablesLifecycleEvent::Pointer event(new SaveablesLifecycleEvent(source,
         SaveablesLifecycleEvent::POST_OPEN, added, false));
     this->FireModelLifecycleEvent(event);
   }
 }
 
 void SaveablesList::FireModelLifecycleEvent(
     SaveablesLifecycleEvent::Pointer event)
 {
   events.lifecycleChange(event);
 }
 
 bool SaveablesList::PromptForSavingIfNecessary(
     IWorkbenchWindow::Pointer /*window*/, const Saveable::Set& /*modelsClosing*/,
     const QHash<Saveable::Pointer, int>& /*modelsDecrementing*/, bool /*canCancel*/)
 {
 //  List modelsToOptionallySave = new ArrayList();
 //  for (Iterator it = modelsDecrementing.keySet().iterator(); it.hasNext();)
 //  {
 //    Saveable modelDecrementing = (Saveable) it.next();
 //    if (modelDecrementing.isDirty() && !modelsClosing.contains(
 //        modelDecrementing))
 //    {
 //      modelsToOptionallySave.add(modelDecrementing);
 //    }
 //  }
 //
 //  boolean shouldCancel =
 //      modelsToOptionallySave.isEmpty() ? false : promptForSaving(
 //          modelsToOptionallySave, window, window, canCancel, true);
 //
 //  if (shouldCancel)
 //  {
 //    return true;
 //  }
 //
 //  List modelsToSave = new ArrayList();
 //  for (Iterator it = modelsClosing.iterator(); it.hasNext();)
 //  {
 //    Saveable modelClosing = (Saveable) it.next();
 //    if (modelClosing.isDirty())
 //    {
 //      modelsToSave.add(modelClosing);
 //    }
 //  }
 //  return modelsToSave.isEmpty() ? false : promptForSaving(modelsToSave, window,
 //      window, canCancel, false);
   return false;
 }
 
 void SaveablesList::FillModelsClosing(Saveable::Set& modelsClosing,
     const QHash<Saveable::Pointer, int>& modelsDecrementing)
 {
   for (QHash<Saveable::Pointer, int>::const_iterator it = modelsDecrementing.begin();
        it != modelsDecrementing.end(); ++it)
   {
     Saveable::Pointer model = it.key();
     if (it.value() == modelRefCounts[model])
     {
       modelsClosing.insert(model);
     }
   }
 }
 
 QList<Saveable::Pointer> SaveablesList::GetSaveables(
     IWorkbenchPart::Pointer part)
 {
   if (part.Cast<ISaveablesSource> () != 0)
   {
     ISaveablesSource::Pointer source = part.Cast<ISaveablesSource>();
     return source->GetSaveables();
   }
   else if (part.Cast<ISaveablePart> () != 0)
   {
     QList<Saveable::Pointer> result;
     Saveable::Pointer defaultSaveable(new DefaultSaveable(part));
     result.push_back(defaultSaveable);
     return result;
   }
   else
   {
     return QList<Saveable::Pointer>();
   }
 }
 
 Saveable::Set SaveablesList::GetOpenModels()
 {
   Saveable::Set allDistinctModels;
   for (QHash<Object*, Saveable::Set>::iterator it = modelMap.begin();
        it != modelMap.end(); ++it)
     allDistinctModels.unite(it.value());
 
   return allDistinctModels;
 }
 
 void SaveablesList::HandleLifecycleEvent(const SaveablesLifecycleEvent::Pointer& event)
 {
   if (event->GetSource().Cast<IWorkbenchPart> () == 0)
   {
     // just update the set of non-part sources. No prompting necessary.
     // See bug 139004.
     this->UpdateNonPartSource(event->GetSource().Cast<ISaveablesSource>());
     return;
   }
   QList<Saveable::Pointer> modelArray = event->GetSaveables();
   int eventType = event->GetEventType();
   if (eventType == SaveablesLifecycleEvent::POST_OPEN)
   {
     this->AddModels(event->GetSource(), modelArray);
   }
   else if (eventType == SaveablesLifecycleEvent::PRE_CLOSE)
   {
     QList<Saveable::Pointer> models = event->GetSaveables();
     QHash<Saveable::Pointer, int> modelsDecrementing;
     Saveable::Set modelsClosing;
     for (int i = 0; i < models.size(); i++)
     {
       this->IncrementRefCount(modelsDecrementing, models[i]);
     }
 
     this->FillModelsClosing(modelsClosing, modelsDecrementing);
     bool canceled = this->PromptForSavingIfNecessary(
         PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow(), modelsClosing,
         modelsDecrementing, !event->IsForce());
     if (canceled)
     {
       event->SetVeto(true);
     }
   }
   else if (eventType == SaveablesLifecycleEvent::POST_CLOSE)
   {
     this->RemoveModels(event->GetSource(), modelArray);
   }
   else if (eventType == SaveablesLifecycleEvent::DIRTY_CHANGED)
   {
     Object::Pointer source(this);
     SaveablesLifecycleEvent::Pointer lifeCycleEvent(
       new SaveablesLifecycleEvent(source, event->GetEventType(), event->GetSaveables(), false));
     this->FireModelLifecycleEvent(lifeCycleEvent);
   }
 }
 
 void SaveablesList::AddModelLifecycleListener(ISaveablesLifecycleListener* listener)
 {
   events.AddListener(listener);
 }
 
 void SaveablesList::RemoveModelLifecycleListener(ISaveablesLifecycleListener* listener)
 {
   events.RemoveListener(listener);
 }
 
 SaveablesList::PostCloseInfo::Pointer SaveablesList::PreCloseParts(
     const QList<IWorkbenchPart::Pointer>& partsToClose, bool save,
     IWorkbenchWindow::Pointer window)
 {
   // reference count (how many occurrences of a model will go away?)
   PostCloseInfo::Pointer postCloseInfo(new PostCloseInfo());
   for (QList<IWorkbenchPart::Pointer>::const_iterator it = partsToClose.begin();
        it != partsToClose.end(); ++it)
   {
     WorkbenchPart::Pointer part = it->Cast<WorkbenchPart>();
     postCloseInfo->partsClosing.push_back(part);
     if (part.Cast<ISaveablePart> () != 0)
     {
       ISaveablePart::Pointer saveablePart = part.Cast<ISaveablePart>();
       if (save && !saveablePart->IsSaveOnCloseNeeded())
       {
         // pretend for now that this part is not closing
         continue;
       }
     }
 //    if (save && part.Cast<ISaveablePart2> () != 0)
 //    {
 //      ISaveablePart2 saveablePart2 = (ISaveablePart2) part;
 //      // TODO show saveablePart2 before prompting, see
 //      // EditorManager.saveAll
 //      int response = SaveableHelper.savePart(saveablePart2, window, true);
 //      if (response == ISaveablePart2.CANCEL)
 //      {
 //        // user canceled
 //        return 0;
 //      }
 //      else if (response != ISaveablePart2.DEFAULT)
 //      {
 //        // only include this part in the following logic if it returned
 //        // DEFAULT
 //        continue;
 //      }
 //    }
     QList<Saveable::Pointer> modelsFromSource = this->GetSaveables(part);
     for (int i = 0; i < modelsFromSource.size(); i++)
     {
       this->IncrementRefCount(postCloseInfo->modelsDecrementing, modelsFromSource[i]);
     }
   }
   this->FillModelsClosing(postCloseInfo->modelsClosing,
       postCloseInfo->modelsDecrementing);
   if (save)
   {
     bool canceled = this->PromptForSavingIfNecessary(window,
         postCloseInfo->modelsClosing, postCloseInfo->modelsDecrementing, true);
     if (canceled)
     {
       return PostCloseInfo::Pointer(nullptr);
     }
   }
   return postCloseInfo;
 }
 
 bool SaveablesList::PromptForSaving(
     const QList<Saveable::Pointer>& /*modelsToSave*/,
     /*final IShellProvider shellProvider, IRunnableContext runnableContext,*/
     bool /*canCancel*/, bool /*stillOpenElsewhere*/)
 {
   //  // Save parts, exit the method if cancel is pressed.
   //  if (modelsToSave.size() > 0) {
   //    boolean canceled = SaveableHelper.waitForBackgroundSaveJobs(modelsToSave);
   //    if (canceled) {
   //      return true;
   //    }
   //
   //    IPreferenceStore apiPreferenceStore = PrefUtil.getAPIPreferenceStore();
   //    boolean dontPrompt = stillOpenElsewhere && !apiPreferenceStore.getBoolean(IWorkbenchPreferenceConstants.PROMPT_WHEN_SAVEABLE_STILL_OPEN);
   //
   //    if (dontPrompt) {
   //      modelsToSave.clear();
   //      return false;
   //    } else if (modelsToSave.size() == 1) {
   //      Saveable model = (Saveable) modelsToSave.get(0);
   //      // Show a dialog.
   //      QList<QString> buttons;
   //      if(canCancel) {
   //        buttons.push_back(IDialogConstants.YES_LABEL);
   //            buttons.push_back(IDialogConstants.NO_LABEL);
   //            buttons.push_back(IDialogConstants.CANCEL_LABEL);
   //      } else {
   //        buttons.push_back(IDialogConstants.YES_LABEL);
   //            buttons.push_back(IDialogConstants.NO_LABEL);
   //      }
   //
   //      // don't save if we don't prompt
   //      int choice = ISaveablePart2.NO;
   //
   //      MessageDialog dialog;
   //      if (stillOpenElsewhere) {
   //        String message = NLS
   //            .bind(
   //                WorkbenchMessages.EditorManager_saveChangesOptionallyQuestion,
   //                model.getName());
   //        MessageDialogWithToggle dialogWithToggle = new MessageDialogWithToggle(shellProvider.getShell(),
   //            WorkbenchMessages.Save_Resource, 0, message,
   //            MessageDialog.QUESTION, buttons, 0, WorkbenchMessages.EditorManager_closeWithoutPromptingOption, false) {
   //          protected int getShellStyle() {
   //            return (canCancel ? SWT.CLOSE : SWT.NONE)
   //                | SWT.TITLE | SWT.BORDER
   //                | SWT.APPLICATION_MODAL
   //                | getDefaultOrientation();
   //          }
   //        };
   //        dialog = dialogWithToggle;
   //      } else {
   //        String message = NLS
   //            .bind(
   //                WorkbenchMessages.EditorManager_saveChangesQuestion,
   //                model.getName());
   //        dialog = new MessageDialog(shellProvider.getShell(),
   //            WorkbenchMessages.Save_Resource, 0, message,
   //            MessageDialog.QUESTION, buttons, 0) {
   //          protected int getShellStyle() {
   //            return (canCancel ? SWT.CLOSE : SWT.NONE)
   //                | SWT.TITLE | SWT.BORDER
   //                | SWT.APPLICATION_MODAL
   //                | getDefaultOrientation();
   //          }
   //        };
   //      }
   //
   //      choice = SaveableHelper.testGetAutomatedResponse();
   //      if (SaveableHelper.testGetAutomatedResponse() == SaveableHelper.USER_RESPONSE) {
   //        choice = dialog.open();
   //
   //        if(stillOpenElsewhere) {
   //          // map value of choice back to ISaveablePart2 values
   //          switch (choice) {
   //          case IDialogConstants.YES_ID:
   //            choice = ISaveablePart2.YES;
   //            break;
   //          case IDialogConstants.NO_ID:
   //            choice = ISaveablePart2.NO;
   //            break;
   //          case IDialogConstants.CANCEL_ID:
   //            choice = ISaveablePart2.CANCEL;
   //            break;
   //          default:
   //            break;
   //          }
   //          MessageDialogWithToggle dialogWithToggle = (MessageDialogWithToggle) dialog;
   //          if (choice != ISaveablePart2.CANCEL && dialogWithToggle.getToggleState()) {
   //            apiPreferenceStore.setValue(IWorkbenchPreferenceConstants.PROMPT_WHEN_SAVEABLE_STILL_OPEN, false);
   //          }
   //        }
   //      }
   //
   //      // Branch on the user choice.
   //      // The choice id is based on the order of button labels
   //      // above.
   //      switch (choice) {
   //      case ISaveablePart2.YES: // yes
   //        break;
   //      case ISaveablePart2.NO: // no
   //        modelsToSave.clear();
   //        break;
   //      default:
   //      case ISaveablePart2.CANCEL: // cancel
   //        return true;
   //      }
   //    } else {
   //      MyListSelectionDialog dlg = new MyListSelectionDialog(
   //          shellProvider.getShell(),
   //          modelsToSave,
   //          new ArrayContentProvider(),
   //          new WorkbenchPartLabelProvider(),
   //          stillOpenElsewhere ? WorkbenchMessages.EditorManager_saveResourcesOptionallyMessage
   //              : WorkbenchMessages.EditorManager_saveResourcesMessage,
   //          canCancel, stillOpenElsewhere);
   //      dlg.setInitialSelections(modelsToSave.toArray());
   //      dlg.setTitle(EditorManager.SAVE_RESOURCES_TITLE);
   //
   //      // this "if" statement aids in testing.
   //      if (SaveableHelper.testGetAutomatedResponse() == SaveableHelper.USER_RESPONSE) {
   //        int result = dlg.open();
   //        // Just return 0 to prevent the operation continuing
   //        if (result == IDialogConstants.CANCEL_ID)
   //          return true;
   //
   //        if (dlg.getDontPromptSelection()) {
   //          apiPreferenceStore.setValue(IWorkbenchPreferenceConstants.PROMPT_WHEN_SAVEABLE_STILL_OPEN, false);
   //        }
   //
   //        modelsToSave = Arrays.asList(dlg.getResult());
   //      }
   //    }
   //  }
   //  // Create save block.
   //  return saveModels(modelsToSave, shellProvider, runnableContext);
   return true;
 }
 
 bool SaveablesList::SaveModels(const QList<Saveable::Pointer>& /*finalModels*/
 /*final IShellProvider shellProvider, IRunnableContext runnableContext*/)
 {
   //  IRunnableWithProgress progressOp = new IRunnableWithProgress() {
   //    public void run(IProgressMonitor monitor) {
   //      IProgressMonitor monitorWrap = new EventLoopProgressMonitor(
   //          monitor);
   //      monitorWrap.beginTask("", finalModels.size()); //$NON-NLS-1$
   //      for (Iterator i = finalModels.iterator(); i.hasNext();) {
   //        Saveable model = (Saveable) i.next();
   //        // handle case where this model got saved as a result of
   //        // saving another
   //        if (!model.isDirty()) {
   //          monitor.worked(1);
   //          continue;
   //        }
   //        SaveableHelper.doSaveModel(model, new SubProgressMonitor(monitorWrap, 1), shellProvider, true);
   //        if (monitorWrap.isCanceled())
   //          break;
   //      }
   //      monitorWrap.done();
   //    }
   //  };
   //
   //  // Do the save.
   //  return !SaveableHelper.runProgressMonitorOperation(
   //      WorkbenchMessages.Save_All, progressOp, runnableContext,
   //      shellProvider);
   return true;
 }
 
 void SaveablesList::PostClose(PostCloseInfo::Pointer postCloseInfo)
 {
   QList<Saveable::Pointer> removed;
   for (QList<WorkbenchPart::Pointer>::const_iterator it = postCloseInfo->partsClosing.begin();
       it != postCloseInfo->partsClosing.end(); ++it)
   {
     IWorkbenchPart::Pointer part = *it;
     QHash<Object*, Saveable::Set>::iterator it2 = modelMap.find(part.GetPointer());
     if (it2 != modelMap.end()) {
       // make a copy to avoid a ConcurrentModificationException - we
       // will remove from the original set as we iterate
       Saveable::Set saveables(it2.value());
       for (Saveable::Set::const_iterator it3 = saveables.begin();
           it3 != saveables.end(); ++it3)
       {
         if (RemoveModel(part, *it3)) {
           removed.push_back(*it3);
         }
       }
     }
   }
   if (!removed.empty()) {
     Object::Pointer source(this);
     SaveablesLifecycleEvent::Pointer event(new SaveablesLifecycleEvent(source,
         SaveablesLifecycleEvent::POST_CLOSE, removed, false));
     this->FireModelLifecycleEvent(event);
   }
 }
 
 void SaveablesList::PostOpen(IWorkbenchPart::Pointer part)
 {
   this->AddModels(part, this->GetSaveables(part));
 }
 
 void SaveablesList::DirtyChanged(IWorkbenchPart::Pointer part)
 {
   QList<Saveable::Pointer> saveables = this->GetSaveables(part);
   if (saveables.size() > 0) {
     Object::Pointer source(this);
     SaveablesLifecycleEvent::Pointer event(new SaveablesLifecycleEvent(source,
         SaveablesLifecycleEvent::DIRTY_CHANGED, saveables, false));
     this->FireModelLifecycleEvent(event);
   }
 }
 
 QList<Object::Pointer> SaveablesList::TestGetSourcesForModel(
     Saveable::Pointer /*model*/)
 {
   QList<Object::Pointer> result;
   //  for (Iterator it = modelMap.entrySet().iterator(); it.hasNext();) {
   //    Map.Entry entry = (Map.Entry) it.next();
   //    Set values = (Set) entry.getValue();
   //    if (values.contains(model)) {
   //      result.add(entry.getKey());
   //    }
   //  }
   return result;
 }
 
 QList<ISaveablesSource::Pointer> SaveablesList::GetNonPartSources()
 {
-  return nonPartSources.toList();
+  return nonPartSources.values();
 }
 
 QList<IWorkbenchPart::Pointer> SaveablesList::GetPartsForSaveable(
     Saveable::Pointer model)
 {
   QList<IWorkbenchPart::Pointer> result;
   for (QHash<Object*, Saveable::Set>::iterator it = modelMap.begin(); it
       != modelMap.end(); ++it)
   {
     Saveable::Set& values = it.value();
     IWorkbenchPart::Pointer part(dynamic_cast<IWorkbenchPart*>(it.key()));
     if (values.find(model) != values.end() && part)
     {
       result.push_back(part);
     }
   }
   return result;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berrySlaveHandlerService.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berrySlaveHandlerService.cpp
index 20177c4688..315bc51943 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berrySlaveHandlerService.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berrySlaveHandlerService.cpp
@@ -1,232 +1,232 @@
 /*============================================================================
 
 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 "berrySlaveHandlerService.h"
 
 #include "berryIHandler.h"
 #include "berryIHandlerActivation.h"
 #include "berryISourceProvider.h"
 
 #include "berryAndExpression.h"
 #include "berryHandlerActivation.h"
 #include "berryExecutionEvent.h"
 
 namespace berry {
 
 SlaveHandlerService::SlaveHandlerService(IHandlerService* parentHandlerService,
                     const SmartPointer<Expression>& defaultExpression)
   : defaultExpression(defaultExpression)
   , parent(parentHandlerService)
 {
   if (parentHandlerService == nullptr)
   {
     throw ctkInvalidArgumentException("The parent handler service cannot be null");
   }
 }
 
 SmartPointer<IHandlerActivation> SlaveHandlerService::ActivateHandler(const SmartPointer<IHandlerActivation>& childActivation)
 {
   const QString commandId = childActivation->GetCommandId();
   const IHandler::Pointer handler = childActivation->GetHandler();
   const Expression::Pointer childExpression = childActivation->GetExpression();
   Expression::Pointer expression = defaultExpression;
   if (childExpression.IsNotNull() && defaultExpression.IsNotNull())
   {
     const AndExpression::Pointer andExpression(new AndExpression());
     andExpression->Add(childExpression);
     andExpression->Add(defaultExpression);
     expression = andExpression;
   }
   else if (childExpression.IsNotNull())
   {
     expression = childExpression;
   }
   const int depth = childActivation->GetDepth() + 1;
   const IHandlerActivation::Pointer localActivation(
         new HandlerActivation(commandId, handler, expression, depth, this));
 
   return DoActivation(localActivation);
 }
 
 SmartPointer<IHandlerActivation> SlaveHandlerService::ActivateHandler(const QString& commandId,
                                                  const SmartPointer<IHandler>& handler)
 {
   const IHandlerActivation::Pointer localActivation(
         new HandlerActivation(commandId, handler, defaultExpression, IHandlerActivation::ROOT_DEPTH, this));
   return DoActivation(localActivation);
 }
 
 SmartPointer<IHandlerActivation> SlaveHandlerService::ActivateHandler(const QString& commandId,
                                                  const SmartPointer<IHandler>& handler,
                                                  const SmartPointer<Expression>& expression)
 {
   return ActivateHandler(commandId, handler, expression, false);
 }
 
 SmartPointer<IHandlerActivation> SlaveHandlerService::ActivateHandler(const QString& commandId,
                                                  const SmartPointer<IHandler>& handler,
                                                  const SmartPointer<Expression>& expression,
                                                  bool global)
 {
   if (global)
   {
     const IHandlerActivation::Pointer activation = parent->ActivateHandler(
           commandId, handler, expression, global);
     parentActivations.insert(activation);
     return activation;
   }
 
   Expression::Pointer aExpression = defaultExpression;
   if (expression.IsNotNull() && defaultExpression.IsNotNull())
   {
     const AndExpression::Pointer andExpression(new AndExpression());
     andExpression->Add(expression);
     andExpression->Add(defaultExpression);
     aExpression = andExpression;
   }
   else if (expression.IsNotNull())
   {
     aExpression = expression;
   }
   const IHandlerActivation::Pointer localActivation(
         new HandlerActivation(commandId, handler, aExpression, IHandlerActivation::ROOT_DEPTH, this));
   return DoActivation(localActivation);
 }
 
 void SlaveHandlerService::AddSourceProvider(const SmartPointer<ISourceProvider>& provider)
 {
   if (!fSourceProviders.contains(provider))
   {
     fSourceProviders.push_back(provider);
   }
   parent->AddSourceProvider(provider);
 }
 
 SmartPointer<const ExecutionEvent> SlaveHandlerService::CreateExecutionEvent(const SmartPointer<const Command>& command,
                                                         const SmartPointer<const UIElement>& event)
 {
   return parent->CreateExecutionEvent(command, event);
 }
 
 SmartPointer<const ExecutionEvent> SlaveHandlerService::CreateExecutionEvent(
     const SmartPointer<const ParameterizedCommand>& command,
     const SmartPointer<const UIElement>& event)
 {
   return parent->CreateExecutionEvent(command, event);
 }
 
 void SlaveHandlerService::DeactivateHandler(const SmartPointer<IHandlerActivation>& activation)
 {
   IHandlerActivation::Pointer parentActivation;
   if (localActivationsToParentActivations.contains(activation))
   {
     parentActivation = localActivationsToParentActivations.take(activation);
   }
   else
   {
     parentActivation = activation;
   }
 
   if (parentActivation.IsNotNull())
   {
     parent->DeactivateHandler(parentActivation);
     parentActivations.remove(parentActivation);
   }
 }
 
 void SlaveHandlerService::DeactivateHandlers(const QList<SmartPointer<IHandlerActivation> >& activations)
 {
   for (int i = 0; i < activations.size(); i++)
   {
     DeactivateHandler(activations[i]);
   }
 }
 
 void SlaveHandlerService::Dispose()
 {
-  parent->DeactivateHandlers(parentActivations.toList());
+  parent->DeactivateHandlers(parentActivations.values());
   parentActivations.clear();
   localActivationsToParentActivations.clear();
 
   // Remove any "resource", like listeners, that were associated
   // with this service.
   if (!fSourceProviders.isEmpty())
   {
     for (int i = 0; i < fSourceProviders.size(); i++)
     {
       RemoveSourceProvider(fSourceProviders[i]);
     }
     fSourceProviders.clear();
   }
 }
 
 Object::Pointer SlaveHandlerService::ExecuteCommand(const SmartPointer<ParameterizedCommand>& command,
                                const SmartPointer<const UIElement>& event)
 {
   return parent->ExecuteCommand(command, event);
 }
 
 Object::Pointer SlaveHandlerService::ExecuteCommand(const QString& commandId,
                                const SmartPointer<const UIElement>& event)
 {
   return parent->ExecuteCommand(commandId, event);
 }
 
 SmartPointer<IEvaluationContext> SlaveHandlerService::GetCurrentState() const
 {
   return parent->GetCurrentState();
 }
 
 void SlaveHandlerService::ReadRegistry()
 {
   parent->ReadRegistry();
 }
 
 void SlaveHandlerService::RemoveSourceProvider(const SmartPointer<ISourceProvider>& provider)
 {
   fSourceProviders.removeAll(provider);
   parent->RemoveSourceProvider(provider);
 }
 
 void SlaveHandlerService::SetHelpContextId(const SmartPointer<IHandler>& handler,
                       const QString& helpContextId)
 {
   parent->SetHelpContextId(handler, helpContextId);
 }
 
 SmartPointer<Expression> SlaveHandlerService::GetDefaultExpression() const
 {
   return defaultExpression;
 }
 
 SmartPointer<IEvaluationContext> SlaveHandlerService::CreateContextSnapshot(bool includeSelection)
 {
   return parent->CreateContextSnapshot(includeSelection);
 }
 
 Object::Pointer SlaveHandlerService::ExecuteCommandInContext(const SmartPointer<ParameterizedCommand>& command,
                                         const SmartPointer<const UIElement>& event,
                                         const SmartPointer<IEvaluationContext>& context)
 {
   return parent->ExecuteCommandInContext(command, event, context);
 }
 
 SmartPointer<IHandlerActivation> SlaveHandlerService::DoActivation(
     const SmartPointer<IHandlerActivation>& localActivation)
 {
   const IHandlerActivation::Pointer parentActivation = parent->ActivateHandler(localActivation);
   parentActivations.insert(parentActivation);
   localActivationsToParentActivations.insert(localActivation, parentActivation.GetPointer());
   return localActivation;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berrySourceProviderService.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berrySourceProviderService.cpp
index f0ce866065..4a80d065c4 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berrySourceProviderService.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berrySourceProviderService.cpp
@@ -1,81 +1,81 @@
 /*============================================================================
 
 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 "berrySourceProviderService.h"
 
 #include "berryAbstractSourceProvider.h"
 #include "berryWorkbenchServiceRegistry.h"
 
 namespace berry {
 
 SourceProviderService::SourceProviderService(IServiceLocator *locator)
   : locator(locator)
 {
 }
 
 void SourceProviderService::Dispose()
 {
   sourceProvidersByName.clear();
 }
 
 SmartPointer<ISourceProvider> SourceProviderService::GetSourceProvider(const QString& sourceName) const
 {
   return sourceProvidersByName.value(sourceName);
 }
 
 QList<SmartPointer<ISourceProvider> > SourceProviderService::GetSourceProviders() const
 {
-  return sourceProviders.toList();
+  return sourceProviders.values();
 }
 
 void SourceProviderService::RegisterProvider(const SmartPointer<ISourceProvider>& sourceProvider)
 {
   if (sourceProvider.IsNull())
   {
     throw ctkInvalidArgumentException("The source provider cannot be null");
   }
 
   const QList<QString> sourceNames = sourceProvider->GetProvidedSourceNames();
   for (int i = 0; i < sourceNames.size(); i++)
   {
     const QString sourceName = sourceNames[i];
     sourceProvidersByName.insert(sourceName, sourceProvider);
   }
   sourceProviders.insert(sourceProvider);
 }
 
 void SourceProviderService::UnregisterProvider(const SmartPointer<ISourceProvider>& sourceProvider)
 {
   if (sourceProvider.IsNull())
   {
     throw ctkInvalidArgumentException("The source provider cannot be null");
   }
 
   const QList<QString> sourceNames = sourceProvider->GetProvidedSourceNames();
   for (int i = 0; i < sourceNames.size(); i++)
   {
     sourceProvidersByName.remove(sourceNames[i]);
   }
   sourceProviders.remove(sourceProvider);
 }
 
 void SourceProviderService::ReadRegistry()
 {
   QList<AbstractSourceProvider::Pointer> sp = WorkbenchServiceRegistry::GetRegistry()->GetSourceProviders();
   for (int i = 0; i < sp.size(); i++)
   {
     sp[i]->Initialize(locator);
     RegisterProvider(sp[i]);
   }
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryWorkbenchWindowConfigurer.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryWorkbenchWindowConfigurer.cpp
index 1e0de9ace4..f51891885b 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryWorkbenchWindowConfigurer.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryWorkbenchWindowConfigurer.cpp
@@ -1,291 +1,291 @@
 /*============================================================================
 
 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 "berryWorkbenchWindowConfigurer.h"
 
 #include "berryWorkbenchWindow.h"
 #include "berryWorkbench.h"
 #include "berryWorkbenchPage.h"
 #include "berryEditorSashContainer.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryMenuManager.h"
 
 #include "berryQtDnDControlWidget.h"
 
 namespace berry
 {
 
 WorkbenchWindowConfigurer::WindowActionBarConfigurer::WindowActionBarConfigurer(WorkbenchWindow::WeakPtr wnd)
 : window(wnd)
 {
 
 }
 
 void WorkbenchWindowConfigurer::WindowActionBarConfigurer::SetProxy(IActionBarConfigurer::Pointer proxy)
 {
   this->proxy = proxy;
 }
 
 IWorkbenchWindowConfigurer::Pointer WorkbenchWindowConfigurer::WindowActionBarConfigurer::GetWindowConfigurer()
 {
   return WorkbenchWindow::Pointer(window)->GetWindowConfigurer();
 }
 
 IMenuManager* WorkbenchWindowConfigurer::WindowActionBarConfigurer::GetMenuManager()
 {
   if (proxy.IsNotNull())
   {
     return proxy->GetMenuManager();
   }
   return window.Lock()->GetMenuManager();
 }
 
 IToolBarManager* WorkbenchWindowConfigurer::WindowActionBarConfigurer::GetToolBarManager()
 {
   if (proxy.IsNotNull())
   {
     return proxy->GetToolBarManager();
   }
   //return window.Lock()->GetToolBarManager();
   return nullptr;
 }
 
 WorkbenchWindowConfigurer::WorkbenchWindowConfigurer(const WorkbenchWindow::Pointer& window)
  : shellStyle(nullptr)
  , showPerspectiveBar(false)
  , showStatusLine(true)
  , showToolBar(true)
  , showMenuBar(true)
  , showProgressIndicator(false)
  , dropTargetListener(nullptr)
  , initialSize(1632, 918) // 85% of 1920 x 1080 (FullHD, 1080p)
 {
   if (window.IsNull())
   {
     throw Poco::InvalidArgumentException();
   }
   this->window = window;
   windowTitle = "BlueBerry Application";
 }
 
 IWorkbenchWindow::Pointer WorkbenchWindowConfigurer::GetWindow()
 {
   return IWorkbenchWindow::Pointer(window);
 }
 
 IWorkbenchConfigurer::Pointer WorkbenchWindowConfigurer::GetWorkbenchConfigurer()
 {
   return dynamic_cast<Workbench*>(PlatformUI::GetWorkbench())->GetWorkbenchConfigurer();
 }
 
 QString WorkbenchWindowConfigurer::BasicGetTitle()
 {
   return windowTitle;
 }
 
 QString WorkbenchWindowConfigurer::GetTitle()
 {
   Shell::Pointer shell = window.Lock()->GetShell();
   if (shell)
   {
     // update the cached title
     windowTitle = shell->GetText();
   }
   return windowTitle;
 }
 
 void WorkbenchWindowConfigurer::SetTitle(const QString &title)
 {
   windowTitle = title;
   Shell::Pointer shell = window.Lock()->GetShell();
   if (shell)
   {
     shell->SetText(title);
   }
 }
 
 bool WorkbenchWindowConfigurer::GetShowMenuBar() const
 {
   return showMenuBar;
 }
 
 void WorkbenchWindowConfigurer::SetShowMenuBar(bool show)
 {
   showMenuBar = show;
 //  WorkbenchWindow win = (WorkbenchWindow) getWindow();
 //  Shell shell = win.getShell();
 //  if (shell != null)
 //  {
 //    boolean showing = shell.getMenuBar() != null;
 //    if (show != showing)
 //    {
 //      if (show)
 //      {
 //        shell.setMenuBar(win.getMenuBarManager().getMenu());
 //      }
 //      else
 //      {
 //        shell.setMenuBar(null);
 //      }
 //    }
 //  }
 }
 
 bool WorkbenchWindowConfigurer::GetShowToolBar() const
 {
   return showToolBar;
 }
 
 void WorkbenchWindowConfigurer::SetShowToolBar(bool show)
 {
   showToolBar = show;
   //window.setCoolBarVisible(show);
   // @issue need to be able to reconfigure after window's controls created
 }
 
 bool WorkbenchWindowConfigurer::GetShowPerspectiveBar() const
 {
   return showPerspectiveBar;
 }
 
 void WorkbenchWindowConfigurer::SetShowPerspectiveBar(bool show)
 {
   showPerspectiveBar = show;
   //window.setPerspectiveBarVisible(show);
   // @issue need to be able to reconfigure after window's controls created
 }
 
 bool WorkbenchWindowConfigurer::GetShowStatusLine() const
 {
   return showStatusLine;
 }
 
 void WorkbenchWindowConfigurer::SetShowStatusLine(bool show)
 {
   showStatusLine = show;
   // @issue need to be able to reconfigure after window's controls created
 }
 
 bool WorkbenchWindowConfigurer::GetShowProgressIndicator() const
 {
   return showProgressIndicator;
 }
 
 void WorkbenchWindowConfigurer::SetShowProgressIndicator(bool show)
 {
   showProgressIndicator = show;
   // @issue need to be able to reconfigure after window's controls created
 }
 
 void WorkbenchWindowConfigurer::AddEditorAreaTransfer(const QStringList& transfers)
 {
   if (transfers.isEmpty()) return;
 
   int oldSize = transferTypes.size();
   transferTypes.unite(QSet<QString>::fromList(transfers));
 
   if (transferTypes.size() == oldSize) return;
 
   WorkbenchPage::Pointer page = window.Lock()->GetActivePage().Cast<WorkbenchPage>();
   if (page)
   {
     QtDnDControlWidget* dropTarget =
         static_cast<QtDnDControlWidget*>(page->GetEditorPresentation()->GetLayoutPart().Cast<EditorSashContainer>()->GetParent());
-    dropTarget->SetTransferTypes(transferTypes.toList());
+    dropTarget->SetTransferTypes(transferTypes.values());
   }
 }
 
 void WorkbenchWindowConfigurer::ConfigureEditorAreaDropListener(IDropTargetListener* listener)
 {
   if (listener == nullptr) return;
   dropTargetListener = listener;
 
   WorkbenchPage::Pointer page = window.Lock()->GetActivePage().Cast<WorkbenchPage>();
   if (page)
   {
     QtDnDControlWidget* dropTarget =
         static_cast<QtDnDControlWidget*>(page->GetEditorPresentation()->GetLayoutPart().Cast<EditorSashContainer>()->GetParent());
     dropTarget->AddDropListener(listener);
   }
 }
 
 QStringList WorkbenchWindowConfigurer::GetTransfers() const
 {
-  return transferTypes.toList();
+  return transferTypes.values();
 }
 
 IDropTargetListener* WorkbenchWindowConfigurer::GetDropTargetListener() const
 {
   return dropTargetListener;
 }
 
 IActionBarConfigurer::Pointer WorkbenchWindowConfigurer::GetActionBarConfigurer()
 {
   if (actionBarConfigurer.IsNull())
   {
     // lazily initialize
     actionBarConfigurer = new WindowActionBarConfigurer(window);
   }
   return actionBarConfigurer;
 }
 
 Qt::WindowFlags WorkbenchWindowConfigurer::GetWindowFlags() const
 {
   return shellStyle;
 }
 
 void WorkbenchWindowConfigurer::SetWindowFlags(Qt::WindowFlags shellStyle)
 {
   this->shellStyle = shellStyle;
 }
 
 QPoint WorkbenchWindowConfigurer::GetInitialSize() const
 {
   return initialSize;
 }
 
 void WorkbenchWindowConfigurer::SetInitialSize(QPoint size)
 {
   initialSize = size;
 }
 
 void WorkbenchWindowConfigurer::CreateDefaultContents(Shell::Pointer shell)
 {
   WorkbenchWindow::Pointer(window)->CreateDefaultContents(shell);
 }
 
 QMenuBar* WorkbenchWindowConfigurer::CreateMenuBar()
 {
   return window.Lock()->GetMenuManager()->CreateMenuBar(window.Lock()->GetShell()->GetControl());
 }
 
 QWidget* WorkbenchWindowConfigurer::CreateToolBar(QWidget* /*parent*/)
 {
 //  IToolBarManager* toolBarManager = window->GetToolBarManager();
 //  if (toolBarManager)
 //  {
 //    return toolBarManager->CreateControl(parent);
 //  }
   return nullptr;
 }
 
 QWidget *WorkbenchWindowConfigurer::CreatePageComposite(QWidget *parent)
 {
   return WorkbenchWindow::Pointer(window)->CreatePageComposite(parent);
 }
 
 bool WorkbenchWindowConfigurer::SaveState(IMemento::Pointer memento)
 {
   return WorkbenchWindow::Pointer(window)->SaveState(memento);
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp b/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
index c4d49feb81..8fe1f286e6 100644
--- a/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
@@ -1,460 +1,460 @@
 /*============================================================================
 
 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 "berryViewTreeModel.h"
 
 #include "berryIViewRegistry.h"
 #include "berryIViewCategory.h"
 #include "berryIWorkbench.h"
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 
 #include "internal/intro/berryIntroConstants.h"
 #include "internal/berryKeywordRegistry.h"
 
 #include <QIcon>
 #include <QBrush>
 
 namespace berry {
 
 // --------------------------- Tree Item Classes ---------------------------
 
 struct ViewTreeItem;
 
 bool CompareViewTreeItem(ViewTreeItem* item1, ViewTreeItem* item2);
 
 struct ViewTreeItem
 {
   ViewTreeItem(ViewTreeModel* model)
     : m_parent(nullptr)
     , m_model(model)
   {}
 
   virtual ~ViewTreeItem()
   {
     QList<ViewTreeItem*> children = m_children;
     if (m_parent) m_parent->removeChild(this);
     qDeleteAll(children);
   }
 
   virtual QVariant data(int role)
   {
     if (role == ViewTreeModel::Keywords)
     {
       if (m_keywordCache.isEmpty())
       {
-        m_keywordCache = QStringList(keywordLabels().toList());
+        m_keywordCache = keywordLabels().values();
       }
       return m_keywordCache;
     }
     return QVariant();
   }
 
   virtual Qt::ItemFlags flags() const
   {
     return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
   }
 
   virtual QSet<QString> keywordLabels() const
   {
     return QSet<QString>();
   }
 
   void appendChild(ViewTreeItem* child)
   {
     m_children.push_back(child);
     child->m_parent = this;
     qSort(m_children.begin(), m_children.end(), CompareViewTreeItem);
   }
 
   void removeChild(ViewTreeItem* child)
   {
     m_children.removeAll(child);
   }
 
   QList<ViewTreeItem*> takeChildren()
   {
     QList<ViewTreeItem*> children = m_children;
     m_children.clear();
     return children;
   }
 
   ViewTreeItem* childItem(int row) const
   {
     if (row < 0 || row >= m_children.size()) return nullptr;
     return m_children.at(row);
   }
 
   ViewTreeItem* parentItem() const
   {
     return m_parent;
   }
 
   int childCount() const
   {
     return m_children.size();
   }
 
   int row() const
   {
     if (m_parent) return m_parent->rowIndex(this);
     return 0;
   }
 
   int rowIndex(const ViewTreeItem* child) const
   {
     return m_children.indexOf(const_cast<ViewTreeItem*>(child));
   }
 
   QList<ViewTreeItem*> m_children;
   ViewTreeItem* m_parent;
   ViewTreeModel* m_model;
 
 private:
 
   QStringList m_keywordCache;
 
 };
 
 bool CompareViewTreeItem(ViewTreeItem* item1, ViewTreeItem* item2)
 {
   return item1->data(Qt::DisplayRole).toString() < item2->data(Qt::DisplayRole).toString();
 }
 
 struct RootTreeItem : ViewTreeItem
 {
   RootTreeItem(ViewTreeModel* model) : ViewTreeItem(model) {}
 
   QVariant data(int /*role*/) override { return QVariant(); }
 };
 
 struct DescriptorTreeItem : ViewTreeItem
 {
   DescriptorTreeItem(ViewTreeModel* model, IViewDescriptor::Pointer descriptor, ViewTreeItem* parent = nullptr);
 
   QVariant data(int role) override;
 
 protected:
 
   QSet<QString> keywordLabels() const override;
 
   IViewDescriptor::Pointer m_descriptor;
 };
 
 struct CategoryTreeItem : ViewTreeItem
 {
   CategoryTreeItem(ViewTreeModel* model, IViewCategory::Pointer category, ViewTreeItem* parent = nullptr);
 
   QVariant data(int role) override;
 
   Qt::ItemFlags flags() const override;
 
 protected:
 
   QSet<QString> keywordLabels() const override;
 
   /**
    * Removes the temporary intro view from the list so that it cannot be activated except through
    * the introduction command.
    */
   void RemoveIntroView(QList<IViewDescriptor::Pointer>& list);
 
 private:
 
   void CreateChildren();
 
   IViewCategory::Pointer m_category;
 
 };
 
 // --------------------------- Tree Model Classes ---------------------------
 
 struct ViewTreeModel::Impl
 {
   Impl(const IWorkbenchWindow* window)
     : window(window)
     , viewRegistry(*window->GetWorkbench()->GetViewRegistry())
   {
 
   }
 
   const IWorkbenchWindow* window;
   IViewRegistry& viewRegistry;
 
   QScopedPointer<RootTreeItem> rootItem;
 };
 
 ViewTreeModel::ViewTreeModel(const IWorkbenchWindow* window, QObject* parent)
   : QAbstractItemModel(parent)
   , d(new Impl(window))
 {
   d->rootItem.reset(new RootTreeItem(this));
 
   QList<CategoryTreeItem*> categoryItems;
 
   QList<IViewCategory::Pointer> categories = d->viewRegistry.GetCategories();
   for (const auto &category : qAsConst(categories))
   {
     if (category->GetViews().isEmpty()) continue;
     CategoryTreeItem* categoryItem = new CategoryTreeItem(this, category);
     if (categoryItem->childCount() == 0)
     {
       delete categoryItem;
     }
     else
     {
       categoryItems.push_back(categoryItem);
     }
   }
 
 
   // if there is only one category, return it's children directly
   if (categoryItems.size() == 1)
   {
     QList<ViewTreeItem*> items = categoryItems.front()->takeChildren();
     for (auto item : qAsConst(items))
     {
       d->rootItem->appendChild(item);
     }
     qDeleteAll(categoryItems);
   }
   else
   {
     for (auto category : qAsConst(categoryItems))
     {
       d->rootItem->appendChild(category);
     }
   }
 }
 
 ViewTreeModel::~ViewTreeModel()
 {
 
 }
 
 QVariant ViewTreeModel::data(const QModelIndex& index, int role) const
 {
   if (!index.isValid()) return QVariant();
 
   return static_cast<ViewTreeItem*>(index.internalPointer())->data(role);
 }
 
 Qt::ItemFlags ViewTreeModel::flags(const QModelIndex& index) const
 {
   if (!index.isValid()) return {};
 
   return static_cast<ViewTreeItem*>(index.internalPointer())->flags();
 }
 
 QVariant ViewTreeModel::headerData(int section, Qt::Orientation /*orientation*/, int role) const
 {
   if (role == Qt::DisplayRole && section == 0)
   {
     return "View";
   }
   return QVariant();
 }
 
 QModelIndex ViewTreeModel::index(int row, int column, const QModelIndex& parent) const
 {
   if (!hasIndex(row, column, parent))
   {
     return QModelIndex();
   }
 
   ViewTreeItem* parentItem = nullptr;
   if (!parent.isValid())
   {
     parentItem = d->rootItem.data();
   }
   else
   {
     parentItem = static_cast<ViewTreeItem*>(parent.internalPointer());
   }
 
   ViewTreeItem* childItem = parentItem->childItem(row);
   if (childItem)
   {
     return createIndex(row, column, childItem);
   }
   return QModelIndex();
 }
 
 QModelIndex ViewTreeModel::parent(const QModelIndex& child) const
 {
   if (!child.isValid())
   {
     return QModelIndex();
   }
 
   ViewTreeItem* childItem = static_cast<ViewTreeItem*>(child.internalPointer());
   ViewTreeItem* parentItem = childItem->parentItem();
 
   if (parentItem == d->rootItem.data())
   {
     return QModelIndex();
   }
   return createIndex(parentItem->row(), 0, parentItem);
 }
 
 int ViewTreeModel::rowCount(const QModelIndex& parent) const
 {
   ViewTreeItem* parentItem = nullptr;
   if (parent.column() > 0) return 0;
 
   if (!parent.isValid())
   {
     parentItem = d->rootItem.data();
   }
   else
   {
     parentItem = static_cast<ViewTreeItem*>(parent.internalPointer());
   }
   return parentItem->childCount();
 }
 
 int ViewTreeModel::columnCount(const QModelIndex& /*parent*/) const
 {
   return 1;
 }
 
 const IWorkbenchWindow*ViewTreeModel::GetWorkbenchWindow() const
 {
   return d->window;
 }
 
 // --------------------------- DescriptorTreeItem  ---------------------------
 
 DescriptorTreeItem::DescriptorTreeItem(ViewTreeModel* model, IViewDescriptor::Pointer descriptor, ViewTreeItem* parent)
   : ViewTreeItem(model)
   , m_descriptor(descriptor)
 {
   if (parent) parent->appendChild(this);
 }
 
 QVariant DescriptorTreeItem::data(int role)
 {
   if (role == Qt::DisplayRole)
   {
     return m_descriptor->GetLabel();
   }
   else if (role == Qt::DecorationRole)
   {
     return m_descriptor->GetImageDescriptor();
   }
   else if (role == Qt::ForegroundRole)
   {
     IWorkbenchPage::Pointer page = this->m_model->GetWorkbenchWindow()->GetActivePage();
     if (page.IsNotNull())
     {
       if (page->FindViewReference(m_descriptor->GetId()).IsNotNull())
       {
         return QBrush(QColor(Qt::gray));
       }
     }
   }
   else if (role == ViewTreeModel::Description)
   {
     return m_descriptor->GetDescription();
   }
   else if (role == ViewTreeModel::Id)
   {
     return m_descriptor->GetId();
   }
   return ViewTreeItem::data(role);
 }
 
 QSet<QString> DescriptorTreeItem::keywordLabels() const
 {
   KeywordRegistry* registry = KeywordRegistry::GetInstance();
   QStringList ids = m_descriptor->GetKeywordReferences();
   QSet<QString> keywords;
   keywords.insert(m_descriptor->GetLabel());
   for(const auto &id : qAsConst(ids))
   {
     QString label = registry->GetKeywordLabel(id);
     for (const auto &keyword : label.split(' ', Qt::SkipEmptyParts))
     {
       keywords.insert(keyword);
     }
   }
   return keywords;
 }
 
 // --------------------------- CategoryTreeItem ---------------------------
 
 CategoryTreeItem::CategoryTreeItem(ViewTreeModel* model, IViewCategory::Pointer category, ViewTreeItem* parent)
   : ViewTreeItem(model)
   , m_category(category)
 {
   if (parent) parent->appendChild(this);
   this->CreateChildren();
 }
 
 QVariant CategoryTreeItem::data(int role)
 {
   if (role == Qt::DisplayRole)
   {
     return m_category->GetLabel();
   }
   else if (role == Qt::DecorationRole)
   {
     return QIcon::fromTheme("folder");
   }
   else if (role == ViewTreeModel::Id)
   {
     return m_category->GetId();
   }
   return ViewTreeItem::data(role);
 }
 
 Qt::ItemFlags CategoryTreeItem::flags() const
 {
   return Qt::ItemIsEnabled;
 }
 
 QSet<QString> CategoryTreeItem::keywordLabels() const
 {
   QSet<QString> keywords;
   for(auto child : this->m_children)
   {
     for (const auto &keyword : child->data(ViewTreeModel::Keywords).toStringList())
     {
       keywords.insert(keyword);
     }
   }
   return keywords;
 }
 
 void CategoryTreeItem::CreateChildren()
 {
   auto viewDescriptors = m_category->GetViews();
   RemoveIntroView(viewDescriptors);
   for(const auto &viewDescriptor : qAsConst(viewDescriptors))
   {
     new DescriptorTreeItem(this->m_model, viewDescriptor, this);
   }
 }
 
 void CategoryTreeItem::RemoveIntroView(QList<IViewDescriptor::Pointer>& list)
 {
   for (auto view = list.begin(); view != list.end();)
   {
     if ((*view)->GetId() == IntroConstants::INTRO_VIEW_ID)
     {
       view = list.erase(view);
     }
     else ++view;
   }
 }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
index c706326752..f0e7398335 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
@@ -1,117 +1,118 @@
 /*============================================================================
 
 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 <QmitkAbstractDataNodeAction.h>
 
 #include "mitkIRenderWindowPart.h"
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // berry
 #include <berryIWorkbenchPage.h>
 
 QList<mitk::DataNode::Pointer> AbstractDataNodeAction::GetSelectedNodes(berry::IWorkbenchPartSite::Pointer workbenchPartSite)
 {
   QList<mitk::DataNode::Pointer> selectedNodes;
   if (workbenchPartSite.IsNull())
   {
     return selectedNodes;
   }
 
   berry::ISelection::ConstPointer selection = workbenchPartSite->GetWorkbenchWindow()->GetSelectionService()->GetSelection();
   mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
   if (currentSelection.IsNull() || currentSelection->IsEmpty())
   {
     return selectedNodes;
   }
 
-  selectedNodes = QList<mitk::DataNode::Pointer>::fromStdList(currentSelection->GetSelectedDataNodes());
+  auto nodes = currentSelection->GetSelectedDataNodes();
+  selectedNodes = QList<mitk::DataNode::Pointer>(nodes.begin(), nodes.end());
   return selectedNodes;
 }
 
 QmitkAbstractDataNodeAction::QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer workbenchPartSite)
 {
   m_WorkbenchPartSite = workbenchPartSite;
 }
 
 QmitkAbstractDataNodeAction::QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite* workbenchPartSite)
 {
   m_WorkbenchPartSite = berry::IWorkbenchPartSite::Pointer(workbenchPartSite);
 }
 
 void QmitkAbstractDataNodeAction::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage != dataStorage)
   {
     // set the new data storage
     m_DataStorage = dataStorage;
   }
 }
 
 void QmitkAbstractDataNodeAction::SetSelectedNodes(const QList<mitk::DataNode::Pointer>& selectedNodes)
 {
   m_SelectedNodes = selectedNodes;
   // use the first selected node to initialize the data node actions
   InitializeWithDataNode(m_SelectedNodes.front());
 }
 
 void QmitkAbstractDataNodeAction::SetBaseRenderer(mitk::BaseRenderer* baseRenderer)
 {
   if (m_BaseRenderer != baseRenderer)
   {
     // set the new base renderer
     m_BaseRenderer = baseRenderer;
   }
 }
 
 mitk::BaseRenderer::Pointer QmitkAbstractDataNodeAction::GetBaseRenderer()
 {
   return m_BaseRenderer.Lock();
 }
 
 QList<mitk::DataNode::Pointer> QmitkAbstractDataNodeAction::GetSelectedNodes() const
 {
   if (!m_SelectedNodes.isEmpty())
   {
     return m_SelectedNodes;
   }
 
   auto workbenchPartSite = m_WorkbenchPartSite.Lock();
 
   if (workbenchPartSite.IsNull())
   {
     // return empty list of selected nodes
     return m_SelectedNodes;
   }
 
   // retrieve selection from the workbench selection service
   return AbstractDataNodeAction::GetSelectedNodes(workbenchPartSite);
 }
 
 mitk::DataNode::Pointer QmitkAbstractDataNodeAction::GetSelectedNode() const
 {
   QList<mitk::DataNode::Pointer> selectedNodes = GetSelectedNodes();
   if (selectedNodes.empty())
   {
     return nullptr;
   }
 
   // no batch action; should only be called with a single node
   mitk::DataNode::Pointer dataNode = selectedNodes.front();
   if (nullptr == dataNode)
   {
     return nullptr;
   }
 
   return dataNode;
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
index b7e0afe75d..33107498da 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
@@ -1,488 +1,489 @@
 /*============================================================================
 
 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 <QmitkDataNodeContextMenu.h>
 
 #include <QmitkCustomVariants.h>
 #include <QmitkFileSaveAction.h>
 #include <QmitkNodeDescriptorManager.h>
 
 #include <mitkDataNodeSelection.h>
 #include <mitkIContextMenuAction.h>
 
 #include <berryAbstractUICTKPlugin.h>
 #include <berryIContributor.h>
 #include <berryIExtensionRegistry.h>
 #include <berryISelectionService.h>
 #include <berryPlatform.h>
 
 QmitkDataNodeContextMenu::QmitkDataNodeContextMenu(berry::IWorkbenchPartSite::Pointer workbenchPartSite, QWidget* parent)
   : QMenu(parent),
     m_Parent(parent),
     m_WorkbenchPartSite(workbenchPartSite)
 {
   this->InitNodeDescriptors();
   this->InitDefaultActions();
   this->InitExtensionPointActions();
 }
 
 QmitkDataNodeContextMenu::~QmitkDataNodeContextMenu()
 {
   for (auto& descriptorActionPair : m_DescriptorActionList)
     descriptorActionPair.first->RemoveAction(descriptorActionPair.second);
 }
 
 void QmitkDataNodeContextMenu::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   m_DataStorage = dataStorage;
 
   for (auto& descriptorActionPair : m_DescriptorActionList)
   {
     auto dataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(descriptorActionPair.second);
 
     if (nullptr != dataNodeAction)
       dataNodeAction->SetDataStorage(dataStorage);
   }  
 }
 
 void QmitkDataNodeContextMenu::SetBaseRenderer(mitk::BaseRenderer* baseRenderer)
 {
   m_BaseRenderer = baseRenderer;
 
   for (auto& descriptorActionPair : m_DescriptorActionList)
   {
     auto dataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(descriptorActionPair.second);
 
     if (nullptr != dataNodeAction)
       dataNodeAction->SetBaseRenderer(baseRenderer);
   }
 }
 
 void QmitkDataNodeContextMenu::SetSurfaceDecimation(bool surfaceDecimation)
 {
   m_SurfaceDecimation = surfaceDecimation;
 }
 
 void QmitkDataNodeContextMenu::SetSelectedNodes(const QList<mitk::DataNode::Pointer>& selectedNodes)
 {
   m_SelectedNodes = selectedNodes;
 }
 
 void QmitkDataNodeContextMenu::InitNodeDescriptors()
 {
   auto nodeDescriptorManager = QmitkNodeDescriptorManager::GetInstance();
 
   m_UnknownDataNodeDescriptor = nodeDescriptorManager->GetUnknownDataNodeDescriptor();
   m_ImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("Image");
   m_MultiComponentImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("MultiComponentImage");
   m_DiffusionImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("DiffusionImage");
   m_FiberBundleDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("FiberBundle");
   m_PeakImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("PeakImage");
   m_SegmentDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("Segment");
   m_SurfaceDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("Surface");
   m_PointSetNodeDescriptor = nodeDescriptorManager->GetDescriptor("PointSet");
   m_PlanarLineNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarLine");
   m_PlanarCircleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarCircle");
   m_PlanarEllipseNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarEllipse");
   m_PlanarAngleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarAngle");
   m_PlanarFourPointAngleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarFourPointAngle");
   m_PlanarRectangleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarRectangle");
   m_PlanarPolygonNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarPolygon");
   m_PlanarPathNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarPath");
   m_PlanarDoubleEllipseNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarDoubleEllipse");
   m_PlanarBezierCurveNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarBezierCurve");
   m_PlanarSubdivisionPolygonNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarSubdivisionPolygon");
 }
 
 void QmitkDataNodeContextMenu::InitDefaultActions()
 {
   auto workbenchPartSite = m_WorkbenchPartSite.Lock();
 
   m_GlobalReinitAction = new QmitkDataNodeGlobalReinitAction(m_Parent, workbenchPartSite);
   m_GlobalReinitAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_GlobalReinitAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_GlobalReinitAction));
 
   m_ReinitAction = new QmitkDataNodeReinitAction(m_Parent, workbenchPartSite);
   m_ReinitAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ReinitAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ReinitAction));
 
   m_ResetGeometryAction = new QmitkDataNodeResetGeometryAction(m_Parent, workbenchPartSite);
   m_ResetGeometryAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ResetGeometryAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ResetGeometryAction));
 
   QAction* saveAction = new QmitkFileSaveAction(QIcon(":/org.mitk.gui.qt.datamanager/Save_48.png"), workbenchPartSite->GetWorkbenchWindow());
   m_UnknownDataNodeDescriptor->AddAction(saveAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, saveAction));
 
   m_RemoveAction = new QmitkDataNodeRemoveAction(m_Parent, workbenchPartSite);
   m_RemoveAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Remove_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_RemoveAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_RemoveAction));
 
   m_ShowSelectedNodesAction = new QmitkDataNodeShowSelectedNodesAction(m_Parent, workbenchPartSite);
   m_ShowSelectedNodesAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/ShowSelectedNode_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ShowSelectedNodesAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ShowSelectedNodesAction));
 
   m_ToggleVisibilityAction = new QmitkDataNodeToggleVisibilityAction(m_Parent, workbenchPartSite);
   m_ToggleVisibilityAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/InvertShowSelectedNode_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ToggleVisibilityAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ToggleVisibilityAction));
 
   m_ShowDetailsAction = new QmitkDataNodeShowDetailsAction(m_Parent, workbenchPartSite);
   m_ShowDetailsAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/ShowDataInfo_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ShowDetailsAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ShowDetailsAction));
 
   m_OpacityAction = new QmitkDataNodeOpacityAction(m_Parent, workbenchPartSite);
   m_UnknownDataNodeDescriptor->AddAction(m_OpacityAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_OpacityAction));
 
   m_ColorAction = new QmitkDataNodeColorAction(m_Parent, workbenchPartSite);
   this->AddColorAction(m_ColorAction);
 
   m_ColormapAction = new QmitkDataNodeColorMapAction(m_Parent, workbenchPartSite);
   m_ImageDataNodeDescriptor->AddAction(m_ColormapAction);
   m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, m_ColormapAction));
 
   if (nullptr != m_DiffusionImageDataNodeDescriptor)
   {
     m_DiffusionImageDataNodeDescriptor->AddAction(m_ColormapAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_ColormapAction));
   }
 
   m_ComponentAction = new QmitkDataNodeComponentAction(m_Parent, workbenchPartSite);
   m_MultiComponentImageDataNodeDescriptor->AddAction(m_ComponentAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_MultiComponentImageDataNodeDescriptor, m_ComponentAction));
 
   if (nullptr != m_DiffusionImageDataNodeDescriptor)
   {
     m_DiffusionImageDataNodeDescriptor->AddAction(m_ComponentAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_ComponentAction));
   }
 
   m_TextureInterpolationAction = new QmitkDataNodeTextureInterpolationAction(m_Parent, workbenchPartSite);
   m_ImageDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, m_TextureInterpolationAction));
 
   if (nullptr != m_DiffusionImageDataNodeDescriptor)
   {
     m_DiffusionImageDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_TextureInterpolationAction));
   }
 
   if (nullptr != m_SegmentDataNodeDescriptor)
   {
     m_SegmentDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_SegmentDataNodeDescriptor, m_TextureInterpolationAction));
   }
 
   m_SurfaceRepresentationAction = new QmitkDataNodeSurfaceRepresentationAction(m_Parent, workbenchPartSite);
   m_SurfaceDataNodeDescriptor->AddAction(m_SurfaceRepresentationAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_SurfaceDataNodeDescriptor, m_SurfaceRepresentationAction));
 }
 
 void QmitkDataNodeContextMenu::InitExtensionPointActions()
 {
   auto extensionPointService = berry::Platform::GetExtensionRegistry();
   auto customMenuConfigs = extensionPointService->GetConfigurationElementsFor("org.mitk.gui.qt.datamanager.contextMenuActions");
 
   DescriptorActionListType descriptorActionList;
   m_ConfigElements.clear();
 
   for (const auto& customMenuConfig : qAsConst(customMenuConfigs))
   {
     auto descriptorName = customMenuConfig->GetAttribute("nodeDescriptorName");
     auto actionLabel = customMenuConfig->GetAttribute("label");
     auto actionClass = customMenuConfig->GetAttribute("class");
 
     if (descriptorName.isEmpty() || actionLabel.isEmpty() || actionClass.isEmpty())
       continue;
 
     auto descriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(descriptorName);
 
     if (nullptr == descriptor)
     {
       MITK_WARN << "Cannot add action \"" << actionLabel << "\" to non-existent descriptor \"" << descriptorName << "\".";
       continue;
     }
 
     QAction* action = nullptr;
     auto actionIcon = customMenuConfig->GetAttribute("icon");
 
     if (!actionIcon.isEmpty())
     {
       QIcon icon = !QFile::exists(actionIcon)
         ? berry::AbstractUICTKPlugin::ImageDescriptorFromPlugin(customMenuConfig->GetContributor()->GetName(), actionIcon)
         : QIcon(actionIcon);
 
       action = new QAction(icon, actionLabel, m_Parent);
     }
     else
     {
       action = new QAction(actionLabel, m_Parent);
     }
 
     if (nullptr != action)
     {
       // See T26938. We do not know why but without the lambda function indirection, the
       // connection is lost after the content menu was shown for the first time.
       connect(action, &QAction::triggered, [action, this]()
       {
         this->OnExtensionPointActionTriggered(action);
       });
 
       m_ConfigElements[action] = customMenuConfig;
       descriptorActionList.push_back(std::make_pair(descriptor, action));
     }
   }
 
   this->AddDescriptorActionList(descriptorActionList);
 }
 
 void QmitkDataNodeContextMenu::InitServiceActions()
 {
 }
 
 void QmitkDataNodeContextMenu::OnContextMenuRequested(const QPoint& /*pos*/)
 {
   auto workbenchPartSite = m_WorkbenchPartSite.Lock();
 
   if (workbenchPartSite.IsNull())
     return;
 
   auto selection = workbenchPartSite->GetWorkbenchWindow()->GetSelectionService()->GetSelection()
     .Cast<const mitk::DataNodeSelection>();
 
   if (selection.IsNull() || selection->IsEmpty())
     return;
 
-  m_SelectedNodes = QList<mitk::DataNode::Pointer>::fromStdList(selection->GetSelectedDataNodes());
+  auto nodes = selection->GetSelectedDataNodes();
+  m_SelectedNodes = QList<mitk::DataNode::Pointer>(nodes.begin(), nodes.end());
 
   if (!m_SelectedNodes.isEmpty())
   {
     this->clear();
 
     auto actions = m_SelectedNodes.size() == 1
       ? this->GetActions(m_SelectedNodes.front())
       : this->GetActions(m_SelectedNodes);
 
     for (auto& action : actions)
     {
       auto dataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(action);
 
       if (nullptr != dataNodeAction)
         dataNodeAction->SetSelectedNodes(m_SelectedNodes);
     }
 
     this->addActions(actions);
     this->popup(QCursor::pos());
   }
 }
 
 void QmitkDataNodeContextMenu::OnExtensionPointActionTriggered(QAction* action)
 {
   auto configElementIter = m_ConfigElements.find(action);
 
   if (m_ConfigElements.end() == configElementIter)
   {
     MITK_WARN << "Associated configuration element for action \"" << action->text() << "\" not found.";
     return;
   }
 
   auto configElement = configElementIter->second;
   auto contextMenuAction = configElement->CreateExecutableExtension<mitk::IContextMenuAction>("class");
   auto dataStorage = m_DataStorage.Lock();
 
   if (dataStorage.IsNotNull())
     contextMenuAction->SetDataStorage(dataStorage);
 
   if ("QmitkCreatePolygonModelAction" == configElement->GetAttribute("class"))
   {
     contextMenuAction->SetSmoothed("true" == configElement->GetAttribute("smoothed"));
     contextMenuAction->SetDecimated(m_SurfaceDecimation);
   }
 
   contextMenuAction->Run(m_SelectedNodes);
 }
 
 void QmitkDataNodeContextMenu::AddColorAction(QWidgetAction* colorAction)
 {
   if (nullptr != m_ImageDataNodeDescriptor)
   {
     m_ImageDataNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_MultiComponentImageDataNodeDescriptor)
   {
     m_MultiComponentImageDataNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_MultiComponentImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_DiffusionImageDataNodeDescriptor)
   {
     m_DiffusionImageDataNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_FiberBundleDataNodeDescriptor)
   {
     m_FiberBundleDataNodeDescriptor->AddAction(colorAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_FiberBundleDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PeakImageDataNodeDescriptor)
   {
     m_PeakImageDataNodeDescriptor->AddAction(colorAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_PeakImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_SegmentDataNodeDescriptor)
   {
     m_SegmentDataNodeDescriptor->AddAction(colorAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_SegmentDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_SurfaceDataNodeDescriptor)
   {
     m_SurfaceDataNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_SurfaceDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PointSetNodeDescriptor)
   {
     m_PointSetNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PointSetNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarLineNodeDescriptor)
   {
     m_PlanarLineNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarLineNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarCircleNodeDescriptor)
   {
     m_PlanarCircleNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarCircleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarEllipseNodeDescriptor)
   {
     m_PlanarEllipseNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarEllipseNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarAngleNodeDescriptor)
   {
     m_PlanarAngleNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarAngleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarFourPointAngleNodeDescriptor)
   {
     m_PlanarFourPointAngleNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarFourPointAngleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarRectangleNodeDescriptor)
   {
     m_PlanarRectangleNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarRectangleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarPolygonNodeDescriptor)
   {
     m_PlanarPolygonNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarPolygonNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarPathNodeDescriptor)
   {
     m_PlanarPathNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarPathNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarDoubleEllipseNodeDescriptor)
   {
     m_PlanarDoubleEllipseNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarDoubleEllipseNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarBezierCurveNodeDescriptor)
   {
     m_PlanarBezierCurveNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarBezierCurveNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarSubdivisionPolygonNodeDescriptor)
   {
     m_PlanarSubdivisionPolygonNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarSubdivisionPolygonNodeDescriptor, colorAction));
   }
 }
 
 void QmitkDataNodeContextMenu::AddDescriptorActionList(DescriptorActionListType& descriptorActionList)
 {
   using ListItem = std::pair<QmitkNodeDescriptor*, QAction*>;
 
   std::sort(descriptorActionList.begin(), descriptorActionList.end(), [](const ListItem& left, const ListItem& right) -> bool
   {
     return left.second->text() < right.second->text();
   });
 
   for (auto& descriptorActionPair : descriptorActionList)
   {
     descriptorActionPair.first->AddAction(descriptorActionPair.second);
     m_DescriptorActionList.push_back(descriptorActionPair);
   }
 }
 
 QList<QAction*> QmitkDataNodeContextMenu::GetActions(const mitk::DataNode* node)
 {
   QList<QAction*> actions;
 
   for(const auto& descriptorActionPair : m_DescriptorActionList)
   {
     if (descriptorActionPair.first->CheckNode(node) || "Unknown" == descriptorActionPair.first->GetNameOfClass())
       actions.append(descriptorActionPair.second);
   }
 
   return actions;
 }
 
 QList<QAction*> QmitkDataNodeContextMenu::GetActions(const QList<mitk::DataNode::Pointer>& nodes)
 {
   QList<QAction*> actions;
 
   for (const auto& descriptorActionPair : m_DescriptorActionList)
   {
     for (const auto& node : nodes)
     {
       if (descriptorActionPair.first->CheckNode(node) || "Unknown" == descriptorActionPair.first->GetNameOfClass())
       {
         auto batchActions = descriptorActionPair.first->GetBatchActions();
 
         if (std::find(batchActions.begin(), batchActions.end(), descriptorActionPair.second) != batchActions.end())
           actions.append(descriptorActionPair.second);
 
         break;
       }
     }
   }
 
   return actions;
 }
diff --git a/Plugins/org.mitk.gui.qt.chartExample/src/internal/QmitkChartExampleView.cpp b/Plugins/org.mitk.gui.qt.chartExample/src/internal/QmitkChartExampleView.cpp
index 1adeb0b41b..82dd8e35f3 100644
--- a/Plugins/org.mitk.gui.qt.chartExample/src/internal/QmitkChartExampleView.cpp
+++ b/Plugins/org.mitk.gui.qt.chartExample/src/internal/QmitkChartExampleView.cpp
@@ -1,452 +1,452 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 // Blueberry
 #include <berryIQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 
 // Qmitk
 #include "QmitkChartExampleView.h"
 #include <QmitkChartxyData.h>
 
 const std::string QmitkChartExampleView::VIEW_ID = "org.mitk.views.qmitkchartexample";
 
 void QmitkChartExampleView::SetFocus()
 {
   m_Controls.m_buttonCreateChart->setFocus();
 }
 
 void QmitkChartExampleView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   CreateConnectionsForGUIElements();
   connect(m_Controls.m_comboBoxChartType, &QComboBox::currentTextChanged, this, &QmitkChartExampleView::AdaptDataGUI);
 
   m_Controls.m_lineEditDataXVector->setText("0;1;2;3;4;5;6;7;8;9");
   m_Controls.m_lineEditDataYVector->setText("0;1;2;3;4;5;6;7;8;9");
   m_Controls.m_lineEditDataLabel->setText("Test");
   m_Controls.m_lineEditXAxisLabel->setText("X-Axis");
   m_Controls.m_lineEditYAxisLabel->setText("Y-Axis");
   m_Controls.m_lineEditTitle->setText("Title");
 
   m_Controls.m_labelPieData->setVisible(false);
   m_Controls.m_lineEditPieDataLabel->setVisible(false);
 
   m_Controls.m_groupBoxErrors->setVisible(false);
   m_Controls.m_groupBoxXErrors->setVisible(false);
   m_Controls.m_groupBoxYErrors->setVisible(false);
 
   m_Controls.m_doubleSpinBox_maxZoomX->setValue(10);
   m_Controls.m_doubleSpinBox_maxZoomY->setValue(10);
 
   m_AxisScaleNameToAxisScaleType.emplace("linear", QmitkChartWidget::AxisScale::linear);
   m_AxisScaleNameToAxisScaleType.emplace("logarithmic", QmitkChartWidget::AxisScale::log);
 
   m_LegendPositionNameToLegendPositionType.emplace("bottom middle", QmitkChartWidget::LegendPosition::bottomMiddle);
   m_LegendPositionNameToLegendPositionType.emplace("bottom right", QmitkChartWidget::LegendPosition::bottomRight);
   m_LegendPositionNameToLegendPositionType.emplace("top right", QmitkChartWidget::LegendPosition::topRight);
   m_LegendPositionNameToLegendPositionType.emplace("top left", QmitkChartWidget::LegendPosition::topLeft);
   m_LegendPositionNameToLegendPositionType.emplace("middle right", QmitkChartWidget::LegendPosition::middleRight);
 }
 
 void QmitkChartExampleView::CreateConnectionsForGUIElements()
 {
   connect(m_Controls.m_buttonCreateChart, &QPushButton::clicked, this, &QmitkChartExampleView::CreateChart);
   connect(m_Controls.m_buttonUpdateData, &QPushButton::clicked, this, &QmitkChartExampleView::UpdateData);
   connect(m_Controls.m_buttonClearChart, &QPushButton::clicked, this, &QmitkChartExampleView::ClearChart);
   connect(m_Controls.m_buttonAddData, &QPushButton::clicked, this, &QmitkChartExampleView::AddData);
   connect(m_Controls.m_comboBoxExistingData, &QComboBox::currentTextChanged, this, &QmitkChartExampleView::UpdateSelectedData);
   connect(m_Controls.m_checkBoxEnableErrors, &QCheckBox::toggled, this, &QmitkChartExampleView::ShowErrorOptions);
   connect(m_Controls.m_checkBoxEnableXErrors, &QCheckBox::toggled, this, &QmitkChartExampleView::ShowXErrorOptions);
   connect(m_Controls.m_checkBoxEnableYErrors, &QCheckBox::toggled, this, &QmitkChartExampleView::ShowYErrorOptions);
   connect(m_Controls.m_doubleSpinBox_minZoomX, &QSpinBox::editingFinished, this, &QmitkChartExampleView::AdaptZoomX);
   connect(m_Controls.m_doubleSpinBox_maxZoomX, &QSpinBox::editingFinished, this, &QmitkChartExampleView::AdaptZoomX);
   connect(m_Controls.m_doubleSpinBox_minZoomY, &QSpinBox::editingFinished, this, &QmitkChartExampleView::AdaptZoomY);
   connect(m_Controls.m_doubleSpinBox_maxZoomY, &QSpinBox::editingFinished, this, &QmitkChartExampleView::AdaptZoomY);
   connect(m_Controls.m_comboBoxLegendPosition, &QComboBox::currentTextChanged, this, &QmitkChartExampleView::OnLegendPositionChanged);
   connect(m_Controls.m_lineEditTitle, &QLineEdit::editingFinished, this, &QmitkChartExampleView::OnTitleChanged);
   connect(m_Controls.m_lineEditXAxisLabel, &QLineEdit::editingFinished, this, &QmitkChartExampleView::OnXAxisLabelChanged);
   connect(m_Controls.m_lineEditYAxisLabel, &QLineEdit::editingFinished, this, &QmitkChartExampleView::OnYAxisLabelChanged);
   connect(m_Controls.m_comboBoxYAxisScale, &QComboBox::currentTextChanged, this, &QmitkChartExampleView::OnYAxisScaleChanged);
   connect(m_Controls.m_checkBoxShowLegend, &QCheckBox::stateChanged, this, &QmitkChartExampleView::OnShowLegendChanged);
   connect(m_Controls.m_checkBoxStackedData, &QCheckBox::stateChanged, this, &QmitkChartExampleView::OnStackedDataChanged);
   connect(m_Controls.m_checkBoxShowDataPoints, &QCheckBox::stateChanged, this, &QmitkChartExampleView::OnShowDataPointsChanged);
   connect(m_Controls.m_checkBoxShowSubchart, &QCheckBox::stateChanged, this, &QmitkChartExampleView::OnShowSubchartChanged);
 }
 
 void QmitkChartExampleView::AddData()
 {
     QString lineEditDataX = m_Controls.m_lineEditDataXVector->text();
     QString lineEditDataY = m_Controls.m_lineEditDataYVector->text();
     auto dataX = ConvertToDoubleVector(lineEditDataX);
     auto dataY = ConvertToDoubleVector(lineEditDataY);
     auto dataXandY = CreatePairList(dataX, dataY);
     QString data = QString::fromStdString(ConvertToText(dataXandY));
 
     std::string dataLabel = m_Controls.m_lineEditDataLabel->text().toStdString();
     std::string chartTypeAsString = m_Controls.m_comboBoxChartType->currentText().toStdString();
     std::string chartColorAsString = m_Controls.m_comboBoxColor->currentText().toStdString();
     std::string chartLineStyleAsString = m_Controls.m_comboBoxLineStyle->currentText().toStdString();
     std::string pieLabelsAsString = m_Controls.m_lineEditPieDataLabel->text().toStdString();
 
     if (std::find(labelStorage.begin(), labelStorage.end(), dataLabel) != labelStorage.end())
     {
         m_Controls.m_labelInfo->setText("This data already exists");
         m_Controls.m_labelInfo->setStyleSheet("color: red;");
         return;
     }
 
     if (dataX.size() != dataY.size())
     {
         m_Controls.m_labelInfo->setText("Data x and y size have to be equal");
         m_Controls.m_labelInfo->setStyleSheet("color: red;");
         return;
     }
 
     labelStorage.push_back(dataLabel);
     m_Controls.m_Chart->AddChartExampleData(dataXandY, dataLabel, chartTypeAsString, chartColorAsString, chartLineStyleAsString, pieLabelsAsString);
     m_Controls.m_comboBoxExistingData->addItem(m_Controls.m_lineEditDataLabel->text());
 
     if (m_Controls.m_checkBoxEnableErrors->isChecked())
     {
         if (m_Controls.m_checkBoxEnableXErrors->isChecked())
         {
             auto errorsPlus = ConvertToDoubleVector(m_Controls.m_lineEditXErrorPlus->text());
             auto errorsMinus = ConvertToDoubleVector(m_Controls.m_lineEditXErrorMinus->text());
             m_Controls.m_Chart->SetXErrorBars(m_Controls.m_lineEditDataLabel->text().toStdString(), errorsPlus, errorsMinus);
         }
         if (m_Controls.m_checkBoxEnableYErrors->isChecked())
         {
             auto errorsPlus = ConvertToDoubleVector(m_Controls.m_lineEditYErrorPlus->text());
             auto errorsMinus = ConvertToDoubleVector(m_Controls.m_lineEditYErrorMinus->text());
             m_Controls.m_Chart->SetYErrorBars(m_Controls.m_lineEditDataLabel->text().toStdString(), errorsPlus, errorsMinus);
         }
     }
 
     QString dataOverview;
     dataOverview.append(m_Controls.m_lineEditDataLabel->text());
     dataOverview.append("(").append(m_Controls.m_comboBoxChartType->currentText());
 
     dataOverview.append(", ").append(m_Controls.m_comboBoxLineStyle->currentText());
     dataOverview.append(")");
     dataOverview.append(":").append(data);
 
     m_Controls.m_plainTextEditDataView->appendPlainText(dataOverview);
 }
 
 void QmitkChartExampleView::CreateChart()
 {
   auto dataYAxisScaleType =
     m_AxisScaleNameToAxisScaleType.at(m_Controls.m_comboBoxYAxisScale->currentText().toStdString());
   auto xAxisLabel = m_Controls.m_lineEditXAxisLabel->text().toStdString();
   auto yAxisLabel = m_Controls.m_lineEditYAxisLabel->text().toStdString();
   auto showLegend = m_Controls.m_checkBoxShowLegend->isChecked();
   auto legendPosition =
     m_LegendPositionNameToLegendPositionType.at(m_Controls.m_comboBoxLegendPosition->currentText().toStdString());
   auto showDataPoints = m_Controls.m_checkBoxShowDataPoints->isChecked();
   auto stackedData = m_Controls.m_checkBoxStackedData->isChecked();
   auto showSubchart = m_Controls.m_checkBoxShowSubchart->isChecked();
   auto title = m_Controls.m_lineEditTitle->text().toStdString();
 
   m_Controls.m_Chart->SetTitle(title);
   m_Controls.m_Chart->SetYAxisScale(dataYAxisScaleType);
   m_Controls.m_Chart->SetXAxisLabel(xAxisLabel);
   m_Controls.m_Chart->SetYAxisLabel(yAxisLabel);
   m_Controls.m_Chart->SetShowLegend(showLegend);
   m_Controls.m_Chart->SetLegendPosition(legendPosition);
   m_Controls.m_Chart->SetShowErrorBars(true);
   m_Controls.m_Chart->SetShowDataPoints(showDataPoints);
   m_Controls.m_Chart->SetStackedData(stackedData);
   m_Controls.m_Chart->Show(showSubchart);
 }
 
 void QmitkChartExampleView::UpdateData()
 {
     if (m_Controls.m_comboBoxExistingData->currentText().isEmpty())
     {
         m_Controls.m_labelInfo->setText("Please enter a valid Datalabel");
         m_Controls.m_labelInfo->setStyleSheet("color: red;");
         return;
     }
 
     if (m_Controls.m_lineEditDataLabel->text() != m_Controls.m_comboBoxExistingData->currentText())
     {
         return;
     }
 
     QString lineEditDataX = m_Controls.m_lineEditDataXVector->text();
     QString lineEditDataY = m_Controls.m_lineEditDataYVector->text();
     auto dataX = ConvertToDoubleVector(lineEditDataX);
     auto dataY = ConvertToDoubleVector(lineEditDataY);
     auto dataXandY = CreatePairList(dataX, dataY);
     QString data = QString::fromStdString(ConvertToText(dataXandY));
 
     std::string dataLabel = m_Controls.m_lineEditDataLabel->text().toStdString();
     std::string chartTypeAsString = m_Controls.m_comboBoxChartType->currentText().toStdString();
     std::string chartColorAsString = m_Controls.m_comboBoxColor->currentText().toStdString();
     std::string chartLineStyleAsString = m_Controls.m_comboBoxLineStyle->currentText().toStdString();
     std::string pieLabelsAsString = m_Controls.m_lineEditPieDataLabel->text().toStdString();
 
     if (dataX.size() != dataY.size())
     {
         m_Controls.m_labelInfo->setText("Data x and y size have to be equal");
         m_Controls.m_labelInfo->setStyleSheet("color: red;");
         return;
     }
 
     m_Controls.m_Chart->UpdateChartExampleData(dataXandY, dataLabel, chartTypeAsString, chartColorAsString, chartLineStyleAsString, pieLabelsAsString);
 }
 
 void QmitkChartExampleView::UpdateSelectedData()
 {
     std::string label = m_Controls.m_comboBoxExistingData->currentText().toStdString();
     auto data = m_Controls.m_Chart->GetDataElementByLabel(label);
 
     if (data == nullptr)
     {
         return;
     }
 
     auto x = data->GetXData();
     auto y = data->GetYData();
 
-    auto xVector = x.toVector().toStdVector();
-    auto yVector = y.toVector().toStdVector();
+    std::vector<QVariant> xVector(x.begin(), x.end());
+    std::vector<QVariant> yVector(y.begin(), y.end());
 
     QString xString = QString::fromStdString(ConvertToText(xVector));
     QString yString = QString::fromStdString(ConvertToText(yVector));
 
     auto color = data->GetColor();
     auto type = data->GetChartType();
     auto style = data->GetLineStyle();
 
     if (type.toString() == "pie")
     {
         m_Controls.m_comboBoxLineStyle->setVisible(false);
         m_Controls.m_labelLineStyle->setVisible(false);
         m_Controls.m_lineEditPieDataLabel->setVisible(true);
         m_Controls.m_labelPieData->setVisible(true);
 
         auto pieLabelsString = ConvertToText(data->GetPieLabels());
 
         m_Controls.m_lineEditPieDataLabel->setText(QString::fromStdString(pieLabelsString));
     }
 
     else
     {
         m_Controls.m_lineEditPieDataLabel->setVisible(false);
         m_Controls.m_labelPieData->setVisible(false);
         m_Controls.m_comboBoxLineStyle->setVisible(true);
         m_Controls.m_labelLineStyle->setVisible(true);
         m_Controls.m_comboBoxLineStyle->setCurrentText(style.toString());
     }
 
     m_Controls.m_lineEditDataXVector->setText(xString);
     m_Controls.m_lineEditDataYVector->setText(yString);
     m_Controls.m_lineEditDataLabel->setText(QString::fromStdString(label));
     m_Controls.m_comboBoxColor->setCurrentText(color.toString());
     m_Controls.m_comboBoxChartType->setCurrentText(type.toString());
 }
 
 void QmitkChartExampleView::ClearChart()
 {
   m_Controls.m_Chart->Clear();
 
   m_Controls.m_plainTextEditDataView->clear();
 
   m_Controls.m_comboBoxExistingData->clear();
 
   labelStorage.clear();
 }
 
 void QmitkChartExampleView::ShowErrorOptions(bool show)
 {
   m_Controls.m_groupBoxErrors->setVisible(show);
 }
 
 void QmitkChartExampleView::ShowXErrorOptions(bool show)
 {
   m_Controls.m_groupBoxXErrors->setVisible(show);
 }
 
 void QmitkChartExampleView::ShowYErrorOptions(bool show)
 {
   m_Controls.m_groupBoxYErrors->setVisible(show);
 }
 
 void QmitkChartExampleView::AdaptZoomX()
 {
   m_Controls.m_Chart->SetMinMaxValueXView(m_Controls.m_doubleSpinBox_minZoomX->value(),
                                              m_Controls.m_doubleSpinBox_maxZoomX->value());
   m_Controls.m_Chart->Show();
 }
 
 void QmitkChartExampleView::AdaptZoomY()
 {
   m_Controls.m_Chart->SetMinMaxValueYView(m_Controls.m_doubleSpinBox_minZoomY->value(),
                                              m_Controls.m_doubleSpinBox_maxZoomY->value());
   m_Controls.m_Chart->Show();
 }
 
 void QmitkChartExampleView::AdaptDataGUI(QString chartType)
 {
   if (chartType == "pie")
   {
     m_Controls.m_labelPieData->setVisible(true);
     m_Controls.m_lineEditPieDataLabel->setVisible(true);
     m_Controls.m_labelLineStyle->setVisible(false);
     m_Controls.m_comboBoxLineStyle->setVisible(false);
   }
 
   else
   {
     m_Controls.m_labelLineStyle->setVisible(true);
     m_Controls.m_comboBoxLineStyle->setVisible(true);
     m_Controls.m_labelPieData->setVisible(false);
     m_Controls.m_lineEditPieDataLabel->setVisible(false);
   }
 }
 
 void QmitkChartExampleView::OnLegendPositionChanged(const QString &newText)
 {
   auto legendPosition = m_LegendPositionNameToLegendPositionType.at(newText.toStdString());
   m_Controls.m_Chart->SetLegendPosition(legendPosition);
 }
 
 void QmitkChartExampleView::OnTitleChanged() {
   auto newTitle = m_Controls.m_lineEditTitle->text();
   m_Controls.m_Chart->SetTitle(newTitle.toStdString());
 }
 
 void QmitkChartExampleView::OnXAxisLabelChanged() {
   auto newXAxisLabel = m_Controls.m_lineEditXAxisLabel->text();
   m_Controls.m_Chart->SetXAxisLabel(newXAxisLabel.toStdString());
 }
 
 void QmitkChartExampleView::OnYAxisLabelChanged() {
   auto newYAxisLabel = m_Controls.m_lineEditYAxisLabel->text();
   m_Controls.m_Chart->SetYAxisLabel(newYAxisLabel.toStdString());
 }
 
 void QmitkChartExampleView::OnYAxisScaleChanged(const QString &newYAxisScale) {
   auto yAxisScale = m_AxisScaleNameToAxisScaleType.at(newYAxisScale.toStdString());
   m_Controls.m_Chart->SetYAxisScale(yAxisScale);
 }
 
 void QmitkChartExampleView::OnShowLegendChanged(int newState) {
   m_Controls.m_Chart->SetShowLegend(newState == Qt::Checked);
 }
 
 void QmitkChartExampleView::OnStackedDataChanged(int newState) {
   m_Controls.m_Chart->SetStackedData(newState == Qt::Checked);
 }
 
 void QmitkChartExampleView::OnShowDataPointsChanged(int newState) {
   m_Controls.m_Chart->SetShowDataPoints(newState == Qt::Checked);
 }
 
 void QmitkChartExampleView::OnShowSubchartChanged(int newState) {
   m_Controls.m_Chart->SetShowSubchart(newState == Qt::Checked);
 }
 
 std::vector< std::pair<double, double> > QmitkChartExampleView::CreatePairList(std::vector<double> keys, std::vector<double> values) const
 {
     std::vector< std::pair<double, double> > aMap;
     std::transform(keys.begin(), keys.end(), values.begin(), std::inserter(aMap, aMap.end()), [](double a, double b) {
         return std::make_pair(a, b);
         });
     return aMap;
 }
 
 std::string QmitkChartExampleView::ConvertToText(std::vector<std::pair<double, double> > numbers, std::string delimiter) const
 {
     std::ostringstream oss;
     oss.precision(3);
 
     if (!numbers.empty())
     {
         for (const auto& keyValue : numbers)
         {
             oss << keyValue.first << ":" << keyValue.second << delimiter;
         }
     }
     auto aString = oss.str();
     aString.pop_back();
     return aString;
 }
 
 std::string QmitkChartExampleView::ConvertToText(std::vector<QVariant> numbers, std::string delimiter) const
 {
     std::ostringstream oss;
     oss.precision(3);
 
     if (!numbers.empty())
     {
         for (auto number : numbers)
         {
             oss << number.toDouble() << delimiter;
         }
     }
     auto aString = oss.str();
     aString.pop_back();
     return aString;
 }
 
 std::string QmitkChartExampleView::ConvertToText(QVariantList list, std::string delimiter) const
 {
     std::ostringstream oss;
 
     if (!list.isEmpty())
     {
         for (auto element : list)
         {
             oss << element.toString().toStdString() << delimiter;
         }
 
         auto aString = oss.str();
         aString.pop_back();
         return aString;
     }
 
     return "";
 }
 
 std::vector<double> QmitkChartExampleView::ConvertToDoubleVector(const QString& data, QChar delimiter) const
 {
     std::vector<double> output;
     if (data.isEmpty())
     {
         return output;
     }
 
     for (const QString& entry : data.split(delimiter))
     {
         output.push_back(entry.toDouble());
     }
     return output;
 }
 
 std::vector<std::string> QmitkChartExampleView::ConvertToStringVector(const QString& data, QChar delimiter) const
 {
     std::vector<std::string> output;
     if (data.isEmpty())
     {
         return output;
     }
 
     for (const QString& entry : data.split(delimiter))
     {
         output.push_back(entry.toStdString());
     }
     return output;
 }
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractView.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractView.cpp
index 4f74a40026..ecd5f692f9 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractView.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractView.cpp
@@ -1,522 +1,526 @@
 /*============================================================================
 
 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 "QmitkAbstractView.h"
 #include "QmitkDataNodeSelectionProvider.h"
 #include "internal/QmitkCommonActivator.h"
 #include "internal/QmitkDataNodeItemModel.h"
 
 // mitk Includes
 #include <mitkLog.h>
 #include <mitkCoreServices.h>
 #include <mitkIPreferences.h>
 #include <mitkIPreferencesService.h>
 #include <mitkIDataStorageService.h>
 #include <mitkDataStorageEditorInput.h>
 #include <mitkDataNodeObject.h>
 #include <mitkIRenderingManager.h>
 #include <mitkTimeNavigationController.h>
 
 // berry Includes
 #include <berryIWorkbenchPage.h>
 #include <berryIEditorPart.h>
 #include <berryINullSelectionListener.h>
 #include <berryUIException.h>
 
 // CTK Includes
 #include <ctkServiceTracker.h>
 
 // Qt Includes
 #include <QItemSelectionModel>
 #include <QApplication>
 #include <QMessageBox>
 #include <QScrollArea>
 #include <QVBoxLayout>
 
 class QmitkAbstractViewPrivate
 {
 public:
 
   QmitkAbstractViewPrivate(QmitkAbstractView* qq)
     : q(qq)
     , m_DataStorageServiceTracker(QmitkCommonActivator::GetContext())
     , m_Parent(nullptr)
     , m_DataNodeItemModel(new QmitkDataNodeItemModel)
     , m_DataNodeSelectionModel(new QItemSelectionModel(m_DataNodeItemModel))
     , m_InDataStorageChanged(false)
   {
     m_DataStorageServiceTracker.open();
   }
 
   ~QmitkAbstractViewPrivate()
   {
     delete m_DataNodeSelectionModel;
     delete m_DataNodeItemModel;
 
     m_DataStorageServiceTracker.close();
   }
 
   /**
    * Called when a DataStorage Add Event was thrown. Sets
    * m_InDataStorageChanged to true and calls NodeAdded afterwards.
    * \see m_InDataStorageChanged
    */
   void NodeAddedProxy(const mitk::DataNode* node)
   {
     // garantuee no recursions when a new node event is thrown in NodeAdded()
     if(!m_InDataStorageChanged)
     {
       m_InDataStorageChanged = true;
       q->NodeAdded(node);
       q->DataStorageModified();
       m_InDataStorageChanged = false;
     }
   }
 
   /**
    * Called when a DataStorage remove event was thrown. Sets
    * m_InDataStorageChanged to true and calls NodeRemoved afterwards.
    * \see m_InDataStorageChanged
    */
   void NodeRemovedProxy(const mitk::DataNode* node)
   {
     // garantuee no recursions when a new node event is thrown in NodeAdded()
     if(!m_InDataStorageChanged)
     {
       m_InDataStorageChanged = true;
       q->NodeRemoved(node);
       q->DataStorageModified();
       m_InDataStorageChanged = false;
     }
   }
 
   /**
    * Called when a DataStorage changed event was thrown. Sets
    * m_InDataStorageChanged to true and calls NodeChanged afterwards.
    * \see m_InDataStorageChanged
    */
   void NodeChangedProxy(const mitk::DataNode* node)
   {
     // garantuee no recursions when a new node event is thrown in NodeAdded()
     if(!m_InDataStorageChanged)
     {
       m_InDataStorageChanged = true;
       q->NodeChanged(node);
       q->DataStorageModified();
       m_InDataStorageChanged = false;
     }
   }
 
   /**
    * reactions to selection events from views
    */
   void BlueBerrySelectionChanged(const berry::IWorkbenchPart::Pointer& sourcepart,
                                  const berry::ISelection::ConstPointer& selection)
   {
     if(sourcepart.IsNull() || sourcepart.GetPointer() == static_cast<berry::IWorkbenchPart*>(q))
       return;
 
     if(selection.IsNull())
     {
       q->OnNullSelection(sourcepart);
       return;
     }
 
     mitk::DataNodeSelection::ConstPointer _DataNodeSelection
       = selection.Cast<const mitk::DataNodeSelection>();
     q->OnSelectionChanged(sourcepart, this->DataNodeSelectionToQList(_DataNodeSelection));
   }
 
   /**
    * Converts a mitk::DataNodeSelection to a QList<mitk::DataNode::Pointer> (possibly empty)
    */
   QList<mitk::DataNode::Pointer> DataNodeSelectionToQList(mitk::DataNodeSelection::ConstPointer currentSelection) const;
 
   QmitkAbstractView* const q;
 
   ctkServiceTracker<mitk::IDataStorageService*> m_DataStorageServiceTracker;
 
   /**
    * Saves the parent of this view (this is the scrollarea created in CreatePartControl(QWidget*)
    * \see CreatePartControl(QWidget*)
    */
   QWidget* m_Parent;
 
   /**
    * Holds the current selection (selection made by this View !!!)
    */
   QmitkDataNodeSelectionProvider::Pointer m_SelectionProvider;
 
   /**
    * Holds a helper model for firing selection events.
    */
   QmitkDataNodeItemModel* m_DataNodeItemModel;
 
   /**
    * The selection model for the QmitkDataNodeItemModel;
    */
   QItemSelectionModel* m_DataNodeSelectionModel;
 
   /**
    * object to observe BlueBerry selections
    */
   QScopedPointer<berry::ISelectionListener> m_BlueBerrySelectionListener;
 
   /**
    * Saves if this class is currently working on DataStorage changes.
    * This is a protector variable to avoid recursive calls on event listener functions.
    */
   bool m_InDataStorageChanged;
 
 };
 
 QmitkAbstractView::QmitkAbstractView()
   : d(new QmitkAbstractViewPrivate(this))
 {
 }
 
 void QmitkAbstractView::CreatePartControl(QWidget* parent)
 {
 
   // scrollArea
   auto   scrollArea = new QScrollArea;
   //QVBoxLayout* scrollAreaLayout = new QVBoxLayout(scrollArea);
   scrollArea->setFrameShadow(QFrame::Plain);
   scrollArea->setFrameShape(QFrame::NoFrame);
   scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
   scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
 
   // m_Parent
   d->m_Parent = new QWidget;
   //m_Parent->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
   this->CreateQtPartControl(d->m_Parent);
 
   //scrollAreaLayout->addWidget(m_Parent);
   //scrollArea->setLayout(scrollAreaLayout);
 
   // set the widget now
   scrollArea->setWidgetResizable(true);
   scrollArea->setWidget(d->m_Parent);
 
   // add the scroll area to the real parent (the view tabbar)
   QWidget* parentQWidget = static_cast<QWidget*>(parent);
   auto   parentLayout = new QVBoxLayout(parentQWidget);
   parentLayout->setContentsMargins({});
   parentLayout->setSpacing(0);
   parentLayout->addWidget(scrollArea);
 
   // finally set the layout containing the scroll area to the parent widget (= show it)
   parentQWidget->setLayout(parentLayout);
 
   this->AfterCreateQtPartControl();
 }
 
 void QmitkAbstractView::AfterCreateQtPartControl()
 {
   this->SetSelectionProvider();
 
   // REGISTER DATASTORAGE LISTENER
   this->GetDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkAbstractViewPrivate, const mitk::DataNode*>
                                                     ( d.data(), &QmitkAbstractViewPrivate::NodeAddedProxy ) );
   this->GetDataStorage()->ChangedNodeEvent.AddListener( mitk::MessageDelegate1<QmitkAbstractViewPrivate, const mitk::DataNode*>
                                                         ( d.data(), &QmitkAbstractViewPrivate::NodeChangedProxy ) );
   this->GetDataStorage()->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<QmitkAbstractViewPrivate, const mitk::DataNode*>
                                                        ( d.data(), &QmitkAbstractViewPrivate::NodeRemovedProxy ) );
 
   // REGISTER PREFERENCES LISTENER
   auto* prefs = this->GetPreferences();
 
   if (prefs != nullptr)
     prefs->OnChanged.AddListener(mitk::MessageDelegate1<QmitkAbstractView, const mitk::IPreferences*>(this, &QmitkAbstractView::OnPreferencesChanged));
 
   // REGISTER FOR WORKBENCH SELECTION EVENTS
   d->m_BlueBerrySelectionListener.reset(new berry::NullSelectionChangedAdapter<QmitkAbstractViewPrivate>(
                                           d.data(), &QmitkAbstractViewPrivate::BlueBerrySelectionChanged));
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(d->m_BlueBerrySelectionListener.data());
 
   // EMULATE INITIAL SELECTION EVENTS
 
   // send the current selection
   berry::IWorkbenchPart::Pointer activePart = this->GetSite()->GetPage()->GetActivePart();
   if (activePart.IsNotNull())
   {
     this->OnSelectionChanged(activePart, this->GetCurrentSelection());
   }
 
   // send preferences changed event
   this->OnPreferencesChanged(this->GetPreferences());
 }
 
 QmitkAbstractView::~QmitkAbstractView()
 {
   this->Register();
 
   this->GetDataStorage()->AddNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkAbstractViewPrivate, const mitk::DataNode*>
                                                        ( d.data(), &QmitkAbstractViewPrivate::NodeAddedProxy ) );
   this->GetDataStorage()->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkAbstractViewPrivate, const mitk::DataNode*>
                                                           ( d.data(), &QmitkAbstractViewPrivate::NodeRemovedProxy) );
   this->GetDataStorage()->ChangedNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkAbstractViewPrivate, const mitk::DataNode*>
                                                            ( d.data(), &QmitkAbstractViewPrivate::NodeChangedProxy ) );
 
   auto* prefs = this->GetPreferences();
 
   if(prefs != nullptr)
     prefs->OnChanged.RemoveListener(mitk::MessageDelegate1<QmitkAbstractView, const mitk::IPreferences*>(this, &QmitkAbstractView::OnPreferencesChanged));
 
   // REMOVE SELECTION PROVIDER
   this->GetSite()->SetSelectionProvider(berry::ISelectionProvider::Pointer(nullptr));
 
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   if(s)
   {
     s->RemovePostSelectionListener(d->m_BlueBerrySelectionListener.data());
   }
 
   this->UnRegister(false);
 }
 
 void QmitkAbstractView::SetSelectionProvider()
 {
   // REGISTER A SELECTION PROVIDER
   d->m_SelectionProvider = QmitkDataNodeSelectionProvider::Pointer(new QmitkDataNodeSelectionProvider);
   d->m_SelectionProvider->SetItemSelectionModel(GetDataNodeSelectionModel());
   this->GetSite()->SetSelectionProvider(berry::ISelectionProvider::Pointer(d->m_SelectionProvider));
 }
 
 QItemSelectionModel *QmitkAbstractView::GetDataNodeSelectionModel() const
 {
   return nullptr;
 }
 
 void QmitkAbstractView::OnPreferencesChanged( const mitk::IPreferences* )
 {
 }
 
 void QmitkAbstractView::DataStorageModified()
 {
 }
 
 void QmitkAbstractView::DataStorageChanged(mitk::IDataStorageReference::Pointer /*dsRef*/)
 {
 }
 
 mitk::IRenderWindowPart* QmitkAbstractView::GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategies strategies) const
 {
   berry::IWorkbenchPage::Pointer page = GetSite()->GetPage();
   return mitk::WorkbenchUtil::GetRenderWindowPart(page, strategies);
 }
 
 void QmitkAbstractView::RequestRenderWindowUpdate(mitk::RenderingManager::RequestType requestType)
 {
   mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
   if (renderPart == nullptr)
     return;
 
   if (mitk::IRenderingManager* renderingManager = renderPart->GetRenderingManager())
   {
     renderingManager->RequestUpdateAll(requestType);
   }
   else
   {
     renderPart->RequestUpdate(requestType);
   }
 }
 
 void QmitkAbstractView::HandleException( const char* str, QWidget* parent, bool showDialog ) const
 {
   //itkGenericOutputMacro( << "Exception caught: " << str );
   MITK_ERROR << str;
   if ( showDialog )
   {
     QMessageBox::critical ( parent, "Exception caught!", str );
   }
 }
 
 void QmitkAbstractView::HandleException( std::exception& e, QWidget* parent, bool showDialog ) const
 {
   HandleException( e.what(), parent, showDialog );
 }
 
 void QmitkAbstractView::WaitCursorOn()
 {
   QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
 }
 
 void QmitkAbstractView::BusyCursorOn()
 {
   QApplication::setOverrideCursor( QCursor(Qt::BusyCursor) );
 }
 
 void QmitkAbstractView::WaitCursorOff()
 {
   this->RestoreOverrideCursor();
 }
 
 void QmitkAbstractView::BusyCursorOff()
 {
   this->RestoreOverrideCursor();
 }
 
 void QmitkAbstractView::RestoreOverrideCursor()
 {
   QApplication::restoreOverrideCursor();
 }
 
 mitk::IPreferences* QmitkAbstractView::GetPreferences() const
 {
   mitk::CoreServicePointer prefsService(mitk::CoreServices::GetPreferencesService());
   auto* prefs = prefsService->GetSystemPreferences();
 
   if (prefs != nullptr)
   {
     auto viewSite = const_cast<QmitkAbstractView*>(this)->GetViewSite();
 
     if (viewSite.IsNotNull())
       return prefs->Node("/" + viewSite->GetId().toStdString());
   }
 
   return nullptr;
 }
 
 mitk::DataStorage::Pointer QmitkAbstractView::GetDataStorage() const
 {
   mitk::IDataStorageService* dsService = d->m_DataStorageServiceTracker.getService();
 
   if (dsService != nullptr)
   {
     return dsService->GetDataStorage()->GetDataStorage();
   }
 
   return nullptr;
 }
 
 mitk::IDataStorageReference::Pointer QmitkAbstractView::GetDataStorageReference() const
 {
   mitk::IDataStorageService* dsService = d->m_DataStorageServiceTracker.getService();
 
   if (dsService != nullptr)
   {
     return dsService->GetDataStorage();
   }
 
   return mitk::IDataStorageReference::Pointer(nullptr);
 }
 
 QList<mitk::DataNode::Pointer> QmitkAbstractView::GetCurrentSelection() const
 {
   berry::ISelection::ConstPointer selection( this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection());
   mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
   return d->DataNodeSelectionToQList(currentSelection);
 }
 
 bool QmitkAbstractView::IsCurrentSelectionValid() const
 {
   return this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection();
 }
 
 QList<mitk::DataNode::Pointer> QmitkAbstractView::GetDataManagerSelection() const
 {
   berry::ISelection::ConstPointer selection( this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
   return d->DataNodeSelectionToQList(currentSelection);
 }
 
 bool QmitkAbstractView::IsDataManagerSelectionValid() const
 {
   return this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager");
 }
 
 void QmitkAbstractView::SetDataManagerSelection(const berry::ISelection::ConstPointer &selection,
                                                 QItemSelectionModel::SelectionFlags flags) const
 {
   berry::IViewPart::Pointer datamanagerView = this->GetSite()->GetWorkbenchWindow()->GetActivePage()->FindView("org.mitk.views.datamanager");
   if (datamanagerView.IsNull()) return;
 
   datamanagerView->GetSite()->GetSelectionProvider().Cast<berry::QtSelectionProvider>()->SetSelection(selection, flags);
 }
 
 void QmitkAbstractView::SynchronizeDataManagerSelection() const
 {
   berry::ISelection::ConstPointer currentSelection = this->GetSite()->GetSelectionProvider()->GetSelection();
   if (currentSelection.IsNull()) return;
 
   SetDataManagerSelection(currentSelection);
 }
 
 void QmitkAbstractView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
                                            const QList<mitk::DataNode::Pointer>& /*nodes*/)
 {
 }
 
 void QmitkAbstractView::OnNullSelection(berry::IWorkbenchPart::Pointer /*part*/)
 {
 }
 
 QList<mitk::DataNode::Pointer> QmitkAbstractViewPrivate::DataNodeSelectionToQList(mitk::DataNodeSelection::ConstPointer currentSelection) const
 {
-  if (currentSelection.IsNull()) return QList<mitk::DataNode::Pointer>();
-  return QList<mitk::DataNode::Pointer>::fromStdList(currentSelection->GetSelectedDataNodes());
+  if (currentSelection.IsNull())
+    return QList<mitk::DataNode::Pointer>();
+
+  auto nodes = currentSelection->GetSelectedDataNodes();
+
+  return QList<mitk::DataNode::Pointer>(nodes.begin(), nodes.end());
 }
 
 void QmitkAbstractView::NodeAdded( const mitk::DataNode*  /*node*/ )
 {
 }
 
 void QmitkAbstractView::NodeRemoved( const mitk::DataNode*  /*node*/ )
 {
 }
 
 void QmitkAbstractView::NodeChanged( const mitk::DataNode* /*node*/ )
 {
 }
 
 void QmitkAbstractView::FireNodeSelected( mitk::DataNode::Pointer node )
 {
   QList<mitk::DataNode::Pointer> nodes;
   nodes << node;
   this->FireNodesSelected(nodes);
 }
 
 void QmitkAbstractView::FireNodesSelected( const QList<mitk::DataNode::Pointer>& nodes )
 {
   // if this is the first call to FireNodesSelected and the selection provider has no QItemSelectiomMode
   // yet, set our helper model
   if (d->m_SelectionProvider->GetItemSelectionModel() == nullptr)
   {
     d->m_SelectionProvider->SetItemSelectionModel(d->m_DataNodeSelectionModel);
   }
   else if (d->m_SelectionProvider->GetItemSelectionModel() != d->m_DataNodeSelectionModel)
   {
     MITK_WARN << "A custom data node selection model has been set. Ignoring call to FireNodesSelected().";
     return;
   }
 
   if (nodes.empty())
   {
     d->m_DataNodeSelectionModel->clearSelection();
     d->m_DataNodeItemModel->clear();
   }
   else
   {
 
     // The helper data node model is just used for sending selection events.
     // We add the to be selected nodes and set the selection range to everything.
 
     d->m_DataNodeItemModel->clear();
     foreach(mitk::DataNode::Pointer node, nodes)
     {
       d->m_DataNodeItemModel->AddDataNode(node);
     }
     d->m_DataNodeSelectionModel->select(QItemSelection(d->m_DataNodeItemModel->index(0,0), d->m_DataNodeItemModel->index(nodes.size()-1, 0)),
                                         QItemSelectionModel::ClearAndSelect);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkSelectionServiceConnector.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkSelectionServiceConnector.cpp
index 674d0e9758..5f3a5efc1d 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkSelectionServiceConnector.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkSelectionServiceConnector.cpp
@@ -1,126 +1,127 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 // mitk gui qt common plugin
 #include "QmitkSelectionServiceConnector.h"
 #include "internal/QmitkDataNodeSelection.h"
 
 // qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 
 // blueberry ui qt plugin
 #include <berryINullSelectionListener.h>
 
 QmitkSelectionServiceConnector::QmitkSelectionServiceConnector()
   : m_SelectionService(nullptr)
   , m_SelectionProvider(nullptr)
 {
   m_DataNodeItemModel = std::make_shared<QmitkDataNodeItemModel>();
   m_DataNodeSelectionModel = std::make_shared<QItemSelectionModel>(m_DataNodeItemModel.get());
 }
 
 QmitkSelectionServiceConnector::~QmitkSelectionServiceConnector()
 {
   RemovePostSelectionListener();
   RemoveAsSelectionProvider();
 }
 
 void QmitkSelectionServiceConnector::AddPostSelectionListener(berry::ISelectionService* selectionService)
 {
   if (nullptr == selectionService)
   {
     return;
   }
 
   m_SelectionService = selectionService;
   m_BerrySelectionListener.reset(new berry::NullSelectionChangedAdapter<QmitkSelectionServiceConnector>(this, &QmitkSelectionServiceConnector::OnServiceSelectionChanged));
   m_SelectionService->AddPostSelectionListener(m_BerrySelectionListener.get());
 }
 
 void QmitkSelectionServiceConnector::RemovePostSelectionListener()
 {
   if (nullptr == m_SelectionService)
   {
     return;
   }
 
   m_SelectionService->RemovePostSelectionListener(m_BerrySelectionListener.get());
   m_SelectionService = nullptr;
 }
 
 void QmitkSelectionServiceConnector::SetAsSelectionProvider(QmitkDataNodeSelectionProvider* selectionProvider)
 {
   m_SelectionProvider = selectionProvider;
 }
 
 void QmitkSelectionServiceConnector::RemoveAsSelectionProvider()
 {
   m_SelectionProvider = nullptr;
 }
 
 void QmitkSelectionServiceConnector::ChangeServiceSelection(QList<mitk::DataNode::Pointer> nodes)
 {
   if (nullptr == m_SelectionProvider)
   {
     return;
   }
 
   m_SelectionProvider->SetItemSelectionModel(m_DataNodeSelectionModel.get());
 
   if (nodes.empty())
   {
     m_DataNodeSelectionModel->clearSelection();
     m_DataNodeItemModel->clear();
   }
   else
   {
     m_DataNodeItemModel->clear();
     // fill the temporary helper data node item model with the nodes to select
     for (const auto& node : nodes)
     {
       m_DataNodeItemModel->AddDataNode(node);
     }
 
     m_DataNodeSelectionModel->select(QItemSelection(m_DataNodeItemModel->index(0, 0), m_DataNodeItemModel->index(nodes.size() - 1, 0)), QItemSelectionModel::ClearAndSelect);
   }
 }
 
 void QmitkSelectionServiceConnector::OnServiceSelectionChanged(const berry::IWorkbenchPart::Pointer& sourcePart, const berry::ISelection::ConstPointer& selection)
 {
   if (sourcePart.IsNull())
   {
     return;
   }
 
   QList<mitk::DataNode::Pointer> nodes;
   if (selection.IsNull())
   {
     emit ServiceNullSelection(sourcePart);
     return;
   }
 
   // transform valid selection to DataNodeSelection, which allows to retrieve the selected nodes
   mitk::DataNodeSelection::ConstPointer dataNodeSelection = selection.Cast<const mitk::DataNodeSelection>();
   if (dataNodeSelection.IsNull())
   {
     // propagate an empty list
     nodes = QList<mitk::DataNode::Pointer>();
   }
   else
   {
-    nodes = QList<mitk::DataNode::Pointer>::fromStdList(dataNodeSelection->GetSelectedDataNodes());
+    auto selectedNodes = dataNodeSelection->GetSelectedDataNodes();
+    nodes = QList<mitk::DataNode::Pointer>(selectedNodes.begin(), selectedNodes.end());
   }
 
   // send new (possibly empty) list of selected nodes
   emit ServiceSelectionChanged(nodes);
 }