diff --git a/Plugins/org.blueberry.core.runtime/src/internal/berryInternalPlatform.cpp b/Plugins/org.blueberry.core.runtime/src/internal/berryInternalPlatform.cpp
index f59a422aa6..e05e69c7bb 100644
--- a/Plugins/org.blueberry.core.runtime/src/internal/berryInternalPlatform.cpp
+++ b/Plugins/org.blueberry.core.runtime/src/internal/berryInternalPlatform.cpp
@@ -1,497 +1,498 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 
 #include "berryInternalPlatform.h"
 
 #include "berryLog.h"
 #include "berryLogImpl.h"
 #include "berryPlatform.h"
 #include "berryPlatformException.h"
 #include "berryDebugUtil.h"
 #include "berryPlatformException.h"
 #include "berryCTKPluginActivator.h"
 #include "berryPlatformException.h"
 #include "berryApplicationContainer.h"
 #include "berryProduct.h"
 
 #include "berryIBranding.h"
 
 //#include "event/berryPlatformEvents.h"
 //#include "berryPlatformLogChannel.h"
 
 #include <berryIApplicationContext.h>
 #include <berryIExtensionRegistry.h>
 #include <berryIProduct.h>
 
 #include <service/datalocation/ctkLocation.h>
 #include <service/debug/ctkDebugOptions.h>
 
 #include <ctkPluginContext.h>
 #include <ctkPlugin.h>
 #include <ctkPluginException.h>
 #include <ctkPluginFrameworkLauncher.h>
 
 #include <QCoreApplication>
 #include <QDesktopServices>
 #include <QDebug>
 #include <QMutexLocker>
+#include <QStringList>
 
 #include <mitkCoreServices.h>
 #include <mitkIPreferencesService.h>
 
 #include <usModuleInitialization.h>
 
 US_INITIALIZE_MODULE
 
 namespace berry {
 
 QMutex InternalPlatform::m_Mutex;
 
 bool InternalPlatform::DEBUG = false;
 bool InternalPlatform::DEBUG_PLUGIN_PREFERENCES = false;
 
 InternalPlatform::InternalPlatform()
   : m_Initialized(false)
   , m_ConsoleLog(false)
   , m_Context(nullptr)
 {
 }
 
 InternalPlatform::~InternalPlatform()
 {
 
 }
 
 InternalPlatform* InternalPlatform::GetInstance()
 {
   QMutexLocker lock(&m_Mutex);
   static InternalPlatform instance;
   return &instance;
 }
 
 bool InternalPlatform::ConsoleLog() const
 {
   return m_ConsoleLog;
 }
 
 QVariant InternalPlatform::GetOption(const QString& option, const QVariant& defaultValue) const
 {
   ctkDebugOptions* options = GetDebugOptions();
   if (options != nullptr)
   {
     return options->getOption(option, defaultValue);
   }
   return QVariant();
 }
 
 IAdapterManager* InternalPlatform::GetAdapterManager() const
 {
   AssertInitialized();
   return nullptr;
 }
 
 SmartPointer<IProduct> InternalPlatform::GetProduct() const
 {
   if (product.IsNotNull()) return product;
   ApplicationContainer* container = org_blueberry_core_runtime_Activator::GetContainer();
   IBranding* branding = container == nullptr ? nullptr : container->GetBranding();
   if (branding == nullptr) return IProduct::Pointer();
   IProduct::Pointer brandingProduct = branding->GetProduct();
   if (!brandingProduct)
   {
     brandingProduct = new Product(branding);
   }
   product = brandingProduct;
   return product;
 }
 
 void InternalPlatform::InitializePluginPaths()
 {
   QMutexLocker lock(&m_Mutex);
 
   // Add search paths for Qt plugins
   for(const auto& qtPluginPath : m_Context->getProperty(Platform::PROP_QTPLUGIN_PATH).toStringList())
   {
     if (qtPluginPath.isEmpty())
       continue;
 
     if (QFile::exists(qtPluginPath))
     {
       QCoreApplication::addLibraryPath(qtPluginPath);
     }
     else if (m_ConsoleLog)
     {
       BERRY_WARN << "Qt plugin path does not exist: " << qtPluginPath.toStdString();
     }
   }
 
   // Add a default search path. It is assumed that installed applications
   // provide their Qt plugins in that path.
   static const QString defaultQtPluginPath = QCoreApplication::applicationDirPath() + "/plugins";
   if (QFile::exists(defaultQtPluginPath))
   {
     QCoreApplication::addLibraryPath(defaultQtPluginPath);
   }
 
   if (m_ConsoleLog)
   {
     std::string pathList;
     foreach(QString libPath, QCoreApplication::libraryPaths())
     {
       pathList += (pathList.empty() ? "" : ", ") + libPath.toStdString();
     }
     BERRY_INFO << "Qt library search paths: " << pathList;
   }
 
   /*
   m_ConfigPath.setPath(m_Context->getProperty("application.configDir").toString());
   m_InstancePath.setPath(m_Context->getProperty("application.dir").toString());
   QString installPath = m_Context->getProperty(Platform::PROP_HOME).toString();
   if (installPath.isEmpty())
   {
     m_InstallPath = m_InstancePath;
   }
   else {
     m_InstallPath.setPath(installPath);
   }
 
   QString dataLocation = m_Context->getProperty(Platform::PROP_STORAGE_DIR).toString();
   if (!storageDir.isEmpty())
   {
     if (dataLocation.at(dataLocation.size()-1) != '/')
     {
       dataLocation += '/';
     }
     m_UserPath.setPath(dataLocation);
   }
   else
   {
     // Append a hash value of the absolute path of the executable to the data location.
     // This allows to start the same application from different build or install trees.
     dataLocation = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + this->getOrganizationName() + "/" + this->getApplicationName() + '_';
     dataLocation += QString::number(qHash(QCoreApplication::applicationDirPath())) + "/";
     m_UserPath.setPath(dataLocation);
   }
   BERRY_INFO(m_ConsoleLog) << "Framework storage dir: " << m_UserPath.absolutePath();
 
   QFileInfo userFile(m_UserPath.absolutePath());
 
   if (!QDir().mkpath(userFile.absoluteFilePath()) || !userFile.isWritable())
   {
     QString tmpPath = QDir::temp().absoluteFilePath(QString::fromStdString(this->commandName()));
     BERRY_WARN << "Storage dir " << userFile.absoluteFilePath() << " is not writable. Falling back to temporary path " << tmpPath;
     QDir().mkpath(tmpPath);
     userFile.setFile(tmpPath);
   }
 
   m_BaseStatePath.setPath(m_UserPath.absolutePath() + "/bb-metadata/bb-plugins");
 
   QString logPath(m_UserPath.absoluteFilePath(QString::fromStdString(this->commandName()) + ".log"));
   m_PlatformLogChannel = new Poco::SimpleFileChannel(logPath.toStdString());
 */
 }
 
 ctkDebugOptions* InternalPlatform::GetDebugOptions() const
 {
   return m_DebugTracker.isNull() ? nullptr : m_DebugTracker->getService();
 }
 
 IApplicationContext* InternalPlatform::GetApplicationContext() const
 {
   QList<ctkServiceReference> refs;
   try
   {
     refs = m_Context->getServiceReferences<IApplicationContext>("(blueberry.application.type=main.thread)");
   }
   catch (const std::invalid_argument&)
   {
     return nullptr;
   }
   if (refs.isEmpty()) return nullptr;
 
   // assumes the application context is available as a service
   IApplicationContext* result = m_Context->getService<IApplicationContext>(refs.front());
   if (result != nullptr)
   {
     m_Context->ungetService(refs.front());
     return result;
   }
   return nullptr;
 }
 
 void InternalPlatform::Start(ctkPluginContext* context)
 {
   this->m_Context = context;
 
   m_ConsoleLog = m_Context->getProperty(ctkPluginFrameworkLauncher::PROP_CONSOLE_LOG).toBool();
 
   OpenServiceTrackers();
 
   this->InitializePluginPaths();
 
 #ifdef BLUEBERRY_DEBUG_SMARTPOINTER
   DebugUtil::RestoreState(m_UserPath);
 #endif
 
   InitializeDebugFlags();
   this->m_Initialized = true;
 }
 
 void InternalPlatform::Stop(ctkPluginContext* /*context*/)
 {
   AssertInitialized();
 
   this->m_Initialized = false;
   CloseServiceTrackers();
 
 #ifdef BLUEBERRY_DEBUG_SMARTPOINTER
   DebugUtil::SaveState(m_UserPath);
 #endif
 
   this->m_Context = nullptr;
 }
 
 
 void InternalPlatform::AssertInitialized() const
 {
   if (!m_Initialized)
   {
     throw PlatformException("The Platform has not been initialized yet!");
   }
 }
 
 void InternalPlatform::OpenServiceTrackers()
 {
   ctkPluginContext* context = this->m_Context;
 
   instanceLocation.reset(new ctkServiceTracker<ctkLocation*>(context, ctkLDAPSearchFilter(ctkLocation::INSTANCE_FILTER)));
   instanceLocation->open();
 
   userLocation.reset(new ctkServiceTracker<ctkLocation*>(context, ctkLDAPSearchFilter(ctkLocation::USER_FILTER)));
   userLocation->open();
 
   configurationLocation.reset(new ctkServiceTracker<ctkLocation*>(context, ctkLDAPSearchFilter(ctkLocation::CONFIGURATION_FILTER)));
   configurationLocation->open();
 
   installLocation.reset(new ctkServiceTracker<ctkLocation*>(context, ctkLDAPSearchFilter(ctkLocation::INSTALL_FILTER)));
   installLocation->open();
 
   m_RegistryTracker.reset(new ctkServiceTracker<berry::IExtensionRegistry*>(context));
   m_RegistryTracker->open();
 
   m_DebugTracker.reset(new ctkServiceTracker<ctkDebugOptions*>(context));
   m_DebugTracker->open();
 }
 
 void InternalPlatform::CloseServiceTrackers()
 {
   if (!m_RegistryTracker.isNull())
   {
     m_RegistryTracker->close();
     m_RegistryTracker.reset();
   }
   if (!m_DebugTracker.isNull())
   {
     m_DebugTracker->close();
     m_DebugTracker.reset();
   }
 
   if (!configurationLocation.isNull()) {
     configurationLocation->close();
     configurationLocation.reset();
   }
 
   if (!installLocation.isNull()) {
     installLocation->close();
     installLocation.reset();
   }
 
   if (!instanceLocation.isNull()) {
     instanceLocation->close();
     instanceLocation.reset();
   }
 
   if (!userLocation.isNull()) {
     userLocation->close();
     userLocation.reset();
   }
 }
 
 void InternalPlatform::InitializeDebugFlags()
 {
   DEBUG = this->GetOption(Platform::PI_RUNTIME + "/debug", false).toBool();
   if (DEBUG)
   {
     DEBUG_PLUGIN_PREFERENCES = GetOption(Platform::PI_RUNTIME + "/preferences/plugin", false).toBool();
   }
 }
 
 IExtensionRegistry* InternalPlatform::GetExtensionRegistry()
 {
   return m_RegistryTracker.isNull() ? nullptr : m_RegistryTracker->getService();
 }
 
 mitk::IPreferencesService *InternalPlatform::GetPreferencesService()
 {
   return mitk::CoreServices::GetPreferencesService();
 }
 
 ctkLocation* InternalPlatform::GetConfigurationLocation()
 {
   this->AssertInitialized();
   return configurationLocation->getService();
 }
 
 ctkLocation* InternalPlatform::GetInstallLocation()
 {
   this->AssertInitialized();
   return installLocation->getService();
 }
 
 ctkLocation* InternalPlatform::GetInstanceLocation()
 {
   this->AssertInitialized();
   return instanceLocation->getService();
 }
 
 QDir InternalPlatform::GetStateLocation(const QSharedPointer<ctkPlugin>& plugin)
 {
   ctkLocation* service = GetInstanceLocation();
   if (service == nullptr)
   {
     throw ctkIllegalStateException("No instance data can be specified.");
   }
 
   QUrl url = GetInstanceLocation()->getDataArea(plugin->getSymbolicName());
   if (!url.isValid())
   {
     throw ctkIllegalStateException("The instance data location has not been specified yet.");
   }
 
   QDir location(url.toLocalFile());
   if (!location.exists())
   {
     if (!location.mkpath(location.absolutePath()))
     {
       throw PlatformException(QString("Could not create plugin state location \"%1\"").arg(location.absolutePath()));
     }
   }
   return location;
 }
 
 //PlatformEvents& InternalPlatform::GetEvents()
 //{
 //  return m_Events;
 //}
 
 ctkLocation* InternalPlatform::GetUserLocation()
 {
   this->AssertInitialized();
   return userLocation->getService();
 }
 
 ILog *InternalPlatform::GetLog(const QSharedPointer<ctkPlugin> &plugin) const
 {
   LogImpl* result = m_Logs.value(plugin->getPluginId());
   if (result != nullptr)
     return result;
 
 //  ExtendedLogService logService = (ExtendedLogService) extendedLogTracker.getService();
 //  Logger logger = logService == null ? null : logService.getLogger(bundle, PlatformLogWriter.EQUINOX_LOGGER_NAME);
 //  result = new Log(bundle, logger);
 //  ExtendedLogReaderService logReader = (ExtendedLogReaderService) logReaderTracker.getService();
 //  logReader.addLogListener(result, result);
 //  logs.put(bundle, result);
 //  return result;
 
   result = new LogImpl(plugin);
   m_Logs.insert(plugin->getPluginId(), result);
   return result;
 }
 
 bool InternalPlatform::IsRunning() const
 {
   QMutexLocker lock(&m_Mutex);
   try
   {
     return m_Initialized && m_Context && m_Context->getPlugin()->getState() == ctkPlugin::ACTIVE;
   }
   catch (const ctkIllegalStateException&)
   {
     return false;
   }
 }
 
 QSharedPointer<ctkPlugin> InternalPlatform::GetPlugin(const QString &symbolicName)
 {
   QList<QSharedPointer<ctkPlugin> > plugins = m_Context->getPlugins();
 
   QSharedPointer<ctkPlugin> res(nullptr);
   foreach(QSharedPointer<ctkPlugin> plugin, plugins)
   {
     if ((plugin->getState() & (ctkPlugin::INSTALLED | ctkPlugin::UNINSTALLED)) == 0 &&
         plugin->getSymbolicName() == symbolicName)
     {
       if (res.isNull())
       {
         res = plugin;
       }
       else if (res->getVersion().compare(plugin->getVersion()) < 0)
       {
         res = plugin;
       }
     }
   }
   return res;
 }
 
 QList<QSharedPointer<ctkPlugin> > InternalPlatform::GetPlugins(const QString &symbolicName, const QString &version)
 {
   QList<QSharedPointer<ctkPlugin> > plugins = m_Context->getPlugins();
 
   QMap<ctkVersion, QSharedPointer<ctkPlugin> > selected;
   ctkVersion versionObj(version);
   foreach(QSharedPointer<ctkPlugin> plugin, plugins)
   {
     if ((plugin->getState() & (ctkPlugin::INSTALLED | ctkPlugin::UNINSTALLED)) == 0 &&
         plugin->getSymbolicName() == symbolicName)
     {
       if (plugin->getVersion().compare(versionObj) > -1)
       {
         selected.insert(plugin->getVersion(), plugin);
       }
     }
   }
   QList<QSharedPointer<ctkPlugin> > sortedPlugins = selected.values();
   QList<QSharedPointer<ctkPlugin> > reversePlugins;
-  qCopyBackward(sortedPlugins.begin(), sortedPlugins.end(), reversePlugins.end());
+  std::copy_backward(sortedPlugins.begin(), sortedPlugins.end(), reversePlugins.end());
   return reversePlugins;
 }
 
 QStringList InternalPlatform::GetApplicationArgs() const
 {
   QStringList result;
 
   IApplicationContext* appContext = this->GetApplicationContext();
   if (appContext)
   {
     QHash<QString, QVariant> args = appContext->GetArguments();
     result = args[IApplicationContext::APPLICATION_ARGS].toStringList();
   }
   return result;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryChangeToPerspectiveMenu.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryChangeToPerspectiveMenu.cpp
index b2e87cfab6..99cfd91157 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryChangeToPerspectiveMenu.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryChangeToPerspectiveMenu.cpp
@@ -1,251 +1,251 @@
 /*============================================================================
 
 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 "berryChangeToPerspectiveMenu.h"
 
 #include <berryMenuManager.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 #include <berryCommandContributionItem.h>
 #include <berrySeparator.h>
 #include <berryIPluginContribution.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryIWorkbenchCommandConstants.h>
 #include <berryObjectString.h>
 #include <berryObjects.h>
 
 #include "berryCommandContributionItemParameter.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryWorkbenchPreferenceConstants.h"
 #include "berryPreferenceConstants.h"
 
 #include <QMenu>
 
 #include <mitkIPreferences.h>
 
 namespace  berry {
 
 const QString ChangeToPerspectiveMenu::NO_TARGETS_MSG = "<No Applicable Perspectives>";
 
 bool PerspectiveComparator(const IPerspectiveDescriptor::Pointer& d1,
                            const IPerspectiveDescriptor::Pointer& d2)
 {
   return d1->GetLabel() < d2->GetLabel();
 }
 
 ChangeToPerspectiveMenu::ChangeToPerspectiveMenu(IWorkbenchWindow* window, const QString& id)
   : ContributionItem(id)
   , window(window)
   , reg(window->GetWorkbench()->GetPerspectiveRegistry())
   , showActive(true)
   , dirty(true)
 {
 
   CommandContributionItemParameter::Pointer showDlgItemParms(
         new CommandContributionItemParameter(
           window, QString::null, IWorkbenchCommandConstants::PERSPECTIVES_SHOW_PERSPECTIVE,
           CommandContributionItem::STYLE_PUSH));
   showDlgItemParms->label = "&Other...";
   showDlgItem = new CommandContributionItem(showDlgItemParms);
 
   // indicate that a open perspectives submenu has been created
   /*
   if (WorkbenchWindow* window = dynamic_cast<WorkbenchWindow*>(window))
   {
     window->AddSubmenu(WorkbenchWindow::OPEN_PERSPECTIVE_SUBMENU);
   }
   */
 }
 
 void ChangeToPerspectiveMenu::Fill(QMenu* menu, QAction* before)
 {
   if (MenuManager* mm = dynamic_cast<MenuManager*>(GetParent()))
   {
     this->connect(mm, SIGNAL(AboutToShow(IMenuManager*)), SLOT(AboutToShow(IMenuManager*)));
   }
 
   if (!dirty)
   {
     return;
   }
 
   MenuManager::Pointer manager(new MenuManager());
   FillMenu(manager.GetPointer());
 
   QList<IContributionItem::Pointer> items = manager->GetItems();
   if (items.isEmpty())
   {
     auto   action = new QAction(NO_TARGETS_MSG, menu);
     action->setEnabled(false);
     menu->insertAction(before, action);
   }
   else
   {
     foreach (IContributionItem::Pointer item, items)
     {
       item->Fill(menu, before);
     }
   }
   dirty = false;
 }
 
 bool ChangeToPerspectiveMenu::IsDirty() const
 {
   return dirty;
 }
 
 bool ChangeToPerspectiveMenu::IsDynamic() const
 {
   return true;
 }
 
 void ChangeToPerspectiveMenu::AboutToShow(IMenuManager* manager)
 {
   manager->MarkDirty();
   dirty = true;
 }
 
 void ChangeToPerspectiveMenu::FillMenu(IMenuManager* manager)
 {
   // Clear out the manager so that we have a blank slate.
   manager->RemoveAll();
 
   // Collect and sort perspective descriptors.
   QList<IPerspectiveDescriptor::Pointer> persps = GetPerspectiveShortcuts();
-  qSort(persps.begin(), persps.end(), PerspectiveComparator);
+  std::sort(persps.begin(), persps.end(), PerspectiveComparator);
 
   /*
    * Convert the perspective descriptors to command parameters, and filter
    * using the activity/capability mechanism.
    */
   for (const IPerspectiveDescriptor::Pointer &descriptor : qAsConst(persps))
   {
     CommandContributionItemParameter::Pointer ccip = GetItem(descriptor);
 
     //    if (WorkbenchActivityHelper.filterItem(ccip)) {
     //      continue;
     //    }
     CommandContributionItem::Pointer item(new CommandContributionItem(ccip));
     manager->Add(item);
   }
 
   auto* prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
   bool showOther = prefs->GetBool(WorkbenchPreferenceConstants::SHOW_OTHER_IN_PERSPECTIVE_MENU, true);
   if (showOther)
   {
     // Add a separator and then "Other..."
     if (!manager->IsEmpty())
     {
       IContributionItem::Pointer separator(new Separator());
       manager->Add(separator);
     }
     manager->Add(showDlgItem);
   }
 }
 
 SmartPointer<CommandContributionItemParameter> ChangeToPerspectiveMenu::GetItem(const IPerspectiveDescriptor::Pointer& desc) const
 {
   auto* prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
   int mode = prefs->GetInt(PreferenceConstants::OPEN_PERSP_MODE, PreferenceConstants::OPM_ACTIVE_PAGE);
   IWorkbenchPage::Pointer page = window->GetActivePage();
   IPerspectiveDescriptor::Pointer persp;
   if (page.IsNotNull())
   {
     persp = page->GetPerspective();
   }
 
   QString perspId = desc->GetId();
 
   class PluginCCIP : public CommandContributionItemParameter, public IPluginContribution
   {
     QString localId;
     QString pluginId;
 
   public:
 
     typedef PluginCCIP Self;
     static const char* GetStaticClassName() { return "PluginCCIP"; }
     berryObjectTypeInfo(CommandContributionItemParameter, IPluginContribution)
 
     PluginCCIP(const IPerspectiveDescriptor::Pointer& v, IServiceLocator* serviceLocator,
                const QString& id, const QString& commandId, CommandContributionItem::Style style)
       : CommandContributionItemParameter(serviceLocator, id, commandId, style)
     {
 
 
       PerspectiveDescriptor::Pointer vd = v.Cast<PerspectiveDescriptor>();
       localId = vd->GetLocalId();
       pluginId = vd->GetPluginId();
     }
 
     QString GetLocalId() const override
     {
       return localId;
     }
 
     QString GetPluginId() const override
     {
       return pluginId;
     }
   };
 
   CommandContributionItemParameter::Pointer parms(new PluginCCIP(desc,
       window, perspId, IWorkbenchCommandConstants::PERSPECTIVES_SHOW_PERSPECTIVE,
       CommandContributionItem::STYLE_PUSH));
   parms->label = desc->GetLabel();
   parms->icon = desc->GetImageDescriptor();
 
   Object::Pointer strId(new ObjectString(perspId));
   parms->parameters.insert(IWorkbenchCommandConstants::PERSPECTIVES_SHOW_PERSPECTIVE_PARM_ID, strId);
 
   // Only open a new window if user preference is set and the window
   // has an active perspective.
   if (PreferenceConstants::OPM_NEW_WINDOW == mode && persp.IsNotNull())
   {
     Object::Pointer bNewWnd(new ObjectBool(true));
     parms->parameters.insert(IWorkbenchCommandConstants::PERSPECTIVES_SHOW_PERSPECTIVE_PARM_NEWWINDOW,
                              bNewWnd);
   }
 
   return parms;
 }
 
 QList<SmartPointer<IPerspectiveDescriptor> > ChangeToPerspectiveMenu::GetPerspectiveShortcuts() const
 {
   QList<IPerspectiveDescriptor::Pointer> list;
 
   IWorkbenchPage::Pointer page = window->GetActivePage();
   if (page.IsNull())
   {
     return list;
   }
 
   QList<QString> ids = page->GetPerspectiveShortcuts();
   for (int i = 0; i < ids.size(); i++)
   {
     IPerspectiveDescriptor::Pointer desc = reg->FindPerspectiveWithId(ids[i]);
     if (desc.IsNotNull() && !list.contains(desc))
     {
       /*
       if (WorkbenchActivityHelper::FilterItem(desc))
       {
         continue;
       }
       */
       list.push_back(desc);
     }
   }
 
   return list;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryEditorRegistry.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryEditorRegistry.cpp
index 920abd7639..139d7056f3 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());
+  std::sort(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.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/berryQtStylePreferencePage.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryQtStylePreferencePage.cpp
index 281326281c..5b8cb25bb4 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryQtStylePreferencePage.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryQtStylePreferencePage.cpp
@@ -1,272 +1,272 @@
 /*============================================================================
 
 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 "berryQtStylePreferencePage.h"
 
 #include "berryWorkbenchPlugin.h"
 #include <berryQtPreferences.h>
 
 #include <QFileDialog>
 #include <QDirIterator>
 #include <QFontDatabase>
 
 #include <mitkIPreferences.h>
 
 namespace
 {
   mitk::IPreferences* GetPreferences()
   {
     return berry::WorkbenchPlugin::GetDefault()->GetPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
   }
 }
 
 namespace berry
 {
 
 QtStylePreferencePage::QtStylePreferencePage()
 {
 
 }
 
 void QtStylePreferencePage::Init(IWorkbench::Pointer )
 {
 
 }
 
 void QtStylePreferencePage::CreateQtControl(QWidget* parent)
 {
   mainWidget = new QWidget(parent);
   controls.setupUi(mainWidget);
 
   ctkPluginContext* context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
   if (styleManagerRef)
   {
     styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
   }
 
   Update();
 
   connect(controls.m_StylesCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(StyleChanged(int)));
   connect(controls.m_FontComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(FontChanged(int)));
   connect(controls.m_FontSizeSpinBox, SIGNAL(valueChanged(int)), this, SLOT(FontChanged(int)));
   connect(controls.m_PathList, SIGNAL(itemSelectionChanged()), this, SLOT(UpdatePathListButtons()));
   connect(controls.m_AddButton, SIGNAL(clicked(bool)), this, SLOT(AddPathClicked(bool)));
   connect(controls.m_EditButton, SIGNAL(clicked(bool)), this, SLOT(EditPathClicked(bool)));
   connect(controls.m_RemoveButton, SIGNAL(clicked(bool)), this, SLOT(RemovePathClicked(bool)));
 }
 
 void QtStylePreferencePage::FillStyleCombo(const berry::IQtStyleManager::Style& currentStyle)
 {
   controls.m_StylesCombo->clear();
   styles.clear();
   styleManager->GetStyles(styles);
 
-  qSort(styles);
+  std::sort(styles.begin(), styles.end());
   for (int i = 0; i < styles.size(); ++i)
   {
     controls.m_StylesCombo->addItem(styles.at(i).name, QVariant(styles.at(i).fileName));
   }
   controls.m_StylesCombo->setCurrentIndex(styles.indexOf(currentStyle));
 }
 
 void QtStylePreferencePage::FillFontCombo(const QString& currentFont)
 {
   controls.m_FontComboBox->clear();
   QStringList fonts;
   styleManager->GetFonts(fonts);
 
   for (int i = 0; i < fonts.size(); ++i)
   {
     controls.m_FontComboBox->addItem(fonts.at(i));
   }
   controls.m_FontComboBox->setCurrentIndex(fonts.indexOf(currentFont));
   if (currentFont == QString("<<system>>"))
   {
     controls.m_FontSizeSpinBox->setEnabled(false);
   }
   else
   {
     controls.m_FontSizeSpinBox->setEnabled(true);
   }
 }
 
 void QtStylePreferencePage::AddPath(const QString& path, bool updateCombo)
 {
   if (!controls.m_PathList->findItems(path, Qt::MatchCaseSensitive).isEmpty()) return;
 
   new QListWidgetItem(path, controls.m_PathList);
 
   styleManager->AddStyles(path);
 
   if (updateCombo)
     FillStyleCombo(oldStyle);
 }
 
 void QtStylePreferencePage::StyleChanged(int /*index*/)
 {
   QString fileName = controls.m_StylesCombo->itemData(controls.m_StylesCombo->currentIndex()).toString();
   styleManager->SetStyle(fileName);
 }
 
 void QtStylePreferencePage::FontChanged(int /*index*/)
 {
   QString fontName = controls.m_FontComboBox->currentText();
   int fontSize = controls.m_FontSizeSpinBox->value();
 
   if (fontName == QString("<<system>>"))
   {
     controls.m_FontSizeSpinBox->setEnabled(false);
   }
   else
   {
     controls.m_FontSizeSpinBox->setEnabled(true);
   }
 
   styleManager->SetFont(fontName);
   styleManager->SetFontSize(fontSize);
   styleManager->UpdateWorkbenchFont();
 }
 
 void QtStylePreferencePage::AddPathClicked(bool /*checked*/)
 {
   QListWidgetItem* item = controls.m_PathList->currentItem();
   QString initialDir;
   if (item) initialDir = item->text();
   QString dir = QFileDialog::getExistingDirectory(mainWidget, "", initialDir);
 
   if (!dir.isEmpty()) this->AddPath(dir, true);
 }
 
 void QtStylePreferencePage::RemovePathClicked(bool /*checked*/)
 {
   QList<QListWidgetItem*> selection = controls.m_PathList->selectedItems();
   QListIterator<QListWidgetItem*> it(selection);
   while (it.hasNext())
   {
     QListWidgetItem* item = it.next();
     QString dir = item->text();
 
     controls.m_PathList->takeItem(controls.m_PathList->row(item));
     delete item;
     styleManager->RemoveStyles(dir);
   }
 
   if (!styleManager->Contains(oldStyle.fileName))
   {
     oldStyle = styleManager->GetDefaultStyle();
   }
 
   FillStyleCombo(oldStyle);
 }
 
 void QtStylePreferencePage::EditPathClicked(bool checked)
 {
   QListWidgetItem* item = controls.m_PathList->currentItem();
   QString initialDir = item->text();
   QString dir = QFileDialog::getExistingDirectory(mainWidget, "", initialDir);
 
   if (!dir.isEmpty())
   {
     this->RemovePathClicked(checked);
     this->AddPath(dir, true);
   }
 }
 
 void QtStylePreferencePage::UpdatePathListButtons()
 {
   int s = controls.m_PathList->selectedItems().size();
 
   if (s == 0)
   {
     controls.m_EditButton->setEnabled(false);
     controls.m_RemoveButton->setEnabled(false);
   }
   else if (s == 1)
   {
     controls.m_EditButton->setEnabled(true);
     controls.m_RemoveButton->setEnabled(true);
   }
   else
   {
     controls.m_EditButton->setEnabled(false);
     controls.m_RemoveButton->setEnabled(true);
   }
 }
 
 QWidget* QtStylePreferencePage::GetQtControl() const
 {
   return mainWidget;
 }
 
 bool QtStylePreferencePage::PerformOk()
 {
   auto* prefs = GetPreferences();
 
   prefs->Put(berry::QtPreferences::QT_STYLE_NAME, controls.m_StylesCombo->itemData(controls.m_StylesCombo->currentIndex()).toString().toStdString());
 
   QString paths;
   for (int i = 0; i < controls.m_PathList->count(); ++i)
   {
     QString path = controls.m_PathList->item(i)->text() + ";";
     paths += path;
   }
 
   prefs->Put(berry::QtPreferences::QT_STYLE_SEARCHPATHS, paths.toStdString());
   prefs->Put(berry::QtPreferences::QT_FONT_NAME, controls.m_FontComboBox->currentText().toStdString());
   prefs->Put(berry::QtPreferences::QT_FONT_SIZE, std::to_string(controls.m_FontSizeSpinBox->value()));
 
   prefs->PutBool(berry::QtPreferences::QT_SHOW_TOOLBAR_CATEGORY_NAMES,
     controls.m_ToolbarCategoryCheckBox->isChecked());
 
   return true;
 }
 
 void QtStylePreferencePage::PerformCancel()
 {
   Update();
 }
 
 void QtStylePreferencePage::Update()
 {
   styleManager->RemoveStyles();
 
   auto* prefs = GetPreferences();
 
   auto paths = QString::fromStdString(prefs->Get(berry::QtPreferences::QT_STYLE_SEARCHPATHS, ""));
   QStringList pathList = paths.split(";", Qt::SkipEmptyParts);
   QStringListIterator it(pathList);
   while (it.hasNext())
   {
     AddPath(it.next(), false);
   }
 
   auto styleName = QString::fromStdString(prefs->Get(berry::QtPreferences::QT_STYLE_NAME, ""));
   styleManager->SetStyle(styleName);
   oldStyle = styleManager->GetStyle();
   FillStyleCombo(oldStyle);
 
   auto fontName = QString::fromStdString(prefs->Get(berry::QtPreferences::QT_FONT_NAME, "Open Sans"));
   styleManager->SetFont(fontName);
 
   auto fontSize = std::stoi(prefs->Get(berry::QtPreferences::QT_FONT_SIZE, "9"));
   styleManager->SetFontSize(fontSize);
   controls.m_FontSizeSpinBox->setValue(fontSize);
   styleManager->UpdateWorkbenchFont();
 
   FillFontCombo(styleManager->GetFont());
 
   controls.m_ToolbarCategoryCheckBox->setChecked(
     prefs->GetBool(berry::QtPreferences::QT_SHOW_TOOLBAR_CATEGORY_NAMES, true));
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryRegistryReader.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryRegistryReader.cpp
index bc82394674..a2bb630a98 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryRegistryReader.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryRegistryReader.cpp
@@ -1,159 +1,159 @@
 /*============================================================================
 
 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 <berryIExtensionRegistry.h>
 #include <berryIExtension.h>
 #include <berryIConfigurationElement.h>
 #include <berryIContributor.h>
 
 #include "berryRegistryReader.h"
 
 #include "berryWorkbenchPlugin.h"
 #include "berryWorkbenchRegistryConstants.h"
 
 namespace {
 
 bool CompareExtensionsByContributor(const berry::IExtension::Pointer& e1,
                                     const berry::IExtension::Pointer& e2)
 {
   return e1->GetContributor()->GetName().compare(e2->GetContributor()->GetName(), Qt::CaseInsensitive) < 0;
 }
 
 }
 
 namespace berry
 {
 
 RegistryReader::RegistryReader()
 {
 }
 
 RegistryReader::~RegistryReader()
 {
 }
 
 void RegistryReader::LogError(const IConfigurationElement::Pointer& element,
                               const QString& text)
 {
   IExtension::Pointer extension = element->GetDeclaringExtension();
   QString buf = QString("Plugin ") + extension->GetContributor()->GetName() + ", extension "
       + extension->GetExtensionPointUniqueIdentifier();
   // look for an ID if available - this should help debugging
   QString id = element->GetAttribute("id");
   if (!id.isEmpty())
   {
     buf.append(", id ");
     buf.append(id);
   }
   buf.append(": " + text);
   WorkbenchPlugin::Log(buf);
 }
 
 void RegistryReader::LogMissingAttribute(
     const IConfigurationElement::Pointer& element, const QString& attributeName)
 {
   RegistryReader::LogError(element, "Required attribute '" + attributeName + "' not defined");
 }
 
 void RegistryReader::LogMissingElement(
     const IConfigurationElement::Pointer& element, const QString& elementName)
 {
   RegistryReader::LogError(element, "Required sub element '" + elementName + "' not defined");
 }
 
 void RegistryReader::LogUnknownElement(
     const IConfigurationElement::Pointer& element)
 {
   RegistryReader::LogError(element, "Unknown extension tag found: " + element->GetName());
 }
 
 QList<IExtension::Pointer> RegistryReader::OrderExtensions(
     const QList<IExtension::Pointer>& extensions)
 {
   // By default, the order is based on plugin id sorted
   // in ascending order. The order for a plugin providing
   // more than one extension for an extension point is
   // dependent in the order listed in the XML file.
   QList<IExtension::Pointer> sortedExtension(extensions);
-  qStableSort(sortedExtension.begin(), sortedExtension.end(),
+  std::stable_sort(sortedExtension.begin(), sortedExtension.end(),
               CompareExtensionsByContributor);
   return sortedExtension;
 }
 
 void RegistryReader::ReadElementChildren(
     const IConfigurationElement::Pointer& element)
 {
   this->ReadElements(element->GetChildren());
 }
 
 void RegistryReader::ReadElements(
     const QList<IConfigurationElement::Pointer>& elements)
 {
   for (int i = 0; i < elements.size(); i++)
   {
     if (!this->ReadElement(elements[i]))
     {
       RegistryReader::LogUnknownElement(elements[i]);
     }
   }
 }
 
 void RegistryReader::ReadExtension(const IExtension::Pointer& extension)
 {
   this->ReadElements(extension->GetConfigurationElements());
 }
 
 void RegistryReader::ReadRegistry(IExtensionRegistry* registry,
                                   const QString& pluginId, const QString& extensionPoint)
 {
   IExtensionPoint::Pointer point = registry->GetExtensionPoint(pluginId, extensionPoint);
   if (point == 0)
   {
     return;
   }
   QList<IExtension::Pointer> extensions(point->GetExtensions());
   extensions = this->OrderExtensions(extensions);
   for (int i = 0; i < extensions.size(); i++)
   {
     this->ReadExtension(extensions[i]);
   }
 }
 
 QString RegistryReader::GetDescription(const IConfigurationElement::Pointer& configElement)
 {
   QList<IConfigurationElement::Pointer> children(configElement->GetChildren(WorkbenchRegistryConstants::TAG_DESCRIPTION));
   if (children.size() >= 1)
   {
     return children[0]->GetValue();
   }
   return "";
 }
 
 QString RegistryReader::GetClassValue(
     const IConfigurationElement::Pointer& configElement,
     const QString& classAttributeName)
 {
   QString className = configElement->GetAttribute(classAttributeName);
   if (!className.isEmpty())
   {
     return className;
   }
   QList<IConfigurationElement::Pointer> candidateChildren(configElement->GetChildren(classAttributeName));
   if (candidateChildren.isEmpty())
   {
     return "";
   }
 
   return candidateChildren[0]->GetAttribute(WorkbenchRegistryConstants::ATT_CLASS);
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryShowViewMenu.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryShowViewMenu.cpp
index e66d27ec25..6b1205498e 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryShowViewMenu.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryShowViewMenu.cpp
@@ -1,275 +1,275 @@
 /*============================================================================
 
 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 "berryShowViewMenu.h"
 
 #include <berryMenuManager.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 #include <berryCommandContributionItem.h>
 #include <berrySeparator.h>
 #include <berryIPluginContribution.h>
 #include <berryIViewRegistry.h>
 #include <berryIWorkbenchCommandConstants.h>
 #include <berryObjectString.h>
 
 #include "berryCommandContributionItemParameter.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryViewDescriptor.h"
 #include "intro/berryIntroConstants.h"
 
 #include <QMenu>
 #include <QSet>
 #include <QPair>
 
 namespace berry {
 
 const QString ShowViewMenu::NO_TARGETS_MSG = "<No Applicable Views>";
 
 struct ActionComparator {
   bool operator()(const CommandContributionItemParameter::Pointer& p1,
                   const CommandContributionItemParameter::Pointer& p2) const
   {
     return p1->label < p2->label;
   }
 };
 
 ShowViewMenu::ShowViewMenu(IWorkbenchWindow *window, const QString& id)
   : ContributionItem(id), dirty(true), window(window)
 {
   CommandContributionItemParameter::Pointer showDlgItemParms(
         new CommandContributionItemParameter(
           window, QString(), IWorkbenchCommandConstants::VIEWS_SHOW_VIEW,
           CommandContributionItem::STYLE_PUSH));
   showDlgItemParms->label = "&Other...";
   showDlgItem = new CommandContributionItem(showDlgItemParms);
 
 //  window.getWorkbench().getHelpSystem().setHelp(showDlgAction,
 //      IWorkbenchHelpContextIds.SHOW_VIEW_OTHER_ACTION);
 //  // indicate that a show views submenu has been created
 //  if (window instanceof WorkbenchWindow) {
 //    ((WorkbenchWindow) window)
 //        .addSubmenu(WorkbenchWindow.SHOW_VIEW_SUBMENU);
 //  }
 
 }
 
 bool ShowViewMenu::IsDirty() const
 {
   return dirty;
 }
 
 /**
  * Overridden to always return true and force dynamic menu building.
  */
 bool ShowViewMenu::IsDynamic() const
 {
   return true;
 }
 
 void ShowViewMenu::Fill(QMenu* menu, QAction* before)
 {
   if (MenuManager* mm = dynamic_cast<MenuManager*>(GetParent()))
   {
     this->connect(mm, SIGNAL(AboutToShow(IMenuManager*)), SLOT(AboutToShow(IMenuManager*)));
   }
 
   if (!dirty)
   {
     return;
   }
 
   MenuManager::Pointer manager(new MenuManager());
   FillMenu(manager.GetPointer());
 
   QList<IContributionItem::Pointer> items = manager->GetItems();
   if (items.isEmpty())
   {
     auto   action = new QAction(NO_TARGETS_MSG, menu);
     action->setEnabled(false);
     menu->insertAction(before, action);
   }
   else
   {
     foreach (IContributionItem::Pointer item, items)
     {
       item->Fill(menu, before);
     }
   }
 
   dirty = false;
 }
 
 void ShowViewMenu::FillMenu(IMenuManager* innerMgr)
 {
   // Remove all.
   innerMgr->RemoveAll();
 
   // If no page disable all.
   IWorkbenchPage::Pointer page = window->GetActivePage();
   if (page.IsNull())
   {
     return;
   }
 
   // If no active perspective disable all
   if (page->GetPerspective().IsNull())
   {
     return;
   }
 
   typedef QPair<QString,QString> ViewIdPair;
 
   // Get visible actions.
   QSet<ViewIdPair> viewIds = GetShortcuts(page.GetPointer());
 
   // add all open views
   viewIds = AddOpenedViews(page.GetPointer(), viewIds);
 
   QList<CommandContributionItemParameter::Pointer> actions;
 
   foreach (ViewIdPair id, viewIds)
   {
     if (id.first == IntroConstants::INTRO_VIEW_ID)
     {
       continue;
     }
     CommandContributionItemParameter::Pointer item = GetItem(id.first, id.second);
     if (item)
     {
       actions.append(item);
     }
   }
-  qSort(actions.begin(), actions.end(), ActionComparator());
+  std::sort(actions.begin(), actions.end(), ActionComparator());
   foreach (CommandContributionItemParameter::Pointer ccip, actions)
   {
 //    if (WorkbenchActivityHelper.filterItem(ccip)) {
 //      continue;
 //    }
     CommandContributionItem::Pointer item(new CommandContributionItem(ccip));
     innerMgr->Add(item);
   }
 
   // We only want to add the separator if there are show view shortcuts,
   // otherwise, there will be a separator and then the 'Other...' entry
   // and that looks weird as the separator is separating nothing
   if (!innerMgr->IsEmpty())
   {
     IContributionItem::Pointer separator(new Separator());
     innerMgr->Add(separator);
   }
 
   // Add Other...
   innerMgr->Add(showDlgItem);
 }
 
 QSet<QPair<QString,QString> > ShowViewMenu::GetShortcuts(IWorkbenchPage* page) const
 {
   QSet<QPair<QString,QString> > list;
   QList<QString> shortcuts(page->GetShowViewShortcuts());
   for (int i = 0; i < shortcuts.size(); ++i)
   {
     list.insert(qMakePair(shortcuts[i], QString()));
   }
   return list;
 }
 
 void ShowViewMenu::AboutToShow(IMenuManager* manager)
 {
   manager->MarkDirty();
   this->dirty = true;
 }
 
 CommandContributionItemParameter::Pointer ShowViewMenu::GetItem(const QString& viewId, const QString& secondaryId) const
 {
   IViewRegistry* reg = WorkbenchPlugin::GetDefault()->GetViewRegistry();
   IViewDescriptor::Pointer desc = reg->Find(viewId);
   if (desc.IsNull())
   {
     return CommandContributionItemParameter::Pointer(nullptr);
   }
   QString label = desc->GetLabel();
 
   class PluginCCIP : public CommandContributionItemParameter, public IPluginContribution
   {
     QString localId;
     QString pluginId;
 
   public:
 
     typedef PluginCCIP Self;
     static const char* GetStaticClassName() { return "PluginCCIP"; }
     berryObjectTypeInfo(CommandContributionItemParameter, IPluginContribution)
 
     PluginCCIP(const IViewDescriptor::Pointer& v, IServiceLocator* serviceLocator,
                const QString& id, const QString& commandId, CommandContributionItem::Style style)
       : CommandContributionItemParameter(serviceLocator, id, commandId, style)
     {
       ViewDescriptor::Pointer vd = v.Cast<ViewDescriptor>();
       localId = vd->GetLocalId();
       pluginId = vd->GetPluginId();
     }
 
     QString GetLocalId() const override
     {
       return localId;
     }
 
     QString GetPluginId() const override
     {
       return pluginId;
     }
   };
 
   CommandContributionItemParameter::Pointer parms(new PluginCCIP(desc,
       window, viewId, IWorkbenchCommandConstants::VIEWS_SHOW_VIEW,
       CommandContributionItem::STYLE_PUSH));
   parms->label = label;
   parms->icon = desc->GetImageDescriptor();
 
   Object::Pointer strViewId(new ObjectString(viewId));
   parms->parameters.insert(IWorkbenchCommandConstants::VIEWS_SHOW_VIEW_PARM_ID, strViewId);
 //  if (makeFast)
 //  {
 //    parms.parameters.put(
 //        IWorkbenchCommandConstants.VIEWS_SHOW_VIEW_PARM_FASTVIEW,
 //        "true"); //$NON-NLS-1$
 //  }
   if (!secondaryId.isEmpty())
   {
     Object::Pointer strSecondaryId(new ObjectString(secondaryId));
     parms->parameters.insert(IWorkbenchCommandConstants::VIEWS_SHOW_VIEW_SECONDARY_ID,
                             strSecondaryId);
   }
   return parms;
 }
 
 QSet<QPair<QString,QString> > ShowViewMenu::AddOpenedViews(IWorkbenchPage* page,
                                                            QSet<QPair<QString,QString> >& actions) const
 {
   QSet<QPair<QString,QString> > views = GetParts(page);
   return views.unite(actions);
 }
 
 QSet<QPair<QString,QString> > ShowViewMenu::GetParts(IWorkbenchPage* page) const
 {
   QSet<QPair<QString,QString> > parts;
   QList<IViewReference::Pointer> refs = page->GetViewReferences();
   for (int i = 0; i < refs.size(); ++i)
   {
     parts.insert(qMakePair(refs[i]->GetId(), refs[i]->GetSecondaryId()));
   }
   return parts;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/dialogs/berryPerspectivesPreferencePage.cpp b/Plugins/org.blueberry.ui.qt/src/internal/dialogs/berryPerspectivesPreferencePage.cpp
index 7b314e961f..ad0a0a8df1 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/dialogs/berryPerspectivesPreferencePage.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/dialogs/berryPerspectivesPreferencePage.cpp
@@ -1,292 +1,292 @@
 /*============================================================================
 
 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 "berryPerspectivesPreferencePage.h"
 #include "ui_berryPerspectivesPreferencePage.h"
 
 #include <berryIWorkbenchPage.h>
 
 #include "internal/berryPerspective.h"
 #include "internal/berryPerspectiveRegistry.h"
 #include "internal/berryPreferenceConstants.h"
 #include "internal/berryWorkbenchPage.h"
 #include "berryWorkbenchPlugin.h"
 
 #include <QListWidgetItem>
 #include <QMessageBox>
 
 #include <mitkIPreferences.h>
 
 namespace
 {
   mitk::IPreferences* GetPreferences()
   {
     return berry::WorkbenchPlugin::GetDefault()->GetPreferences();
   }
 }
 
 namespace berry {
 
 bool PerspectiveComparator(const PerspectiveDescriptor::Pointer& p1, const PerspectiveDescriptor::Pointer& p2)
 {
   return p1->GetLabel() < p2->GetLabel();
 }
 
 PerspectivesPreferencePage::PerspectivesPreferencePage()
   : ui(nullptr)
   , pageWidget(nullptr)
   , workbench(nullptr)
   , perspRegistry(nullptr)
 {
 }
 
 PerspectivesPreferencePage::~PerspectivesPreferencePage()
 {
   delete ui;
 }
 
 
 void PerspectivesPreferencePage::Init(berry::IWorkbench::Pointer workbench)
 {
   ui = new Ui::PerspectivesPreferencePage;
 
   this->workbench = workbench.GetPointer();
   perspRegistry = dynamic_cast<PerspectiveRegistry*>(workbench->GetPerspectiveRegistry());
 }
 
 void PerspectivesPreferencePage::CreateQtControl(QWidget* parent)
 {
   pageWidget = new QWidget(parent);
   ui->setupUi(pageWidget);
 
   ui->perspectivesListWidget->setSelectionMode(QAbstractItemView::SingleSelection);
   ui->perspectivesListWidget->setIconSize(QSize(16, 16));
 
   connect(ui->sameWindowButton, SIGNAL(clicked()), this, SLOT(OpenPerspInSameWindow()));
   connect(ui->newWindowButton, SIGNAL(clicked()), this, SLOT(OpenPerspInNewWindow()));
   connect(ui->perspectivesListWidget, SIGNAL(itemSelectionChanged()), this, SLOT(PerspectiveSelectionChanged()));
 
   connect(ui->revertButton, SIGNAL(clicked()), this, SLOT(RevertPerspective()));
   connect(ui->makeDefaultButton, SIGNAL(clicked()), this, SLOT(MakeDefaultPerspective()));
   connect(ui->deleteButton, SIGNAL(clicked()), this, SLOT(DeletePerspective()));
 
   this->Update();
 }
 
 QWidget* PerspectivesPreferencePage::GetQtControl() const
 {
   return pageWidget;
 }
 
 bool PerspectivesPreferencePage::PerformOk()
 {
   // Set the default perspective
   if (defaultPerspectiveId != perspRegistry->GetDefaultPerspective())
   {
     perspRegistry->SetDefaultPerspective(defaultPerspectiveId);
   }
 
   //Delete the perspective
   if(perspectives.size() < perspRegistry->GetPerspectives().size())
   {
     QList<IWorkbenchWindow::Pointer> windows = workbench->GetWorkbenchWindows();
 
     // close any perspectives that are about to be deleted
     for (int i = 0; i < windows.size(); i++)
     {
       QList<IWorkbenchPage::Pointer> pages = windows[i]->GetPages();
       for (int j = 0; j < pages.size(); j++)
       {
         WorkbenchPage::Pointer page = pages[j].Cast<WorkbenchPage>();
         for (int k = 0; k < perspToDelete.size(); k++)
         {
           IPerspectiveDescriptor::Pointer desc(perspToDelete[k].GetPointer());
           if (page->FindPerspective(desc).IsNotNull())
           {
             page->ClosePerspective(desc, true, true);
           }
         }
       }
     }
     perspRegistry->DeletePerspectives(perspToDelete);
   }
 
   // Revert the perspectives
   perspRegistry->RevertPerspectives(perspToRevert);
 
   // store the open perspective mode setting
   auto* prefs = GetPreferences();
   prefs->PutInt(PreferenceConstants::OPEN_PERSP_MODE, openPerspMode);
 
   return true;
 }
 
 void PerspectivesPreferencePage::PerformCancel()
 {
 
 }
 
 void PerspectivesPreferencePage::Update()
 {
   auto* prefs = GetPreferences();
   openPerspMode = prefs->GetInt(PreferenceConstants::OPEN_PERSP_MODE, PreferenceConstants::OPM_ACTIVE_PAGE);
 
   ui->sameWindowButton->setChecked(openPerspMode == PreferenceConstants::OPM_ACTIVE_PAGE);
   ui->newWindowButton->setChecked(openPerspMode == PreferenceConstants::OPM_NEW_WINDOW);
 
   // Populate the perspectivesTable
   perspectives.clear();
   perspToRevert.clear();
   perspToDelete.clear();
   QList<IPerspectiveDescriptor::Pointer> persps = perspRegistry->GetPerspectives();
   for (int i = 0; i < persps.size(); i++)
   {
     perspectives.push_back(persps[i].Cast<PerspectiveDescriptor>());
   }
-  qSort(perspectives.begin(), perspectives.end(), PerspectiveComparator);
+  std::sort(perspectives.begin(), perspectives.end(), PerspectiveComparator);
   defaultPerspectiveId = perspRegistry->GetDefaultPerspective();
   UpdatePerspectivesTable();
 }
 
 void PerspectivesPreferencePage::OpenPerspInSameWindow()
 {
   openPerspMode = PreferenceConstants::OPM_ACTIVE_PAGE;
 }
 
 void PerspectivesPreferencePage::OpenPerspInNewWindow()
 {
   openPerspMode = PreferenceConstants::OPM_NEW_WINDOW;
 }
 
 void PerspectivesPreferencePage::PerspectiveSelectionChanged()
 {
   UpdateButtons();
 }
 
 void PerspectivesPreferencePage::RevertPerspective()
 {
   PerspectiveDescriptor::Pointer desc = GetSelectedPerspective();
   if (desc.IsNotNull() && !perspToRevert.contains(desc))
   {
     perspToRevert.push_back(desc);
   }
   UpdateButtons();
 }
 
 void PerspectivesPreferencePage::DeletePerspective()
 {
   PerspectiveDescriptor::Pointer desc = GetSelectedPerspective();
   if (desc.IsNotNull() && !perspToDelete.contains(desc))
   {
     if (!FindOpenInstance(desc))
     {
       perspToDelete.push_back(desc);
       perspToRevert.removeAll(desc);
       perspectives.removeAll(desc);
       UpdatePerspectivesTable();
     }
   }
   UpdateButtons();
 }
 
 void PerspectivesPreferencePage::MakeDefaultPerspective()
 {
   PerspectiveDescriptor::Pointer desc = GetSelectedPerspective();
   if (desc.IsNotNull() && !perspToDelete.contains(desc))
   {
     int row = perspectives.indexOf(desc);
     defaultPerspectiveId = desc->GetId();
     UpdatePerspectivesTable();
     ui->perspectivesListWidget->item(row)->setSelected(true);
   }
   UpdateButtons();
 }
 
 void PerspectivesPreferencePage::UpdateButtons()
 {
   PerspectiveDescriptor::Pointer desc = GetSelectedPerspective();
   if (desc)
   {
     ui->revertButton->setEnabled(desc->IsPredefined() && desc->HasCustomDefinition() && !perspToRevert.contains(desc));
     ui->deleteButton->setEnabled(!desc->IsPredefined());
     ui->makeDefaultButton->setEnabled(true);
   }
   else
   {
     ui->revertButton->setEnabled(false);
     ui->deleteButton->setEnabled(false);
     ui->makeDefaultButton->setEnabled(false);
   }
 }
 
 void PerspectivesPreferencePage::UpdatePerspectivesTable()
 {
   ui->perspectivesListWidget->clear();
   for (const PerspectiveDescriptor::Pointer &desc : qAsConst(perspectives))
   {
     NewPerspectivesTableItem(desc);
   }
 }
 
 void PerspectivesPreferencePage::NewPerspectivesTableItem(const SmartPointer<PerspectiveDescriptor>& desc)
 {
   QString label = desc->GetLabel();
   if (desc->GetId() == defaultPerspectiveId)
   {
     label += " (default)";
   }
   new QListWidgetItem(desc->GetImageDescriptor(), label, ui->perspectivesListWidget);
 }
 
 bool PerspectivesPreferencePage::FindOpenInstance(const PerspectiveDescriptor::Pointer& desc)
 {
   QList<IWorkbenchWindow::Pointer> windows = workbench->GetWorkbenchWindows();
 
   //find all active perspectives currently
   for (int i = 0; i < windows.size(); i++)
   {
     QList<IWorkbenchPage::Pointer> pages = windows[i]->GetPages();
     for (int j = 0; j < pages.size(); j++)
     {
       WorkbenchPage::Pointer page = pages[j].Cast<WorkbenchPage>();
       if (page->FindPerspective(desc).IsNotNull())
       {
         QMessageBox::StandardButton returnCode =
             QMessageBox::question(workbench->GetActiveWorkbenchWindow()->GetShell()->GetControl(),
                                   "Delete Perspective",
                                   QString("Are you sure you want to delete the \"%1\" perspective? It has open instances.").arg(desc->GetLabel()),
                                   QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
         return (returnCode != QMessageBox::Yes);
       }
     }
   }
 
   return false;
 }
 
 SmartPointer<PerspectiveDescriptor> PerspectivesPreferencePage::GetSelectedPerspective() const
 {
   PerspectiveDescriptor::Pointer desc;
 
   QList<QListWidgetItem*> selection = ui->perspectivesListWidget->selectedItems();
   if (!selection.isEmpty())
   {
     int row = ui->perspectivesListWidget->row(selection.back());
     if (row > -1)
     {
       desc = perspectives.at(row);
     }
   }
   return desc;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp b/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
index 8fe1f286e6..93d035151b 100644
--- a/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
@@ -1,460 +1,461 @@
 /*============================================================================
 
 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>
+#include <QStringList>
 
 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 = 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);
+    std::sort(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.viewnavigator/src/QmitkViewNavigatorWidget.cpp b/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp
index 44be82cacb..e4a7686adf 100644
--- a/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp
@@ -1,729 +1,729 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 // View navigator plugin
 #include <QmitkViewNavigatorWidget.h>
 #include <QmitkPerspectiveItem.h>
 #include <QmitkViewItem.h>
 
 // Blueberry
 #include <berryIWorkbenchWindow.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryPlatform.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIExtensionRegistry.h>
 #include <berryIHandlerService.h>
 #include <berryIWorkbenchCommandConstants.h>
 #include <berryUIElement.h>
 
 // MITK
 #include <mitkLog.h>
 
 // Qt
 #include <QHash>
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QStandardItem>
 #include <QSortFilterProxyModel>
 
 namespace
 {
   QFont getLargeFont()
   {
     QFont font = qApp->font();
     font.setPointSizeF(font.pointSizeF() * 1.25f);
     return font;
   }
 }
 
 class KeywordRegistry
 {
 public:
 
     KeywordRegistry()
     {
         berry::IExtensionRegistry* extensionPointService = berry::Platform::GetExtensionRegistry();
         auto keywordExts = extensionPointService->GetConfigurationElementsFor("org.blueberry.ui.keywords");
         for (auto keywordExtsIt = keywordExts.begin(); keywordExtsIt != keywordExts.end(); ++keywordExtsIt)
         {
             QString keywordId = (*keywordExtsIt)->GetAttribute("id");
             QString keywordLabels = (*keywordExtsIt)->GetAttribute("label");
             m_Keywords[keywordId].push_back(keywordLabels);
         }
     }
 
     QStringList GetKeywords(const QString& id)
     {
         return m_Keywords[id];
     }
 
     QStringList GetKeywords(const QStringList& ids)
     {
         QStringList result;
         for (const auto& id : ids)
         {
             result.append(this->GetKeywords(id));
         }
         return result;
     }
 
 private:
 
     QHash<QString, QStringList> m_Keywords;
 };
 
 class ClassFilterProxyModel : public QSortFilterProxyModel
 {
 public:
 
   ClassFilterProxyModel(QObject* parent = nullptr)
     : QSortFilterProxyModel(parent)
   {
   }
 
   bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const override
   {
     QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
 
     return hasToBeDisplayed(index);
   }
 
 private:
 
   bool displayElement(const QModelIndex index) const
   {
     QString type = sourceModel()->data(index, Qt::DisplayRole).toString();
     QStandardItem* item = dynamic_cast<QStandardItemModel*>(sourceModel())->itemFromIndex(index);
 
     if (type.contains(filterRegularExpression()))
     {
         return true;
     }
 
     QmitkViewItem* viewItem = dynamic_cast<QmitkViewItem*>(item);
     if (nullptr != viewItem)
     {
         for (const auto& tag : viewItem->m_Tags)
         {
             if (tag.contains(filterRegularExpression()))
             {
                 return true;
             }
         }
         if (viewItem->m_Description.contains(filterRegularExpression()))
         {
             return true;
         }
     }
 
     QmitkPerspectiveItem* perspectiveItem = dynamic_cast<QmitkPerspectiveItem*>(item);
     if (nullptr != perspectiveItem)
     {
         for (const auto& tag : perspectiveItem->m_Tags)
         {
             if (tag.contains(filterRegularExpression()))
             {
                 return true;
             }
         }
         if (perspectiveItem->m_Description.contains(filterRegularExpression()))
         {
             return true;
         }
     }
 
     return false;
   }
 
   bool hasToBeDisplayed(const QModelIndex index) const
   {
     bool result = false;
     if (sourceModel()->rowCount(index) > 0)
     {
         for (int i = 0; i < sourceModel()->rowCount(index); i++)
         {
             QModelIndex childIndex = sourceModel()->index(i, 0, index);
             if (!childIndex.isValid())
             {
                 break;
             }
 
             result = hasToBeDisplayed(childIndex);
             result |= displayElement(index);
 
             if (result)
             {
                 break;
             }
         }
     }
     else
     {
         result = displayElement(index);
     }
     return result;
   }
 };
 
 class ViewNavigatorPerspectiveListener: public berry::IPerspectiveListener
 {
 public:
 
     ViewNavigatorPerspectiveListener(QmitkViewNavigatorWidget* parent)
       : m_ParentWidget(parent)
     {
     }
 
     Events::Types GetPerspectiveEventTypes() const override
     {
         return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED
                 // remove the following line when command framework is finished
                 | Events::CLOSED | Events::OPENED | Events::PART_CHANGED;
     }
 
     void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
                               const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
     {
         m_ParentWidget->UpdateTreeList();
     }
 
     void PerspectiveSavedAs(const berry::IWorkbenchPage::Pointer& /*page*/,
                             const berry::IPerspectiveDescriptor::Pointer& /*oldPerspective*/,
                             const berry::IPerspectiveDescriptor::Pointer& /*newPerspective*/) override
     {
         m_ParentWidget->UpdateTreeList();
     }
 
     void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
                                 const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
     {
         m_ParentWidget->m_ActivePerspective = nullptr;
     }
 
     void PerspectiveOpened(const berry::IWorkbenchPage::Pointer& /*page*/,
                            const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
     {
         m_ParentWidget->UpdateTreeList();
     }
 
     void PerspectiveClosed(const berry::IWorkbenchPage::Pointer& /*page*/,
                            const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
     {
         m_ParentWidget->m_ActivePerspective = nullptr;
     }
 
     using IPerspectiveListener::PerspectiveChanged;
 
     void PerspectiveChanged(const berry::IWorkbenchPage::Pointer& /*page*/,
                             const berry::IPerspectiveDescriptor::Pointer& /*perspective*/,
                             const berry::IWorkbenchPartReference::Pointer& partRef, const std::string& changeId)
     {
         if (changeId == "viewHide" && partRef->GetId() == "org.mitk.views.viewnavigator")
             berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->RemovePerspectiveListener(m_ParentWidget->m_PerspectiveListener.data());
         else
             m_ParentWidget->UpdateTreeList();
     }
 
 private:
 
     QmitkViewNavigatorWidget* m_ParentWidget;
 };
 
 class ViewNavigatorViewListener: public berry::IPartListener
 {
 public:
 
   ViewNavigatorViewListener(QmitkViewNavigatorWidget* parent)
       : m_ParentWidget(parent)
     {
     }
 
     Events::Types GetPartEventTypes() const override
     {
         return Events::OPENED | Events::CLOSED;
     }
 
     void PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef) override
     {
       if (partRef->GetId() != "org.mitk.views.viewnavigator")
       {
         m_ParentWidget->UpdateTreeList((partRef->GetPart(false)).GetPointer());
       }
       else
       {
         m_ParentWidget->FillTreeList();
         m_ParentWidget->UpdateTreeList();
       }
     }
 
     void PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef) override
     {
       if (partRef->GetId() != "org.mitk.views.viewnavigator")
       {
         m_ParentWidget->UpdateTreeList();
       }
     }
 
 private:
 
   QmitkViewNavigatorWidget* m_ParentWidget;
 };
 
 bool compareViews(const berry::IViewDescriptor::Pointer& a, const berry::IViewDescriptor::Pointer& b)
 {
     if (a.IsNull() || b.IsNull())
     {
         return false;
     }
 
     return a->GetLabel().compare(b->GetLabel()) < 0;
 }
 
 bool comparePerspectives(const berry::IPerspectiveDescriptor::Pointer& a, const berry::IPerspectiveDescriptor::Pointer& b)
 {
     if (a.IsNull() || b.IsNull())
     {
         return false;
     }
 
     return a->GetLabel().compare(b->GetLabel()) < 0;
 }
 
 bool compareQStandardItems(const QStandardItem* a, const QStandardItem* b)
 {
     if (nullptr == a || nullptr== b)
     {
         return false;
     }
 
     return a->text().compare(b->text()) < 0;
 }
 
 QmitkViewNavigatorWidget::QmitkViewNavigatorWidget(berry::IWorkbenchWindow::Pointer window,
                                                    QWidget* parent,
                                                    Qt::WindowFlags)
     : QWidget(parent)
     , m_Window(window)
 {
     this->CreateQtPartControl(this);
 }
 
 QmitkViewNavigatorWidget::~QmitkViewNavigatorWidget()
 {
   m_Window->RemovePerspectiveListener(m_PerspectiveListener.data());
   m_Window->GetPartService()->RemovePartListener(m_ViewPartListener.data());
 }
 
 void QmitkViewNavigatorWidget::SetFocus()
 {
   m_Controls.lineEdit->setFocus();
 }
 
 void QmitkViewNavigatorWidget::UpdateTreeList(berry::IWorkbenchPart* workbenchPart)
 {
   berry::IWorkbenchPage::Pointer page = m_Window->GetActivePage();
   if (page.IsNull())
   {
     return;
   }
 
   m_ActivePerspective = page->GetPerspective();
   QList<berry::IViewPart::Pointer> viewParts = page->GetViews();
 
   // iterate over all tree items
   for (const auto& item : m_TreeModel->findItems("*", Qt::MatchWildcard | Qt::MatchRecursive))
   {
     QFont font = qApp->font();
     // check if the item is a view item and if it is equal to any opened view
     QmitkViewItem* viewItem = dynamic_cast<QmitkViewItem *>(item);
     if (nullptr != viewItem)
     {
       if (nullptr != workbenchPart && workbenchPart->GetPartName() == viewItem->m_ItemDescriptor->GetLabel())
       {
         font.setBold(true);
       }
       else
       {
         for (const auto& viewPart : viewParts)
         {
           if (viewPart->GetPartName() == viewItem->m_ItemDescriptor->GetLabel())
           {
             font.setBold(true);
             break;
           }
         }
       }
 
       viewItem->setFont(font);
     }
     else
     {
       // check if the item is a perspective item and if it is equal to the current perspective
       QmitkPerspectiveItem* perspectiveItem = dynamic_cast<QmitkPerspectiveItem*>(item);
       if (nullptr != perspectiveItem)
       {
         if (m_ActivePerspective.IsNotNull() && m_ActivePerspective->GetId() == perspectiveItem->m_ItemDescriptor->GetId())
         {
           font.setBold(true);
         }
 
         perspectiveItem->setFont(font);
       }
     }
   }
 }
 
 bool QmitkViewNavigatorWidget::FillTreeList()
 {
     // initialize tree model
     m_TreeModel->clear();
 
     // add all available views
     this->AddViewsToTree();
 
     // add all available perspectives
     this->AddPerspectivesToTree();
 
     m_Controls.m_PluginTreeView->expandAll();
 
     return true;
 }
 
 void QmitkViewNavigatorWidget::FilterChanged()
 {
     QString filterString = m_Controls.lineEdit->text();
     m_Controls.m_PluginTreeView->expandAll();
 
     QString strPattern = "^*" + filterString;
     QRegularExpression regExp(strPattern, QRegularExpression::CaseInsensitiveOption);
 
     m_FilterProxyModel->setFilterRegularExpression(regExp);
 }
 
 void QmitkViewNavigatorWidget::ItemClicked(const QModelIndex &index)
 {
     QStandardItem* item = m_TreeModel->itemFromIndex(m_FilterProxyModel->mapToSource(index));
 
     QmitkPerspectiveItem* perspectiveItem = dynamic_cast<QmitkPerspectiveItem*>(item);
     if (nullptr != perspectiveItem)
     {
         try
         {
             berry::PlatformUI::GetWorkbench()->ShowPerspective(
               perspectiveItem->m_ItemDescriptor->GetId(), berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow());
         }
         catch (...)
         {
             QMessageBox::critical(nullptr, "Opening Perspective Failed",
                                   QString("The requested perspective could not be opened.\nSee the log for details."));
         }
 
         return;
     }
 
     QmitkViewItem* viewItem = dynamic_cast<QmitkViewItem*>(item);
     if (nullptr != viewItem)
     {
         berry::IWorkbenchPage::Pointer page =
           berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
 
         if (page.IsNotNull())
         {
             try
             {
                 page->ShowView(viewItem->m_ItemDescriptor->GetId());
             }
             catch (const berry::PartInitException& e)
             {
                 BERRY_ERROR << "Error: " << e.what() << std::endl;
             }
         }
     }
 }
 
 void QmitkViewNavigatorWidget::SaveCurrentPerspectiveAs()
 {
   berry::IWorkbenchPage::Pointer page = m_Window->GetActivePage();
   berry::IPerspectiveDescriptor::Pointer currentPerspective = page->GetPerspective();
 
   bool ok = false;
   QString perspectiveLabel = QInputDialog::getText(this, "Save perspective as ...",
                                 "New perspective name:", QLineEdit::Normal,
                                 "", &ok);
 
   if (!ok)
   {
     return;
   }
 
   if (perspectiveLabel.isEmpty())
   {
     QMessageBox::information(this, "Save perspective as ...", "Please select a valid perspective name.");
     return;
   }
 
   berry::IPerspectiveRegistry* perspectiveRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
   berry::IPerspectiveDescriptor::Pointer newPerspective = perspectiveRegistry->CreatePerspective(perspectiveLabel, currentPerspective);
 
   if (nullptr == newPerspective)
   {
     QMessageBox::information(this, "Save perspective as ...", "The selected perspective name is already in use.");
     return;
   }
 
   page->SavePerspectiveAs(newPerspective);
 
   this->FillTreeList();
   this->UpdateTreeList();
 }
 
 void QmitkViewNavigatorWidget::ResetCurrentPerspective()
 {
     if (QMessageBox::Yes == QMessageBox(QMessageBox::Question, "Please confirm",
                                         "Do you really want to reset the current perspective?",
                                         QMessageBox::Yes | QMessageBox::No).exec())
     {
         berry::IWorkbenchPage::Pointer page = m_Window->GetActivePage();
         page->ResetPerspective();
     }
 }
 
 void QmitkViewNavigatorWidget::ClosePerspective()
 {
     if (QMessageBox::Yes == QMessageBox(QMessageBox::Question, "Please confirm",
                                         "Do you really want to close the current perspective?",
                                         QMessageBox::Yes | QMessageBox::No).exec())
     {
         berry::IWorkbenchPage::Pointer page = m_Window->GetActivePage();
         page->ClosePerspective(page->GetPerspective(), true, true);
     }
 }
 
 void QmitkViewNavigatorWidget::CloseAllPerspectives()
 {
     if (QMessageBox::Yes == QMessageBox(QMessageBox::Question, "Please confirm",
                                         "Do you really want to close all perspectives?",
                                         QMessageBox::Yes | QMessageBox::No).exec())
     {
         berry::IWorkbenchPage::Pointer page = m_Window->GetActivePage();
         page->CloseAllPerspectives(true, true);
     }
 }
 
 void QmitkViewNavigatorWidget::ExpandAll()
 {
     m_Controls.m_PluginTreeView->expandAll();
 }
 
 void QmitkViewNavigatorWidget::CollapseAll()
 {
     m_Controls.m_PluginTreeView->collapseAll();
 }
 
 void QmitkViewNavigatorWidget::CustomMenuRequested(QPoint pos)
 {
     QModelIndex index = m_Controls.m_PluginTreeView->indexAt(pos);
     QStandardItem* item = m_TreeModel->itemFromIndex(m_FilterProxyModel->mapToSource(index));
 
     if (nullptr == m_ContextMenu)
         return;
 
     m_ContextMenu->clear();
 
     QmitkPerspectiveItem* perspectiveItem = dynamic_cast<QmitkPerspectiveItem*>(item);
     if (nullptr != perspectiveItem)
     {
         berry::IPerspectiveDescriptor::Pointer perspectiveDescriptor = perspectiveItem->m_ItemDescriptor;
         if (this->m_ActivePerspective.IsNotNull() && this->m_ActivePerspective == perspectiveDescriptor)
         {
           QAction* saveAsAction = new QAction("Save perspective as ...", this);
           m_ContextMenu->addAction(saveAsAction);
           connect(saveAsAction, SIGNAL(triggered()), SLOT(SaveCurrentPerspectiveAs()));
           m_ContextMenu->addSeparator();
         }
     }
 
     QAction* resetAction = new QAction("Reset current perspective", this);
     m_ContextMenu->addAction(resetAction);
     connect(resetAction, SIGNAL(triggered()), SLOT(ResetCurrentPerspective()));
 
     QAction* closeAction = new QAction("Close perspective", this);
     m_ContextMenu->addAction(closeAction);
     connect(closeAction, SIGNAL(triggered()), SLOT(ClosePerspective()));
 
     QAction* closeAllAction = new QAction("Close all perspectives", this);
     m_ContextMenu->addAction(closeAllAction);
     connect(closeAllAction, SIGNAL(triggered()), SLOT(CloseAllPerspectives()));
 
     m_ContextMenu->addSeparator();
 
     QAction* expandAction = new QAction("Expand tree", this);
     m_ContextMenu->addAction(expandAction);
     connect(expandAction, SIGNAL(triggered()), SLOT(ExpandAll()));
 
     QAction* collapseAction = new QAction("Collapse tree", this);
     m_ContextMenu->addAction(collapseAction);
     connect(collapseAction, SIGNAL(triggered()), SLOT(CollapseAll()));
 
     m_ContextMenu->popup(m_Controls.m_PluginTreeView->viewport()->mapToGlobal(pos));
 }
 
 void QmitkViewNavigatorWidget::CreateQtPartControl(QWidget* parent)
 {
   // active workbench window available?
   if (m_Window.IsNull())
   {
     return;
   }
 
   m_Controls.setupUi(parent);
   connect(m_Controls.m_PluginTreeView, SIGNAL(customContextMenuRequested(QPoint)), SLOT(CustomMenuRequested(QPoint)));
   connect(m_Controls.m_PluginTreeView, SIGNAL(doubleClicked(const QModelIndex&)), SLOT(ItemClicked(const QModelIndex&)));
   connect(m_Controls.lineEdit, SIGNAL(textChanged(QString)), SLOT(FilterChanged()));
 
   m_ContextMenu = new QMenu(m_Controls.m_PluginTreeView);
   m_Controls.m_PluginTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   // Create a new TreeModel for the data
   m_TreeModel = new QStandardItemModel();
   m_FilterProxyModel = new ClassFilterProxyModel(this);
   m_FilterProxyModel->setSourceModel(m_TreeModel);
   m_Controls.m_PluginTreeView->setModel(m_FilterProxyModel);
 
   m_PerspectiveListener.reset(new ViewNavigatorPerspectiveListener(this));
   m_Window->AddPerspectiveListener(m_PerspectiveListener.data());
 
   m_ViewPartListener.reset(new ViewNavigatorViewListener(this));
   m_Window->GetPartService()->AddPartListener(m_ViewPartListener.data());
 }
 
 void QmitkViewNavigatorWidget::AddPerspectivesToTree()
 {
   berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
   QList<berry::IPerspectiveDescriptor::Pointer> perspectiveDescriptors(perspRegistry->GetPerspectives());
-  qSort(perspectiveDescriptors.begin(), perspectiveDescriptors.end(), comparePerspectives);
+  std::sort(perspectiveDescriptors.begin(), perspectiveDescriptors.end(), comparePerspectives);
 
   QStandardItem* perspectiveRootItem = new QStandardItem("Perspectives");
   perspectiveRootItem->setFont(getLargeFont());
   perspectiveRootItem->setEditable(false);
   QStandardItem* treeRootItem = m_TreeModel->invisibleRootItem();
   treeRootItem->appendRow(perspectiveRootItem);
 
   this->AddItemsToTree<QList<berry::IPerspectiveDescriptor::Pointer>, QmitkPerspectiveItem>(
     perspectiveDescriptors, perspectiveRootItem);
 }
 
 void QmitkViewNavigatorWidget::AddViewsToTree()
 {
   berry::IViewRegistry* viewRegistry = berry::PlatformUI::GetWorkbench()->GetViewRegistry();
   QList<berry::IViewDescriptor::Pointer> viewDescriptors(viewRegistry->GetViews());
-  qSort(viewDescriptors.begin(), viewDescriptors.end(), compareViews);
+  std::sort(viewDescriptors.begin(), viewDescriptors.end(), compareViews);
 
   auto largeFont = getLargeFont();
 
   QStandardItem* viewRootItem = new QStandardItem("Views");
   viewRootItem->setFont(largeFont);
   viewRootItem->setEditable(false);
   QStandardItem* treeRootItem = m_TreeModel->invisibleRootItem();
   treeRootItem->appendRow(viewRootItem);
 
   QStandardItem* miscellaneousCategoryItem = new QStandardItem("Miscellaneous");
   miscellaneousCategoryItem->setFont(largeFont);
   miscellaneousCategoryItem->setEditable(false);
 
   QStringList viewExcludeList;
   // internal view used for the intro screen, will crash when opened directly, see T22352
   viewExcludeList.append(QString("org.blueberry.ui.internal.introview"));
   viewExcludeList.append(QString("org.mitk.views.controlvisualizationpropertiesview"));
   viewExcludeList.append(QString("org.mitk.views.modules"));
   viewExcludeList.append(QString("org.mitk.views.viewnavigator"));
 
   this->AddItemsToTree<QList<berry::IViewDescriptor::Pointer>, QmitkViewItem>(
     viewDescriptors, viewRootItem, miscellaneousCategoryItem, viewExcludeList);
 }
 
 template<typename D, typename I>
 void QmitkViewNavigatorWidget::AddItemsToTree(D itemDescriptors, QStandardItem* rootItem,
   QStandardItem* miscellaneousItem, const QStringList& itemExcludeList)
 {
   KeywordRegistry keywordRegistry;
   std::vector<QStandardItem*> categoryItems;
 
   for (const auto& itemDescriptor : itemDescriptors)
   {
     bool excludeView = itemExcludeList.contains(itemDescriptor->GetId());
     if (excludeView)
     {
       continue;
     }
 
     QIcon icon = itemDescriptor->GetImageDescriptor();
     I* item = new I(icon, itemDescriptor->GetLabel());
     item->m_ItemDescriptor = itemDescriptor;
     item->m_Description = itemDescriptor->GetDescription();
     item->setToolTip(itemDescriptor->GetDescription());
 
     QStringList keylist = itemDescriptor->GetKeywordReferences();
     item->m_Tags = keywordRegistry.GetKeywords(keylist);
     item->setEditable(false);
 
     QStringList categoryPath = itemDescriptor->GetCategoryPath();
     if (categoryPath.empty())
     {
       // If a root item for general / non-categorized item views is given, use it.
       // Otherwise put the non-categorized item views into the top root item.
       if (nullptr != miscellaneousItem)
       {
         miscellaneousItem->appendRow(item);
       }
       else
       {
         rootItem->appendRow(item);
       }
     }
     else
     {
       QStandardItem* categoryItem = nullptr;
       for (const auto& currentCategoryItem : categoryItems)
       {
         if (currentCategoryItem->text() == categoryPath.front())
         {
           categoryItem = currentCategoryItem;
           break;
         }
       }
 
       if (nullptr == categoryItem)
       {
         categoryItem = new QStandardItem(QIcon(), categoryPath.front());
         categoryItems.push_back(categoryItem);
       }
 
       auto font = getLargeFont();
 
       categoryItem->setFont(font);
       categoryItem->setEditable(false);
       categoryItem->appendRow(item);
     }
   }
 
   std::sort(categoryItems.begin(), categoryItems.end(), compareQStandardItems);
   for (const auto& categoryItem : categoryItems)
   {
     rootItem->appendRow(categoryItem);
   }
 
   if (nullptr != miscellaneousItem && miscellaneousItem->hasChildren())
   {
     rootItem->appendRow(miscellaneousItem);
   }
 }