diff --git a/Modules/AppUtil/src/mitkProvisioningInfo.cpp b/Modules/AppUtil/src/mitkProvisioningInfo.cpp
index 7ccdb6c8ca..7b5990b3e7 100644
--- a/Modules/AppUtil/src/mitkProvisioningInfo.cpp
+++ b/Modules/AppUtil/src/mitkProvisioningInfo.cpp
@@ -1,206 +1,207 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkProvisioningInfo.h"
 
 #include <mitkLog.h>
 
 #include <QCoreApplication>
 #include <QFile>
 #include <QFileInfo>
+#include <QRegularExpression>
 #include <QTextStream>
 
 namespace mitk
 {
 #ifdef CMAKE_INTDIR
   const QString ProvisioningInfo::intermediateOutDir = QString(CMAKE_INTDIR);
 #else
   const QString ProvisioningInfo::intermediateOutDir = QString();
 #endif
 
   ProvisioningInfo::ProvisioningInfo(const QString &file) { this->readProvisioningFile(file); }
   QStringList ProvisioningInfo::getPluginDirs() const { return pluginDirs.toList(); }
   QList<QUrl> ProvisioningInfo::getPluginsToInstall() const { return pluginsToInstall; }
   QList<QUrl> ProvisioningInfo::getPluginsToStart() const { return pluginsToStart; }
   void ProvisioningInfo::readProvisioningFile(const QString &filePath)
   {
     QFile file(filePath);
     file.open(QFile::ReadOnly);
     QTextStream fileStream(&file);
-    QRegExp sep("\\s+");
+    QRegularExpression sep("\\s+");
     QString line;
     int count = 1;
     do
     {
       line = fileStream.readLine().trimmed();
       if (!line.isEmpty() && !line.startsWith('#'))
       {
         QString keyword = line.section(sep, 0, 0);
         QString value = line.mid(keyword.size()).trimmed();
         value = substituteKeywords(value);
 
         if (keyword.isEmpty())
         {
           MITK_WARN << "Keyword missing in line " << count << " of provisioning file " << filePath.toStdString();
           continue;
         }
 
         Keyword key = UNKNOWN;
         if (keyword.compare("READ", Qt::CaseInsensitive) == 0)
         {
           key = READ;
         }
         else if (keyword.compare("INSTALL", Qt::CaseInsensitive) == 0)
         {
           key = INSTALL;
         }
         else if (keyword.compare("START", Qt::CaseInsensitive) == 0)
         {
           key = START;
         }
         else if (keyword.compare("STOP", Qt::CaseInsensitive) == 0)
         {
           key = STOP;
         }
 
         if (key == UNKNOWN)
         {
           MITK_WARN << "Keyword " << keyword.toStdString() << " in line " << count << " of provisioning file "
                     << filePath.toStdString() << " unknown";
           continue;
         }
 
         if (value.isEmpty())
         {
           MITK_WARN << "Value after keyword " << keyword.toStdString() << " missing in line " << count
                     << " of provisioning file " << filePath.toStdString();
           continue;
         }
 
         switch (key)
         {
           case READ:
           {
             QUrl readFileUrl(value);
             if (!readFileUrl.isValid())
             {
               MITK_WARN << "The READ URL " << value.toStdString()
                         << "is invalid: " << readFileUrl.errorString().toStdString();
               break;
             }
             this->readProvisioningFile(readFileUrl.toLocalFile());
             break;
           }
           case INSTALL:
           {
             this->addPluginToInstall(value);
             break;
           }
           case START:
           {
             this->addPluginToStart(value);
             break;
           }
           case STOP:
           {
             break;
           }
           case UNKNOWN:
           {
             break; // error handled above
           }
         }
       }
       ++count;
     } while (!line.isNull());
   }
 
   QUrl ProvisioningInfo::addPluginToInstall(const QString &file)
   {
     QUrl pluginUrl(file);
     if (!pluginUrl.isValid())
     {
       MITK_WARN << "The plugin URL " << file.toStdString() << " is invalid:" << pluginUrl.errorString().toStdString();
       return QUrl();
     }
 
     QFileInfo fileInfo(pluginUrl.toLocalFile());
     if (!fileInfo.exists())
     {
       QString fileName = fileInfo.fileName();
       QString filePath = fileInfo.absolutePath();
       if (!intermediateOutDir.isEmpty())
       {
         // search in the intermediate output dir
         QString filePath2 = filePath + "/" + intermediateOutDir;
         fileInfo = QFileInfo(filePath2 + "/" + fileName);
         if (!fileInfo.exists())
         {
           MITK_WARN << "The plugin " << fileName.toStdString() << " was not found in " << filePath.toStdString()
                     << " or " << filePath2.toStdString();
           return QUrl();
         }
         pluginUrl = QUrl::fromLocalFile(fileInfo.canonicalFilePath());
         pluginDirs.insert(fileInfo.canonicalPath());
       }
       else
       {
         MITK_WARN << "The plugin " << fileName.toStdString() << " was not found in " << filePath.toStdString();
         return QUrl();
       }
     }
     else
     {
       pluginDirs.insert(fileInfo.canonicalPath());
     }
 
     pluginsToInstall.append(pluginUrl);
     return pluginUrl;
   }
 
   void ProvisioningInfo::addPluginToStart(const QString &file)
   {
     QUrl pluginUrl = this->addPluginToInstall(file);
     if (!pluginUrl.isEmpty())
     {
       pluginsToStart.append(pluginUrl);
     }
   }
 
   QString ProvisioningInfo::substituteKeywords(const QString &value) const
   {
     QString appPath = QCoreApplication::applicationDirPath();
     if (appPath.endsWith('/'))
     {
       appPath.chop(1);
     }
 
 #ifdef CMAKE_INTDIR
     // Strip the intermediate dir from the application path
     QString intDir(CMAKE_INTDIR);
     if (appPath.endsWith(intDir))
     {
       appPath.chop(intDir.size() + 1);
     }
 #endif
 
 #ifdef _WIN32
     if (value.contains("@EXECUTABLE_DIR") && value.contains("blueberry_osgi"))
     {
       // special case for org_blueberry_osgi in install trees for Windows
       return QString(value).replace("@EXECUTABLE_DIR", appPath, Qt::CaseInsensitive).replace("plugins/", "");
     }
 #endif
 
     return QString(value).replace("@EXECUTABLE_DIR", appPath, Qt::CaseInsensitive);
   }
 }
diff --git a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp
index 11cdc1a0c0..96431b93c8 100644
--- a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp
+++ b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp
@@ -1,436 +1,436 @@
 /*============================================================================
 
 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 "QmitkIGTLDeviceSetupConnectionWidget.h"
 
 //mitk headers
 #include <mitkSurface.h>
 #include <mitkIGTLDeviceSource.h>
 #include <mitkDataStorage.h>
 #include <mitkIGTLMessageFactory.h>
 
 //qt headers
 #include <qfiledialog.h>
 #include <qinputdialog.h>
 #include <qmessagebox.h>
 #include <qscrollbar.h>
 
 //igtl
 #include <igtlStringMessage.h>
 #include <igtlBindMessage.h>
 #include <igtlQuaternionTrackingDataMessage.h>
 #include <igtlTrackingDataMessage.h>
 
 //poco headers
 #include <Poco/Path.h>
 
-#include <QRegExpValidator>
+#include <QRegularExpressionValidator>
 
 const std::string QmitkIGTLDeviceSetupConnectionWidget::VIEW_ID =
 "org.mitk.views.igtldevicesetupconnectionwidget";
 
 QmitkIGTLDeviceSetupConnectionWidget::QmitkIGTLDeviceSetupConnectionWidget(
   QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f), m_IsClient(false)
 {
   m_Controls = nullptr;
   this->m_IGTLDevice = nullptr;
   CreateQtPartControl(this);
   m_NumSentFramesSinceLastUpdate = 0;
   m_NumReceivedFramesSinceLastUpdate = 0;
 }
 
 QmitkIGTLDeviceSetupConnectionWidget::~QmitkIGTLDeviceSetupConnectionWidget()
 {
   this->RemoveObserver();
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::RemoveObserver()
 {
   if (this->m_IGTLDevice.IsNotNull())
   {
     this->m_IGTLDevice->RemoveObserver(m_MessageReceivedObserverTag);
     this->m_IGTLDevice->RemoveObserver(m_MessageSentObserverTag);
     this->m_IGTLDevice->RemoveObserver(m_CommandReceivedObserverTag);
     this->m_IGTLDevice->RemoveObserver(m_LostConnectionObserverTag);
     this->m_IGTLDevice->RemoveObserver(m_NewConnectionObserverTag);
     this->m_IGTLDevice->RemoveObserver(m_StateModifiedObserverTag);
   }
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkIGTLDeviceSetupConnectionWidgetControls;
     // setup GUI widgets
     m_Controls->setupUi(parent);
   }
 
   // set the validator for the ip edit box (values must be between 0 and 255 and
   // there are four of them, seperated with a point
-  QRegExpValidator *v = new QRegExpValidator(this);
-  QRegExp rx("((1{0,1}[0-9]{0,2}|2[0-4]{1,1}[0-9]{1,1}|25[0-5]{1,1})\\.){3,3}(1{0,1}[0-9]{0,2}|2[0-4]{1,1}[0-9]{1,1}|25[0-5]{1,1})");
-  v->setRegExp(rx);
+  auto v = new QRegularExpressionValidator(this);
+  QRegularExpression rx("((1{0,1}[0-9]{0,2}|2[0-4]{1,1}[0-9]{1,1}|25[0-5]{1,1})\\.){3,3}(1{0,1}[0-9]{0,2}|2[0-4]{1,1}[0-9]{1,1}|25[0-5]{1,1})");
+  v->setRegularExpression(rx);
   m_Controls->editIP->setValidator(v);
   // set the validator for the port edit box (values must be between 1 and 65535)
   m_Controls->editPort->setValidator(new QIntValidator(1, 65535, this));
 
   m_FPSCalculationTimer.start(1000);
 
   //connect slots with signals
   CreateConnections();
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::CreateConnections()
 {
   if (m_Controls)
   {
     // connect the widget items with the methods
     connect(m_Controls->butConnect, SIGNAL(clicked()),
       this, SLOT(OnConnect()));
     connect(m_Controls->editPort, SIGNAL(editingFinished()),
       this, SLOT(OnPortChanged()));
     connect(m_Controls->editIP, SIGNAL(editingFinished()),
       this, SLOT(OnHostnameChanged()));
     connect(m_Controls->bufferInMsgCheckBox, SIGNAL(stateChanged(int)),
       this, SLOT(OnBufferIncomingMessages(int)));
     connect(m_Controls->bufferOutMsgCheckBox, SIGNAL(stateChanged(int)),
       this, SLOT(OnBufferOutgoingMessages(int)));
     connect(&m_FPSCalculationTimer, SIGNAL(timeout()),
       this, SLOT(OnUpdateFPSLabel()));
     connect(m_Controls->logMessageDetailsCheckBox, SIGNAL(clicked()),
       this, SLOT(OnLogMessageDetailsCheckBoxClicked()));
   }
   //this is used for thread seperation, otherwise the worker thread would change the ui elements
   //which would cause an exception
   connect(this, SIGNAL(AdaptGUIToStateSignal()), this, SLOT(AdaptGUIToState()));
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnDeviceStateChanged()
 {
   emit AdaptGUIToStateSignal();
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::AdaptGUIToState()
 {
   //check the validity of the device
   if (this->m_IGTLDevice.IsNull())
   {
     return;
   }
 
   //check the state of the device
   mitk::IGTLDevice::IGTLDeviceState state = this->m_IGTLDevice->GetState();
 
   switch (state) {
   case mitk::IGTLDevice::Setup:
     if (!m_IsClient)
     {
       m_Controls->butConnect->setText("Go Online");
       this->m_Controls->editIP->setEnabled(false);
     }
     else
     {
       m_Controls->butConnect->setText("Connect");
       this->m_Controls->editIP->setEnabled(true);
     }
     this->m_Controls->editPort->setEnabled(true);
     this->m_Controls->logMessageStatusCheckBox->setChecked(false);
     this->m_Controls->logMessageDetailsCheckBox->setChecked(false);
     this->m_Controls->logMessageStatusCheckBox->setEnabled(false);
     this->m_Controls->logMessageDetailsCheckBox->setEnabled(false);
     this->m_Controls->bufferInMsgCheckBox->setEnabled(false);
     this->m_Controls->bufferOutMsgCheckBox->setEnabled(false);
     this->m_Controls->butConnect->setEnabled(true);
     this->m_Controls->fpsInLabel->setEnabled(false);
     this->m_Controls->fpsOutLabel->setEnabled(false);
     this->m_Controls->fpsInDescrLabel->setEnabled(false);
     this->m_Controls->fpsOutDescrLabel->setEnabled(false);
 
     if( this->m_IGTLDevice.IsNotNull() )
     {
       this->m_IGTLDevice->SetLogMessages(false);
     }
 
     break;
   case mitk::IGTLDevice::Ready:
     if (m_IsClient)
     {
       this->m_Controls->butConnect->setText("Disconnect");
     }
     else
     {
       this->m_Controls->butConnect->setText("Go Offline");
     }
     this->m_Controls->editIP->setEnabled(false);
     this->m_Controls->editPort->setEnabled(false);
     this->m_Controls->logMessageStatusCheckBox->setEnabled(true);
     this->m_Controls->logMessageDetailsCheckBox->setEnabled(true);
     this->m_Controls->bufferInMsgCheckBox->setEnabled(true);
     this->m_Controls->bufferOutMsgCheckBox->setEnabled(true);
     this->m_Controls->butConnect->setEnabled(true);
     this->m_Controls->fpsInLabel->setEnabled(true);
     this->m_Controls->fpsOutLabel->setEnabled(true);
     this->m_Controls->fpsInDescrLabel->setEnabled(true);
     this->m_Controls->fpsOutDescrLabel->setEnabled(true);
     break;
   case mitk::IGTLDevice::Running:
     if (m_IsClient)
     {
       this->m_Controls->butConnect->setText("Disconnect");
     }
     else
     {
       this->m_Controls->butConnect->setText("Go Offline");
     }
     this->m_Controls->editIP->setEnabled(false);
     this->m_Controls->editPort->setEnabled(false);
     this->m_Controls->logMessageStatusCheckBox->setEnabled(true);
     this->m_Controls->logMessageDetailsCheckBox->setEnabled(true);
     this->m_Controls->bufferInMsgCheckBox->setEnabled(true);
     this->m_Controls->bufferOutMsgCheckBox->setEnabled(true);
     this->m_Controls->butConnect->setEnabled(true);
     this->m_Controls->fpsInLabel->setEnabled(true);
     this->m_Controls->fpsOutLabel->setEnabled(true);
     this->m_Controls->fpsInDescrLabel->setEnabled(true);
     this->m_Controls->fpsOutDescrLabel->setEnabled(true);
     break;
   default:
     mitkThrow() << "Invalid Device State";
     break;
   }
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::Initialize(
   mitk::IGTLDevice::Pointer device)
 {
   //reset the GUI
   DisableSourceControls();
   //reset the observers
   this->RemoveObserver();
 
   if (device.IsNotNull())
   {
     this->m_IGTLDevice = device;
 
     //check if the device is a server or a client
     if (dynamic_cast<mitk::IGTLClient*>(
       this->m_IGTLDevice.GetPointer()) == nullptr)
     {
       m_IsClient = false;
     }
     else
     {
       m_IsClient = true;
     }
 
     this->AdaptGUIToState();
 
     typedef itk::SimpleMemberCommand< QmitkIGTLDeviceSetupConnectionWidget > CurCommandType;
     CurCommandType::Pointer messageSentCommand = CurCommandType::New();
     messageSentCommand->SetCallbackFunction(
       this, &QmitkIGTLDeviceSetupConnectionWidget::OnMessageSent);
     this->m_MessageSentObserverTag = this->m_IGTLDevice->AddObserver(
       mitk::MessageSentEvent(), messageSentCommand);
 
     CurCommandType::Pointer messageReceivedCommand = CurCommandType::New();
     messageReceivedCommand->SetCallbackFunction(
       this, &QmitkIGTLDeviceSetupConnectionWidget::OnMessageReceived);
     this->m_MessageReceivedObserverTag = this->m_IGTLDevice->AddObserver(
       mitk::MessageReceivedEvent(), messageReceivedCommand);
 
     CurCommandType::Pointer commandReceivedCommand = CurCommandType::New();
     commandReceivedCommand->SetCallbackFunction(
       this, &QmitkIGTLDeviceSetupConnectionWidget::OnCommandReceived);
     this->m_CommandReceivedObserverTag = this->m_IGTLDevice->AddObserver(
       mitk::CommandReceivedEvent(), commandReceivedCommand);
 
     CurCommandType::Pointer connectionLostCommand = CurCommandType::New();
     connectionLostCommand->SetCallbackFunction(
       this, &QmitkIGTLDeviceSetupConnectionWidget::OnLostConnection);
     this->m_LostConnectionObserverTag = this->m_IGTLDevice->AddObserver(
       mitk::LostConnectionEvent(), connectionLostCommand);
 
     CurCommandType::Pointer newConnectionCommand = CurCommandType::New();
     newConnectionCommand->SetCallbackFunction(
       this, &QmitkIGTLDeviceSetupConnectionWidget::OnNewConnection);
     this->m_NewConnectionObserverTag = this->m_IGTLDevice->AddObserver(
       mitk::NewClientConnectionEvent(), newConnectionCommand);
 
     CurCommandType::Pointer stateModifiedCommand = CurCommandType::New();
     stateModifiedCommand->SetCallbackFunction(
       this, &QmitkIGTLDeviceSetupConnectionWidget::OnDeviceStateChanged);
     this->m_StateModifiedObserverTag = this->m_IGTLDevice->AddObserver(
       itk::ModifiedEvent(), stateModifiedCommand);
 
     OnBufferIncomingMessages(m_Controls->bufferInMsgCheckBox->isChecked());
     OnBufferOutgoingMessages(m_Controls->bufferOutMsgCheckBox->isChecked());
   }
   else
   {
     m_IGTLDevice = nullptr;
   }
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::DisableSourceControls()
 {
   m_Controls->editIP->setEnabled(false);
   m_Controls->editPort->setEnabled(false);
   m_Controls->butConnect->setEnabled(false);
   m_Controls->bufferInMsgCheckBox->setEnabled(false);
   m_Controls->bufferOutMsgCheckBox->setEnabled(false);
   this->m_Controls->logMessageStatusCheckBox->setChecked(false);
   this->m_Controls->logMessageDetailsCheckBox->setChecked(false);
   this->m_Controls->logMessageStatusCheckBox->setEnabled(false);
   this->m_Controls->logMessageDetailsCheckBox->setEnabled(false);
 
   if( this->m_IGTLDevice.IsNotNull() )
   {
     this->m_IGTLDevice->SetLogMessages(false);
   }
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnConnect()
 {
   if (m_IGTLDevice->GetState() == mitk::IGTLDevice::Setup)
   {
     QString port = m_Controls->editPort->text();
     m_IGTLDevice->SetPortNumber(port.toInt());
     std::string hostname = m_Controls->editIP->text().toStdString();
     m_IGTLDevice->SetHostname(hostname);
     //connect with the other OpenIGTLink device => changes the state from Setup
     //to Ready
     if (m_IGTLDevice->OpenConnection())
     {
       //starts the communication thread => changes the state from Ready to
       //Running
       if (m_IGTLDevice->StartCommunication())
       {
         if (this->m_IsClient)
         {
           MITK_INFO("IGTLDeviceSourceManagementWidget")
             << "Successfully connected to " << hostname
             << " on port " << port.toStdString();
         }
       }
       else
       {
         MITK_ERROR("QmitkIGTLDeviceSetupConnectionWidget") <<
           "Could not start a communication with the"
           "server because the client is in the wrong state";
       }
     }
     else
     {
       MITK_ERROR("QmitkIGTLDeviceSetupConnectionWidget") <<
         "Could not connect to the server. "
         "Please check the hostname and port.";
     }
   }
   else if (m_IGTLDevice->GetState() == mitk::IGTLDevice::Ready || m_IGTLDevice->GetState() == mitk::IGTLDevice::Running)
   {
     m_IGTLDevice->CloseConnection();
     MITK_INFO("QmitkIGTLDeviceSetupConnectionWidget") << "Closed connection";
   }
   else
   {
     mitkThrow() << "Invalid state of IGTLDevice";
   }
   this->AdaptGUIToState();
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnPortChanged()
 {
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnHostnameChanged()
 {
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnLostConnection()
 {
   emit AdaptGUIToStateSignal();
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnNewConnection()
 {
   emit AdaptGUIToStateSignal();
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnMessageReceived()
 {
   if( this->m_Controls->logMessageStatusCheckBox->isChecked() )
   {
     MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Received a message.";
   }
   m_NumReceivedFramesSinceLastUpdate++;
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnMessageSent()
 {
   if( this->m_Controls->logMessageStatusCheckBox->isChecked() )
   {
     MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Sent a message.";
   }
   m_NumSentFramesSinceLastUpdate++;
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnCommandReceived()
 {
   if( this->m_Controls->logMessageStatusCheckBox->isChecked() )
   {
     MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Received a command.";
   }
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnBufferIncomingMessages(int state)
 {
   if (this->m_IGTLDevice.IsNotNull())
   {
     this->m_IGTLDevice->EnableNoBufferingMode(
       this->m_IGTLDevice->GetMessageQueue(), (bool)state);
   }
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnBufferOutgoingMessages(int state)
 {
   if (this->m_IGTLDevice.IsNotNull())
   {
     this->m_IGTLDevice->EnableNoBufferingMode(
       this->m_IGTLDevice->GetMessageQueue(), (bool)state);
   }
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnUpdateFPSLabel()
 {
   double fpsIn = m_NumReceivedFramesSinceLastUpdate / 1.0;
   double fpsOut = m_NumSentFramesSinceLastUpdate / 1.0;
   this->m_Controls->fpsInLabel->setText(QString::number(fpsIn));
   this->m_Controls->fpsOutLabel->setText(QString::number(fpsOut));
   m_NumReceivedFramesSinceLastUpdate = 0;
   m_NumSentFramesSinceLastUpdate = 0;
 }
 
 void QmitkIGTLDeviceSetupConnectionWidget::OnLogMessageDetailsCheckBoxClicked()
 {
   if( this->m_IGTLDevice.IsNull() )
   {
     MITK_WARN << "Logging information not passed down to Message Provider.";
     return;
   }
   else
   {
     this->m_IGTLDevice->SetLogMessages( this->m_Controls->logMessageDetailsCheckBox->isChecked() );
   }
 }
diff --git a/Modules/XNAT/src/QmitkXnatTreeModel.cpp b/Modules/XNAT/src/QmitkXnatTreeModel.cpp
index deb1309bc4..65fe4a215d 100644
--- a/Modules/XNAT/src/QmitkXnatTreeModel.cpp
+++ b/Modules/XNAT/src/QmitkXnatTreeModel.cpp
@@ -1,310 +1,321 @@
 /*============================================================================
 
 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 "QmitkXnatTreeModel.h"
 #include <QmitkHttpStatusCodeHandler.h>
 
 #include <QmitkMimeTypes.h>
 
 #include <QIcon>
+#include <QRegularExpression>
 
 #include <ctkXnatDataModel.h>
 #include <ctkXnatExperiment.h>
 #include <ctkXnatFile.h>
 #include <ctkXnatProject.h>
 #include <ctkXnatResource.h>
 #include <ctkXnatResourceCatalogXmlParser.h>
 #include <ctkXnatResourceFolder.h>
 #include <ctkXnatScan.h>
 #include <ctkXnatScanFolder.h>
 #include <ctkXnatSubject.h>
 
 #include <iostream>
 
 QmitkXnatTreeModel::QmitkXnatTreeModel() : ctkXnatTreeModel()
 {
 }
 
 QModelIndexList QmitkXnatTreeModel::match(
   const QModelIndex &start, int role, const QVariant &value, int hits, Qt::MatchFlags flags) const
 {
   QModelIndexList result;
-  uint matchType = flags & 0x0F;
-  Qt::CaseSensitivity cs = flags & Qt::MatchCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive;
+  uint matchType = flags & Qt::MatchTypeMask;
+  Qt::CaseSensitivity cs = flags.testFlag(Qt::MatchCaseSensitive)
+    ? Qt::CaseSensitive
+    : Qt::CaseInsensitive;
   bool recurse = flags & Qt::MatchRecursive;
   bool wrap = flags & Qt::MatchWrap;
   bool allHits = (hits == -1);
   QString text; // only convert to a string if it is needed
   QModelIndex p = parent(start);
   int from = start.row();
   int to = rowCount(p);
 
   // iterates twice if wrapping
   for (int i = 0; (wrap && i < 2) || (!wrap && i < 1); ++i)
   {
     for (int r = from; (r < to) && (allHits || result.count() < hits); ++r)
     {
       QModelIndex idx = index(r, start.column(), p);
       if (!idx.isValid())
         continue;
       QVariant v = data(idx, role);
       // QVariant based matching
       if (matchType == Qt::MatchExactly)
       {
         if (value != v)
           result.append(idx);
       }
       else
       {                     // QString based matching
         if (text.isEmpty()) // lazy conversion
           text = value.toString();
         QString t = v.toString();
         switch (matchType)
         {
-          case Qt::MatchRegExp:
-            if (!QRegExp(text, cs).exactMatch(t))
+          case Qt::MatchRegularExpression:
+          {
+            QRegularExpression::PatternOptions options;
+            options.setFlag(QRegularExpression::CaseInsensitiveOption, !flags.testFlag(Qt::MatchCaseSensitive));
+            QRegularExpression regExp(QString("^%1$").arg(text), options);
+            if (!regExp.match(t).hasMatch())
               result.append(idx);
             break;
+          }
           case Qt::MatchWildcard:
-            if (!QRegExp(text, cs, QRegExp::Wildcard).exactMatch(t))
+          {
+            auto regExp = QRegularExpression::fromWildcard(text, cs);
+            if (!regExp.match(t).hasMatch())
               result.append(idx);
             break;
+          }
           case Qt::MatchStartsWith:
             if (!t.startsWith(text, cs))
               result.append(idx);
             break;
           case Qt::MatchEndsWith:
             if (!t.endsWith(text, cs))
               result.append(idx);
             break;
           case Qt::MatchFixedString:
             if (t.compare(text, cs) != 0)
               result.append(idx);
             break;
           case Qt::MatchContains:
           default:
             if (!t.contains(text, cs))
               result.append(idx);
         }
       }
       if (recurse && hasChildren(idx))
       { // search the hierarchy
         result += match(index(0, idx.column(), idx),
                         role,
                         (text.isEmpty() ? value : text),
                         (allHits ? -1 : hits - result.count()),
                         flags);
       }
     }
     // prepare for the next iteration
     from = 0;
     to = start.row();
   }
   return result;
 }
 
 void QmitkXnatTreeModel::fetchMore(const QModelIndex &index)
 {
   try
   {
     ctkXnatTreeModel::fetchMore(index);
   }
   catch (const ctkRuntimeException& e)
   {
     QmitkHttpStatusCodeHandler::HandleErrorMessage(e.what());
     emit Error(index);
   }
 }
 
 QVariant QmitkXnatTreeModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid())
   {
     return QVariant();
   }
 
   if (role == Qt::DecorationRole)
   {
     ctkXnatObject *xnatObject = this->xnatObject(index);
     QString path;
 
     if (dynamic_cast<ctkXnatDataModel *>(xnatObject))
     {
       path = ":/xnat-module/xnat-server.png";
     }
     else if (dynamic_cast<ctkXnatProject *>(xnatObject))
     {
       path = ":/xnat-module/xnat-project.png";
     }
     else if (dynamic_cast<ctkXnatSubject *>(xnatObject))
     {
       path = ":/xnat-module/xnat-subject.png";
     }
     else if (dynamic_cast<ctkXnatExperiment *>(xnatObject))
     {
       path = ":/xnat-module/xnat-experiment.png";
     }
     else if (dynamic_cast<ctkXnatResourceFolder *>(xnatObject))
     {
       path = ":/xnat-module/xnat-folder.png";
     }
     else if (dynamic_cast<ctkXnatResource *>(xnatObject))
     {
       path = ":/xnat-module/xnat-resource.png";
     }
     else if (dynamic_cast<ctkXnatScanFolder *>(xnatObject))
     {
       path = ":/xnat-module/xnat-folder.png";
     }
     else if (dynamic_cast<ctkXnatScan *>(xnatObject))
     {
       path = ":/xnat-module/xnat-scan.png";
     }
     else if (dynamic_cast<ctkXnatFile *>(xnatObject))
     {
       path = ":/xnat-module/xnat-file.png";
     }
     return QIcon(path);
   }
   return ctkXnatTreeModel::data(index, role);
 }
 
 bool QmitkXnatTreeModel::dropMimeData(
   const QMimeData *data, Qt::DropAction action, int /*row*/, int /*column*/, const QModelIndex &parent)
 {
   if (action == Qt::IgnoreAction)
     return true;
 
   // Return true if data can be handled
   bool returnVal(false);
 
   if (data->hasFormat(QmitkMimeTypes::DataNodePtrs))
   {
     returnVal = true;
     QList<mitk::DataNode *> droppedNodes = QmitkMimeTypes::ToDataNodePtrList(data);
     ctkXnatObject *parentXnatObj = this->xnatObject(parent);
     emit ResourceDropped(droppedNodes, parentXnatObj, parent);
   }
   return returnVal;
 }
 
 Qt::DropActions QmitkXnatTreeModel::supportedDropActions()
 {
   return Qt::CopyAction;
 }
 
 Qt::ItemFlags QmitkXnatTreeModel::flags(const QModelIndex &index) const
 {
   Qt::ItemFlags defaultFlags = ctkXnatTreeModel::flags(index);
 
   if (index.isValid())
   {
     bool droppingAllowed = dynamic_cast<ctkXnatSubject *>(this->xnatObject(index)) != nullptr;
     droppingAllowed |= dynamic_cast<ctkXnatExperiment *>(this->xnatObject(index)) != nullptr;
     droppingAllowed |= dynamic_cast<ctkXnatResource *>(this->xnatObject(index)) != nullptr;
     droppingAllowed |= dynamic_cast<ctkXnatResourceFolder *>(this->xnatObject(index)) != nullptr;
 
     // No dropping at project, session or data model level allowed
     if (droppingAllowed)
     {
       return Qt::ItemIsDropEnabled | defaultFlags;
     }
     else
     {
       return defaultFlags;
     }
   }
   else
     return defaultFlags;
 }
 
 ctkXnatObject *QmitkXnatTreeModel::InternalGetXnatObjectFromUrl(const QString &xnatObjectType,
                                                                 const QString &url,
                                                                 ctkXnatObject *parent)
 {
   // 1. Find project
   int start = url.lastIndexOf(xnatObjectType);
   if (start == -1)
     return nullptr;
 
   start += xnatObjectType.length();
 
   parent->fetch();
   QList<ctkXnatObject *> children = parent->children();
   foreach (ctkXnatObject *child, children)
   {
     if (url.indexOf(child->resourceUri()) != -1)
     {
       return child;
     }
   }
   return nullptr;
 }
 
 ctkXnatObject *QmitkXnatTreeModel::GetXnatObjectFromUrl(const QString &url)
 {
   QModelIndex index = this->index(0, 0, QModelIndex());
   ctkXnatObject *currentXnatObject = nullptr;
   currentXnatObject = this->xnatObject(index);
   if (currentXnatObject != nullptr)
   {
     // 1. Find project
     ctkXnatObject *project = nullptr;
     project = this->InternalGetXnatObjectFromUrl("projects/", url, currentXnatObject);
 
     // 2. Find subject
     ctkXnatObject *subject = nullptr;
     if (project != nullptr)
     {
       currentXnatObject = project;
       subject = this->InternalGetXnatObjectFromUrl("subjects/", url, project);
     }
 
     // 3. Find experiment
     ctkXnatObject *experiment = nullptr;
     if (subject != nullptr)
     {
       currentXnatObject = subject;
       experiment = this->InternalGetXnatObjectFromUrl("experiments/", url, subject);
     }
 
     // 4. Find scan
     ctkXnatObject *scan = nullptr;
     if (experiment != nullptr)
     {
       currentXnatObject = experiment;
       scan = this->InternalGetXnatObjectFromUrl("scans/", url, experiment);
     }
 
     if (scan != nullptr)
     {
       scan->fetch();
       QList<ctkXnatObject *> scans = scan->children();
       foreach (ctkXnatObject *child, scans)
       {
         if (url.indexOf(child->resourceUri()) != -1)
         {
           return child;
         }
       }
     }
 
     currentXnatObject->fetch();
     QList<ctkXnatObject *> bla = currentXnatObject->children();
     foreach (ctkXnatObject *child, bla)
     {
       if (child->name() == "Resources")
         return child;
     }
   }
   return nullptr;
 }
diff --git a/Plugins/org.blueberry.core.runtime/src/internal/berryConfigurationElement.cpp b/Plugins/org.blueberry.core.runtime/src/internal/berryConfigurationElement.cpp
index 5b98a2a021..ce073e600e 100644
--- a/Plugins/org.blueberry.core.runtime/src/internal/berryConfigurationElement.cpp
+++ b/Plugins/org.blueberry.core.runtime/src/internal/berryConfigurationElement.cpp
@@ -1,311 +1,311 @@
 /*============================================================================
 
 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 "berryConfigurationElement.h"
 
 #include "berryIExecutableExtension.h"
 #include "berryIExecutableExtensionFactory.h"
 #include "berryConfigurationElementHandle.h"
 #include "berryStatus.h"
 #include "berryRegistryMessages.h"
 #include "berryRegistryConstants.h"
 #include "berryCoreException.h"
 #include "berryExtensionRegistry.h"
 #include "berryRegistryObjectManager.h"
 #include "berryRegistryContributor.h"
 #include "berryObjectString.h"
 #include "berryObjectStringMap.h"
 
-#include <QRegExp>
+#include <QRegularExpression>
 
 namespace berry {
 
 ConfigurationElement::ConfigurationElement(ExtensionRegistry* registry, bool persist)
   : RegistryObject(registry, persist)
 {
 }
 
 ConfigurationElement::ConfigurationElement(int self, const QString& contributorId,
                                            const QString& name, const QList<QString>& propertiesAndValue,
                                            const QList<int>& children, int extraDataOffset, int parent,
                                            short parentType, ExtensionRegistry* registry, bool persist)
   : RegistryObject(registry, persist), parentId(parent), parentType(parentType),
     propertiesAndValue(propertiesAndValue), name(name), contributorId(contributorId)
 {
   SetObjectId(self);
   SetRawChildren(children);
   SetExtraDataOffset(extraDataOffset);
 }
 
 void ConfigurationElement::ThrowException(const QString& message, const ctkException& exc)
 {
   IStatus::Pointer status(new Status(IStatus::ERROR_TYPE, RegistryMessages::OWNER_NAME,
                                      RegistryConstants::PLUGIN_ERROR, message, exc,
                                      BERRY_STATUS_LOC));
   throw CoreException(status);
 }
 
 void ConfigurationElement::ThrowException(const QString &message)
 {
   IStatus::Pointer status(new Status(IStatus::ERROR_TYPE, RegistryMessages::OWNER_NAME,
                                      RegistryConstants::PLUGIN_ERROR, message,
                                      BERRY_STATUS_LOC));
   throw CoreException(status);
 }
 
 QString ConfigurationElement::GetValue() const
 {
   return GetValueAsIs();
 }
 
 QString ConfigurationElement::GetValueAsIs() const
 {
   if (!propertiesAndValue.empty() && propertiesAndValue.size() % 2 == 1)
     return propertiesAndValue.back();
   return QString();
 }
 
 QString ConfigurationElement::GetAttributeAsIs(const QString& attrName) const
 {
   if (propertiesAndValue.size() <= 1)
     return QString();
   int size = propertiesAndValue.size() - (propertiesAndValue.size() % 2);
   for (int i = 0; i < size; i += 2)
   {
     if (propertiesAndValue[i] == attrName)
       return propertiesAndValue[i + 1];
   }
   return QString();
 }
 
 QList<QString> ConfigurationElement::GetAttributeNames() const
 {
   if (propertiesAndValue.size() <= 1)
     return QList<QString>();
 
   QList<QString> result;
   int size = propertiesAndValue.size() / 2;
   for (int i = 0; i < size; i++)
   {
     result.push_back(propertiesAndValue[i * 2]);
   }
   return result;
 }
 
 void ConfigurationElement::SetProperties(const QList<QString>& value)
 {
   propertiesAndValue = value;
 }
 
 QList<QString> ConfigurationElement::GetPropertiesAndValue() const
 {
   return propertiesAndValue;
 }
 
 void ConfigurationElement::SetValue(const QString& value)
 {
   if (propertiesAndValue.empty())
   {
     propertiesAndValue.push_back(value);
     return;
   }
   if (propertiesAndValue.size() % 2 == 1)
   {
     propertiesAndValue[propertiesAndValue.size() - 1] = value;
     return;
   }
   propertiesAndValue.push_back(value);
 }
 
 void ConfigurationElement::SetContributorId(const QString& id)
 {
   contributorId = id;
 }
 
 QString ConfigurationElement::GetContributorId() const
 {
   return contributorId;
 }
 
 void ConfigurationElement::SetParentId(int objectId)
 {
   parentId = objectId;
 }
 
 QString ConfigurationElement::GetName() const
 {
   return name;
 }
 
 void ConfigurationElement::SetName(const QString& name)
 {
   this->name = name;
 }
 
 void ConfigurationElement::SetParentType(short type)
 {
   parentType = type;
 }
 
 QObject* ConfigurationElement::CreateExecutableExtension(const QString& attributeName)
 {
   QString prop;
   QString executable;
   QString contributorName;
   QString className;
   Object::Pointer initData;
   int i = 0;
 
   if (!attributeName.isEmpty())
   {
     prop = GetAttribute(attributeName);
   }
   else
   {
     // property not specified, try as element value
     prop = GetValue().trimmed();
   }
 
   if (prop.isEmpty())
   {
     // property not defined, try as a child element
     QList<ConfigurationElement::Pointer> exec = GetChildren(attributeName);
     if (!exec.empty())
     {
       ConfigurationElement::Pointer element = exec[0]; // assumes single definition
       contributorName = element->GetAttribute("plugin");
       className = element->GetAttribute("class");
       QList<ConfigurationElement::Pointer> parms = element->GetChildren("parameter");
       if (!parms.empty())
       {
         QHash<QString,QString> initParms;
         for (i = 0; i < parms.size(); i++)
         {
           QString pname = parms[i]->GetAttribute("name");
           if (!pname.isEmpty())
             initParms.insert(pname, parms[i]->GetAttribute("value"));
         }
         if (!initParms.isEmpty())
           initData = new ObjectStringMap(initParms);
       }
     }
     else
     {
       // specified name is not a simple attribute nor child element
       ThrowException(QString("Executable extension definition for \"%1\" not found.").arg(attributeName));
     }
   }
   else
   {
     // simple property or element value, parse it into its components
-    i = prop.indexOf(QRegExp("[^:]:[^:]"));
+    i = prop.indexOf(QRegularExpression("[^:]:[^:]"));
     if (i != -1)
     {
       executable = prop.left(i+1).trimmed();
       initData = new ObjectString(prop.mid(i + 2).trimmed());
     }
     else
     {
       executable = prop;
     }
 
     i = executable.indexOf('/');
     if (i != -1)
     {
       contributorName = executable.left(i).trimmed();
       className = executable.mid(i + 1).trimmed();
     }
     else
     {
       className = executable;
     }
   }
 
   // create a new instance
   RegistryContributor::Pointer defaultContributor = registry->GetObjectManager()->GetContributor(contributorId);
   QObject* result = registry->CreateExecutableExtension(defaultContributor, className, contributorName);
 
   // Check if we have extension adapter and initialize;
   // Make the call even if the initialization string is null
   try
   {
     // We need to take into account both "old" and "new" style executable extensions
     if (IExecutableExtension* execExt = qobject_cast<IExecutableExtension*>(result))
     {
       ConfigurationElementHandle::Pointer confElementHandle(new ConfigurationElementHandle(
                                                               registry->GetObjectManager(), GetObjectId()));
       execExt->SetInitializationData(confElementHandle, attributeName, initData);
     }
   }
   catch (const CoreException& ce)
   {
     // user code threw exception
     throw ce;
   }
   catch (const ctkException& te)
   {
     // user code caused exception
     ThrowException(QString("Plug-in \"%1\" was unable to execute setInitializationData on an instance of \"%2\".")
                    .arg(GetContributor()->GetName()).arg(className), te);
   }
 
   // Deal with executable extension factories.
   if (IExecutableExtensionFactory* execExtFactory = qobject_cast<IExecutableExtensionFactory*>(result))
   {
     result = execExtFactory->Create();
   }
 
   return result;
 }
 
 QString ConfigurationElement::GetAttribute(const QString& attrName, const QLocale& /*locale*/) const
 {
   registry->LogMultiLangError();
   return GetAttribute(attrName);
 }
 
 QString ConfigurationElement::GetValue(const QLocale& /*locale*/) const
 {
   registry->LogMultiLangError();
   return GetValue();
 }
 
 QString ConfigurationElement::GetAttribute(const QString& attrName) const
 {
   return GetAttributeAsIs(attrName);
 }
 
 QList<ConfigurationElement::Pointer> ConfigurationElement::GetChildren(const QString& childrenName) const
 {
   QList<ConfigurationElement::Pointer> result;
   if (GetRawChildren().empty())
     return result;
 
   RegistryObjectManager::Pointer objectManager = registry->GetObjectManager();
   for (int i = 0; i < children.size(); i++)
   {
     ConfigurationElement::Pointer toTest = objectManager->GetObject(
           children[i], NoExtraData() ? RegistryObjectManager::CONFIGURATION_ELEMENT : RegistryObjectManager::THIRDLEVEL_CONFIGURATION_ELEMENT).Cast<ConfigurationElement>();
     if (toTest->name == childrenName)
     {
       result.push_back(toTest);
     }
   }
   return result;
 }
 
 SmartPointer<IContributor> ConfigurationElement::GetContributor() const
 {
   return registry->GetObjectManager()->GetContributor(contributorId);
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt.log/src/internal/berryQtLogView.cpp b/Plugins/org.blueberry.ui.qt.log/src/internal/berryQtLogView.cpp
index d1960b8dd7..c3052f2719 100644
--- a/Plugins/org.blueberry.ui.qt.log/src/internal/berryQtLogView.cpp
+++ b/Plugins/org.blueberry.ui.qt.log/src/internal/berryQtLogView.cpp
@@ -1,152 +1,153 @@
 /*============================================================================
 
 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 "berryQtLogView.h"
 
 #include "berryQtLogPlugin.h"
 
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 
 #include <QHeaderView>
 
 #include <QTimer>
 #include <QClipboard>
 
 #include <mitkIPreferencesService.h>
 #include <mitkIPreferences.h>
 
 namespace berry {
 
 QtLogView::QtLogView(QWidget *parent)
     : QWidget(parent)
 {
   auto* prefService = berry::Platform::GetPreferencesService();
   auto* prefs = prefService->GetSystemPreferences()->Node("org_blueberry_ui_qt_log");
 
 
   prefs->PutBool("ShowAdvancedFields", false);
   prefs->PutBool("ShowCategory", true);
   bool showAdvancedFields = false;
 
   ui.setupUi(this);
 
   model = QtLogPlugin::GetInstance()->GetLogModel();
   model->SetShowAdvancedFiels( showAdvancedFields );
 
   filterModel = new QSortFilterProxyModel(this);
   filterModel->setSourceModel(model);
   filterModel->setFilterKeyColumn(-1);
 
 #ifdef __APPLE__
   QFont fnt = ui.tableView->font();
   fnt.setPointSize(11);
   ui.tableView->setFont(fnt);
 #endif
   ui.tableView->setModel(filterModel);
   ui.tableView->verticalHeader()->setVisible(false);
   ui.tableView->horizontalHeader()->setStretchLastSection(true);
 
   connect( ui.filterContent, SIGNAL( textChanged( const QString& ) ), this, SLOT( slotFilterChange( const QString& ) ) );
   connect( filterModel, SIGNAL( rowsInserted ( const QModelIndex &, int, int ) ), this, SLOT( slotRowAdded( const QModelIndex &, int , int  ) ) );
   connect( ui.SaveToClipboard, SIGNAL( clicked()),this, SLOT(on_SaveToClipboard_clicked()));
 
   ui.ShowAdvancedFields->setChecked( showAdvancedFields );
   ui.filterContent->setClearButtonEnabled(true);
 }
 
 QtLogView::~QtLogView()
 {
 }
 
 void QtLogView::slotScrollDown( )
 {
   ui.tableView->scrollToBottom();
 }
 
 void QtLogView::slotFilterChange( const QString& q )
 {
-  filterModel->setFilterRegExp(QRegExp(q, Qt::CaseInsensitive, QRegExp::FixedString));
+  QRegularExpression regExp(QRegularExpression::escape(q), QRegularExpression::CaseInsensitiveOption);
+  filterModel->setFilterRegularExpression(regExp);
 }
 
 
 void QtLogView::slotRowAdded ( const QModelIndex &  /*parent*/, int /*start*/, int /*end*/ )
 {
   ui.tableView->setVisible(false);
   ui.tableView->resizeRowsToContents();
 
   //only resize columns when first entry is added
   static bool first = true;
   if(first)
     {
     ui.tableView->resizeColumnsToContents();
     first = false;
     }
   ui.tableView->setVisible(true);
 
   QTimer::singleShot(0,this,SLOT( slotScrollDown() ) );
 }
 
 void QtLogView::showEvent( QShowEvent * /*event*/ )
 {
     ui.tableView->setVisible(false);
   ui.tableView->resizeColumnsToContents();
   ui.tableView->resizeRowsToContents();
   ui.tableView->setVisible(true);
 }
 
 void QtLogView::on_ShowAdvancedFields_clicked( bool checked )
 {
   ui.tableView->setVisible(false);
   QtLogPlugin::GetInstance()->GetLogModel()->SetShowAdvancedFiels( checked );
   ui.tableView->resizeColumnsToContents();
   ui.tableView->setVisible(true);
 
   auto* prefService = berry::Platform::GetPreferencesService();
   auto* prefs = prefService->GetSystemPreferences()->Node("org_blueberry_ui_qt_log");
 
   prefs->PutBool("ShowAdvancedFields", checked);
   prefs->Flush();
 }
 
 void QtLogView::on_ShowCategory_clicked( bool checked )
 {
   ui.tableView->setVisible(false);
   QtLogPlugin::GetInstance()->GetLogModel()->SetShowCategory( checked );
   ui.tableView->resizeColumnsToContents();
   ui.tableView->setVisible(true);
 
   auto* prefService = berry::Platform::GetPreferencesService();
   auto* prefs = prefService->GetSystemPreferences()->Node("org_blueberry_ui_qt_log");
 
   prefs->PutBool("ShowCategory", checked);
   prefs->Flush();
 }
 
 void QtLogView::on_SaveToClipboard_clicked()
 {
   QClipboard *clipboard = QApplication::clipboard();
   QString loggingMessagesAsText = QString("");
   for (int i=0; i<ui.tableView->model()->rowCount(); i++)
     {
     for (int j=0; j<ui.tableView->model()->columnCount(); j++)
       {
       QModelIndex index = ui.tableView->model()->index(i, j);
       loggingMessagesAsText += ui.tableView->model()->data(index, Qt::DisplayRole).toString() + " ";
       }
     loggingMessagesAsText += "\n";
     }
 
   clipboard->setText(loggingMessagesAsText);
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveHelper.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveHelper.cpp
index e35824ad1c..6ce8a99aab 100755
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveHelper.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveHelper.cpp
@@ -1,1515 +1,1515 @@
 /*============================================================================
 
 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 "tweaklets/berryGuiWidgetsTweaklet.h"
 
 #include "berryPerspectiveHelper.h"
 
 #include "berryLayoutTree.h"
 #include "berryEditorSashContainer.h"
 #include "berryDragUtil.h"
 #include "berryPresentationFactoryUtil.h"
 #include "berryWorkbenchConstants.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryPolicy.h"
 
 #include <berryDebugUtil.h>
 
 namespace berry
 {
 
 const int PerspectiveHelper::MIN_DETACH_WIDTH = 150;
 const int PerspectiveHelper::MIN_DETACH_HEIGHT = 250;
 
 PerspectiveHelper::DragOverListener::DragOverListener(PerspectiveHelper* perspHelper) :
   perspHelper(perspHelper)
 {
 
 }
 
 IDropTarget::Pointer PerspectiveHelper::DragOverListener::Drag(
     QWidget* /*currentControl*/, const Object::Pointer& draggedObject, const QPoint& /*position*/,
     const QRect& dragRectangle)
 {
 
   if (draggedObject.Cast<PartPane>() != 0)
   {
     PartPane::Pointer part = draggedObject.Cast<PartPane>();
     if (part->GetContainer().Cast<PartStack>()->GetAppearance() == PresentationFactoryUtil::ROLE_EDITOR)
       return IDropTarget::Pointer(nullptr);
 
     // Views that haven't been shown yet have no 'control' which causes
     // 'GetWorkbenchWindow' to return 'null' so check explicitly
     if (part->GetPage() != perspHelper->page)
       return IDropTarget::Pointer(nullptr);
     else if (part->GetWorkbenchWindow() != perspHelper->page->GetWorkbenchWindow())
       return IDropTarget::Pointer(nullptr);
 
     if (perspHelper->dropTarget == 0)
       perspHelper->dropTarget = new ActualDropTarget(perspHelper, part, dragRectangle);
     else
       perspHelper->dropTarget->SetTarget(part, dragRectangle);
   }
   else if (draggedObject.Cast<PartStack>() != 0)
   {
     PartStack::Pointer stack = draggedObject.Cast<PartStack>();
     if (stack->GetAppearance() == PresentationFactoryUtil::ROLE_EDITOR)
       return IDropTarget::Pointer(nullptr);
 
     if (stack->GetWorkbenchWindow() != perspHelper->page->GetWorkbenchWindow())
       return IDropTarget::Pointer(nullptr);
 
     if (perspHelper->dropTarget == 0)
       perspHelper->dropTarget = new ActualDropTarget(perspHelper, stack, dragRectangle);
     else
       perspHelper->dropTarget->SetTarget(stack, dragRectangle);
   }
 
   return perspHelper->dropTarget;
 }
 
 void PerspectiveHelper::ActualDropTarget::SetTarget(PartPane::Pointer part,
     const QRect& dragRectangle)
 {
   this->stack = nullptr;
   this->part = part;
   this->dragRectangle = dragRectangle;
 }
 
 void PerspectiveHelper::ActualDropTarget::SetTarget(PartStack::Pointer stack,
     const QRect& dragRectangle)
 {
   this->stack = stack;
   this->part = nullptr;
   this->dragRectangle = dragRectangle;
 }
 
 PerspectiveHelper::ActualDropTarget::ActualDropTarget(PerspectiveHelper* perspHelper, PartPane::Pointer part,
     const QRect& dragRectangle)
 : AbstractDropTarget(), perspHelper(perspHelper)
 {
   this->SetTarget(part, dragRectangle);
 }
 
 PerspectiveHelper::ActualDropTarget::ActualDropTarget(PerspectiveHelper* perspHelper, PartStack::Pointer stack,
     const QRect& dragRectangle)
 : AbstractDropTarget(), perspHelper(perspHelper)
 {
   this->SetTarget(stack, dragRectangle);
 }
 
 void PerspectiveHelper::ActualDropTarget::Drop()
 {
 
   if (part != 0)
   {
   Shell::Pointer shell = part->GetShell();
   if (shell->GetData().Cast<DetachedWindow> () != 0)
   {
     // if only one view in tab folder then do a window move
     ILayoutContainer::Pointer container = part->GetContainer();
     if (container.Cast<PartStack> () != 0)
     {
       if (container.Cast<PartStack>()->GetItemCount() == 1)
       {
         shell->SetLocation(dragRectangle.x(), dragRectangle.y());
         return;
       }
     }
   }
 
 //  // If layout is modified always zoom out.
 //  if (isZoomed())
 //  {
 //    zoomOut();
 //  }
   // do a normal part detach
   perspHelper->DetachPart(part, dragRectangle.x(), dragRectangle.y());
   }
   else if (stack != 0)
   {
     Shell::Pointer shell = stack->GetShell();
   if (shell->GetData().Cast<DetachedWindow> () != 0)
   {
     // only one tab folder in a detach window, so do window
     // move
      shell->SetLocation(dragRectangle.x(), dragRectangle.y());
       return;
   }
 
 //  // If layout is modified always zoom out.
 //  if (isZoomed())
 //  {
 //    zoomOut();
 //  }
   // do a normal part detach
   perspHelper->Detach(stack, dragRectangle.x(), dragRectangle.y());
   }
 }
 
 CursorType PerspectiveHelper::ActualDropTarget::GetCursor()
 {
   return CURSOR_OFFSCREEN;
 }
 
 PerspectiveHelper::MatchingPart::MatchingPart(const QString& pid,
     const QString& sid, LayoutPart::Pointer part)
 {
   this->pid = pid;
   this->sid = sid;
   this->part = part;
   this->len = pid.size() + sid.size();
   this->hasWildcard = (pid.indexOf(PartPlaceholder::WILD_CARD) != -1) ||
                       (sid.indexOf(PartPlaceholder::WILD_CARD) != -1);
 }
 
 bool PerspectiveHelper::CompareMatchingParts::operator()(const MatchingPart& m1, const MatchingPart& m2) const
 {
   // specific ids always outweigh ids with wildcards
   if (m1.hasWildcard && !m2.hasWildcard)
   {
     return true;
   }
   if (!m1.hasWildcard && m2.hasWildcard)
   {
     return false;
   }
   // if both are specific or both have wildcards, simply compare based on length
   return m1.len > m2.len;
 }
 
 PerspectiveHelper::PerspectiveHelper(WorkbenchPage* workbenchPage,
     ViewSashContainer::Pointer mainLayout, Perspective* persp)
 : page(workbenchPage), perspective(persp),
 mainLayout(mainLayout),
 detachable(false), active(false)
 {
 
   // Views can be detached if the feature is enabled (true by default,
   // use the plug-in customization file to disable), and if the platform
   // supports detaching.
 
   this->dragTarget.reset(new DragOverListener(this));
 
   //TODO preference store
   //  IPreferenceStore store = PlatformUI.getPreferenceStore();
   //  this.detachable = store.getBoolean(
   //      IWorkbenchPreferenceConstants.ENABLE_DETACHED_VIEWS);
   this->detachable = true;
 
   if (this->detachable)
   {
     // Check if some arbitrary Composite supports reparenting. If it
     // doesn't, views cannot be detached.
 
     QWidget* client = workbenchPage->GetClientComposite();
     if (client == nullptr)
     {
       // The workbench page is not initialized. I don't think this can happen,
       // but if it does, silently set detachable to false.
       this->detachable = false;
     }
     else
     {
       this->detachable = Tweaklets::Get(GuiWidgetsTweaklet::KEY)->IsReparentable(client);
     }
   }
 }
 
 void PerspectiveHelper::Activate(QWidget* parent)
 {
 
   if (active)
   {
     return;
   }
 
   parentWidget = parent;
 
   // Activate main layout
   // make sure all the views have been properly parented
   QList<PartPane::Pointer> children;
   this->CollectViewPanes(children, mainLayout->GetChildren());
   for (QList<PartPane::Pointer>::iterator iter = children.begin();
       iter != children.end(); ++iter)
   {
     PartPane::Pointer part = *iter;
     part->Reparent(parent);
   }
   mainLayout->CreateControl(parent);
   mainLayout->SetActive(true);
 
   // Open the detached windows.
   for (DetachedWindowsType::iterator iter = detachedWindowList.begin();
       iter != detachedWindowList.end(); ++iter)
   {
     (*iter)->Open();
   }
 
   this->EnableAllDrag();
 
   //  // Ensure that the maximized stack's presentation state is correct
   //  if (maximizedStackId != 0)
   //  {
   //    LayoutPart part = this->FindPart(maximizedStackId);
   //    if (part.Cast<PartStack>() != 0)
   //    {
   //      maximizedStack = (PartStack) part;
   //      maximizedStackId = 0;
   //    }
   //  }
   //
   //  // NOTE: we only handle ViewStacks here; Editor Stacks are handled by the
   //  // perspective
   //  if (maximizedStack instanceof ViewStack)
   //  {
   //    maximizedStack.setPresentationState(IStackPresentationSite.STATE_MAXIMIZED);
   //  }
 
   active = true;
 }
 
 void PerspectiveHelper::AddPart(LayoutPart::Pointer part)
 {
 
   // Look for a placeholder.
   PartPlaceholder::Pointer placeholder;
   LayoutPart::Pointer testPart;
   QString primaryId = part->GetID();
   QString secondaryId;
 
   IViewReference::Pointer ref;
   if (part.Cast<PartPane> () != 0)
   {
     PartPane::Pointer pane = part.Cast<PartPane> ();
     ref = pane->GetPartReference().Cast<IViewReference> ();
     if (ref != 0)
     secondaryId = ref->GetSecondaryId();
   }
   if (secondaryId != "")
   {
     testPart = this->FindPart(primaryId, secondaryId);
   }
   else
   {
     testPart = this->FindPart(primaryId);
   }
 
   // validate the testPart
   if (testPart != 0 && testPart.Cast<PartPlaceholder>() != 0)
   {
     placeholder = testPart.Cast<PartPlaceholder> ();
   }
 
   // If there is no placeholder do a simple add. Otherwise, replace the
   // placeholder if its not a pattern matching placeholder
   if (placeholder == 0)
   {
     part->Reparent(mainLayout->GetParent());
     LayoutPart::Pointer relative = mainLayout->FindBottomRight();
     if (relative != 0 && relative.Cast<ILayoutContainer>() != 0)
     {
       ILayoutContainer::Pointer stack =
       relative.Cast<ILayoutContainer> ();
       if (stack->AllowsAdd(part))
       {
         mainLayout->Stack(part, stack);
       }
       else
       {
         mainLayout->AddPart(part);
       }
     }
     else
     {
       mainLayout->AddPart(part);
     }
   }
   else
   {
     ILayoutContainer::Pointer container = placeholder->GetContainer();
     if (container != 0)
     {
       if (container.Cast<DetachedPlaceHolder> () != 0)
       {
         //Create a detached window add the part on it.
         DetachedPlaceHolder::Pointer holder = container.Cast<DetachedPlaceHolder>();
         detachedPlaceHolderList.removeAll(holder);
         container->Remove(testPart);
         DetachedWindow::Pointer window(new DetachedWindow(page));
         detachedWindowList.push_back(window);
         window->Create();
         part->CreateControl(window->GetShell()->GetControl());
         // Open window.
         window->GetShell()->SetBounds(holder->GetBounds());
         window->Open();
         // add part to detached window.
         PartPane::Pointer pane = part.Cast<PartPane>();
         window->Add(pane);
         QList<LayoutPart::Pointer> otherChildren = holder->GetChildren();
         for (QList<LayoutPart::Pointer>::iterator iter = otherChildren.begin();
             iter != otherChildren.end(); ++iter)
         {
           part->GetContainer()->Add(*iter);
         }
       }
       else
       {
         // show parent if necessary
         if (container.Cast<ContainerPlaceholder> () != 0)
         {
           ContainerPlaceholder::Pointer containerPlaceholder =
               container.Cast<ContainerPlaceholder>();
           ILayoutContainer::Pointer parentContainer =
               containerPlaceholder->GetContainer();
           if (parentContainer == 0)
           {
             if (Policy::DEBUG_PERSPECTIVES())
             {
               QString msg = "Previous ContainerPlaceholder for " + tmpViewId;
               if (tmpStackTrace.isNull())
               {
                 WorkbenchPlugin::Log(msg);
               }
               else
               {
                 WorkbenchPlugin::Log(msg, *tmpStackTrace.data());
               }
               tmpViewId.clear();
               tmpStackTrace.reset(new ctkException(""));
               WorkbenchPlugin::Log("Current ContainerPlaceholder with null parent for " +
                                    primaryId + ":" + secondaryId, *tmpStackTrace.data());
               tmpStackTrace.reset();
             }
             return;
           }
           if (Policy::DEBUG_PERSPECTIVES())
           {
             tmpViewId = primaryId + ":" + secondaryId;
             tmpStackTrace.reset(new ctkException(""));
           }
 
           container = containerPlaceholder->GetRealContainer().Cast<ILayoutContainer>();
           if (container.Cast<LayoutPart> () != 0)
           {
             parentContainer->Replace(containerPlaceholder,
                 container.Cast<LayoutPart>());
           }
           containerPlaceholder->SetRealContainer(ILayoutContainer::Pointer(nullptr));
         }
 
 //        // reparent part.
 //        if (container.Cast<PartStack>() == 0)
 //        {
 //          // We don't need to reparent children of PartTabFolders since they will automatically
 //          // reparent their children when they become visible. This if statement used to be
 //          // part of an else branch. Investigate if it is still necessary.
 //          part->Reparent(mainLayout->GetParent());
 //        }
 
         // see if we should replace the placeholder
         if (placeholder->HasWildCard())
         {
           if (PartSashContainer::Pointer sashContainer = container.Cast<PartSashContainer>())
           {
             sashContainer->AddChildForPlaceholder(part, placeholder);
           }
           else
           {
             container->Add(part);
           }
         }
         else
         {
           container->Replace(placeholder, part);
         }
       }
     }
   }
 }
 
 void PerspectiveHelper::AttachPart(IViewReference::Pointer ref)
 {
   PartPane::Pointer pane = ref.Cast<WorkbenchPartReference>()->GetPane();
 
   // Restore any maximized part before re-attaching.
   // Note that 'getMaximizedStack != 0' implies 'useNewMinMax'
   //  if (getMaximizedStack() != 0)
   //  {
   //    getMaximizedStack().setState(IStackPresentationSite.STATE_RESTORED);
   //  }
 
   this->DerefPart(pane);
   this->AddPart(pane);
   this->BringPartToTop(pane);
   pane->SetFocus();
 }
 
 bool PerspectiveHelper::CanDetach()
 {
   return detachable;
 }
 
 bool PerspectiveHelper::BringPartToTop(LayoutPart::Pointer part)
 {
   ILayoutContainer::Pointer container = part->GetContainer();
   if (container != 0 && container.Cast<PartStack> () != 0)
   {
     PartStack::Pointer folder = container.Cast<PartStack> ();
     if (folder->GetSelection() != part)
     {
       folder->SetSelection(part);
       return true;
     }
   }
   return false;
 }
 
 bool PerspectiveHelper::IsPartVisible(IWorkbenchPartReference::Pointer partRef)
 {
   LayoutPart::Pointer foundPart;
   if (partRef.Cast<IViewReference> () != 0)
   {
     foundPart = this->FindPart(partRef->GetId(),
         partRef.Cast<IViewReference>()->GetSecondaryId());
   }
   else
   {
     foundPart = this->FindPart(partRef->GetId());
   }
   if (foundPart == 0)
   {
     return false;
   }
   if (foundPart.Cast<PartPlaceholder> () != 0)
   {
     return false;
   }
 
   ILayoutContainer::Pointer container = foundPart->GetContainer();
 
   if (container.Cast<ContainerPlaceholder> () != 0)
   {
     return false;
   }
 
   if (container.Cast<PartStack> () != 0)
   {
     PartStack::Pointer folder = container.Cast<PartStack>();
     LayoutPart::Pointer visiblePart = folder->GetSelection();
     if (visiblePart == 0)
     {
       return false;
     }
     return partRef == visiblePart.Cast<PartPane>()->GetPartReference();
   }
   return true;
 }
 
 bool PerspectiveHelper::WillPartBeVisible(const QString& partId)
 {
   return this->WillPartBeVisible(partId, nullptr);
 }
 
 bool PerspectiveHelper::WillPartBeVisible(const QString& partId,
     const QString& secondaryId)
 {
   LayoutPart::Pointer part = this->FindPart(partId, secondaryId);
   if (part == 0)
   {
     return false;
   }
   ILayoutContainer::Pointer container = part->GetContainer();
   if (container != 0 && container.Cast<ContainerPlaceholder> () != 0)
   {
     container = container.Cast<ContainerPlaceholder>()->GetRealContainer().Cast<ILayoutContainer>();
   }
 
   if (container != 0 && container.Cast<PartStack> () != 0)
   {
     PartStack::Pointer folder = container.Cast<PartStack>();
     if (folder->GetSelection() == 0)
     {
       return false;
     }
     return part->GetID() == folder->GetSelection()->GetID();
   }
   return true;
 }
 
 QList<PartPlaceholder::Pointer> PerspectiveHelper::CollectPlaceholders()
 {
   // Scan the main window.
   QList<PartPlaceholder::Pointer> results = this->CollectPlaceholders(
       mainLayout->GetChildren());
 
   // Scan each detached window.
   if (detachable)
   {
     for (DetachedWindowsType::iterator winIter = detachedWindowList.begin();
         winIter != detachedWindowList.end(); ++winIter)
     {
       DetachedWindow::Pointer win = *winIter;
       QList<LayoutPart::Pointer> moreResults = win->GetChildren();
       if (moreResults.size()> 0)
       {
         for (QList<LayoutPart::Pointer>::iterator iter = moreResults.begin();
             iter != moreResults.end(); ++iter)
         {
           if (iter->Cast<PartPlaceholder>() != 0)
           results.push_back(iter->Cast<PartPlaceholder>());
         }
       }
     }
   }
   return results;
 }
 
 QList<PartPlaceholder::Pointer> PerspectiveHelper::CollectPlaceholders(
     const QList<LayoutPart::Pointer>& parts)
 {
   QList<PartPlaceholder::Pointer> result;
 
   for (QList<LayoutPart::Pointer>::const_iterator iter = parts.begin();
       iter != parts.end(); ++iter)
   {
     LayoutPart::Pointer part = *iter;
     if (ILayoutContainer::Pointer container = part.Cast<ILayoutContainer>())
     {
       // iterate through sub containers to find sub-parts
       QList<PartPlaceholder::Pointer> newParts = this->CollectPlaceholders(
             container->GetChildren());
       result.append(newParts);
     }
     else if (PartPlaceholder::Pointer placeholder = part.Cast<PartPlaceholder>())
     {
       result.push_back(placeholder);
     }
   }
 
   return result;
 }
 
 void PerspectiveHelper::CollectViewPanes(QList<PartPane::Pointer>& result)
 {
   // Scan the main window.
   this->CollectViewPanes(result, mainLayout->GetChildren());
 
   // Scan each detached window.
   if (detachable)
   {
     for (DetachedWindowsType::iterator winIter = detachedWindowList.begin();
         winIter != detachedWindowList.end(); ++winIter)
     {
       DetachedWindow::Pointer win = *winIter;
       CollectViewPanes(result, win->GetChildren());
     }
   }
 }
 
 void PerspectiveHelper::CollectViewPanes(QList<PartPane::Pointer>& result,
     const QList<LayoutPart::Pointer>& parts)
 {
   for (QList<LayoutPart::Pointer>::const_iterator iter = parts.begin();
       iter != parts.end(); ++iter)
   {
     LayoutPart::Pointer part = *iter;
     if (PartPane::Pointer partPane = part.Cast<PartPane>())
     {
       if(partPane->GetPartReference().Cast<IViewReference>())
       {
         result.push_back(partPane);
       }
     }
     else if (ILayoutContainer::Pointer container = part.Cast<ILayoutContainer> ())
     {
       this->CollectViewPanes(result, container->GetChildren());
     }
   }
 }
 
 void PerspectiveHelper::Deactivate()
 {
   if (!active)
   {
     return;
   }
 
   this->DisableAllDrag();
 
   // Reparent all views to the main window
   QWidget* parent = mainLayout->GetParent();
   QList<PartPane::Pointer> children;
   this->CollectViewPanes(children, mainLayout->GetChildren());
 
   for (DetachedWindowsType::iterator winIter = detachedWindowList.begin();
       winIter != detachedWindowList.end(); ++winIter)
   {
     DetachedWindow::Pointer window = *winIter;
     CollectViewPanes(children, window->GetChildren());
   }
 
   // *** Do we even need to do this if detached windows not supported?
   for (QList<PartPane::Pointer>::iterator itr = children.begin();
       itr != children.end(); ++itr)
   {
     PartPane::Pointer part = *itr;
     part->Reparent(parent);
   }
 
   // Dispose main layout.
 
   mainLayout->SetActive(false);
 
   // Dispose the detached windows
   for (DetachedWindowsType::iterator iter = detachedWindowList.begin();
       iter != detachedWindowList.end(); ++iter)
   {
     (*iter)->Close();
   }
 
   active = false;
 }
 
 PerspectiveHelper::~PerspectiveHelper()
 {
   mainLayout->Dispose();
   mainLayout->DisposeSashes();
 }
 
 void PerspectiveHelper::DescribeLayout(QString& buf) const
 {
 
   if (detachable)
   {
     if (detachedWindowList.size() != 0)
     {
       buf.append("detachedWindows ("); //$NON-NLS-1$
 
       for (DetachedWindowsType::const_iterator winIter = detachedWindowList.begin();
           winIter != detachedWindowList.end(); ++winIter)
       {
         DetachedWindow::ConstPointer window = *winIter;
         QList<LayoutPart::Pointer> children = window->GetChildren();
         int j = 0;
         if (children.size() != 0)
         {
           buf.append("dWindow ("); //$NON-NLS-1$
           for (QList<LayoutPart::Pointer>::iterator partIter = children.begin();
               partIter != children.end(); ++partIter, ++j)
           {
             if (partIter->Cast<PartPlaceholder>() != 0)
             buf.append(partIter->Cast<PartPlaceholder>()->GetPlaceHolderId());
             else if (partIter->Cast<PartPane>() != 0)
             buf.append(
                 partIter->Cast<PartPane>()->GetPartReference()->GetPartName());
 
             if (j < (children.size() - 1))
             {
               buf.append(", "); //$NON-NLS-1$
             }
           }
           buf.append(")"); //$NON-NLS-1$
         }
 
       }
       buf.append("), "); //$NON-NLS-1$
     }
   }
 
   this->GetLayout()->DescribeLayout(buf);
 }
 
 void PerspectiveHelper::DerefPart(LayoutPart::Pointer part)
 {
   //  if (part.Cast<PartPane> () != 0)
   //  {
   //    IViewReference::Pointer ref = ((ViewPane) part).getViewReference();
   //    if (perspective.isFastView(ref))
   //    {
   //      // Special check: if it's a fast view then it's actual ViewStack
   //      // may only contain placeholders and the stack is represented in
   //      // the presentation by a container placeholder...make sure the
   //      // PartPlaceHolder for 'ref' is removed from the ViewStack
   //      String id = perspective.getFastViewManager().getIdForRef(ref);
   //      LayoutPart parentPart = findPart(id, 0);
   //      if (parentPart.Cast<ContainerPlaceholder> () != 0)
   //      {
   //        ViewStack vs =
   //            (ViewStack) ((ContainerPlaceholder) parentPart).getRealContainer();
   //        QList<LayoutPart::Pointer> kids = vs.getChildren();
   //        for (int i = 0; i < kids.length; i++)
   //        {
   //          if (kids[i].Cast<PartPlaceholder> () != 0)
   //          {
   //            if (ref.getId().equals(kids[i].id))
   //              vs.remove(kids[i]);
   //          }
   //        }
   //      }
   //      perspective.getFastViewManager().removeViewReference(ref, true, true);
   //    }
   //  }
 
   // Get vital part stats before reparenting.
   ILayoutContainer::Pointer oldContainer = part->GetContainer();
   bool wasDocked = part->IsDocked();
   Shell::Pointer oldShell = part->GetShell();
 
   // Reparent the part back to the main window
   part->Reparent(mainLayout->GetParent());
 
   // Update container.
   if (oldContainer == 0)
   {
     return;
   }
 
   oldContainer->Remove(part);
 
   ILayoutContainer::ChildrenType children = oldContainer->GetChildren();
   if (wasDocked)
   {
     bool hasChildren = (children.size()> 0);
     if (hasChildren)
     {
       // make sure one is at least visible
       int childVisible = 0;
       for (ILayoutContainer::ChildrenType::iterator iter = children.begin();
           iter != children.end(); ++iter)
       {
         if ((*iter)->GetControl() != nullptr)
         {
           childVisible++;
         }
       }
 
       // none visible, then reprarent and remove container
       if (oldContainer.Cast<PartStack> () != 0)
       {
         PartStack::Pointer folder = oldContainer.Cast<PartStack>();
 
         // Is the part in the trim?
         bool inTrim = false;
         //        // Safety check...there may be no FastViewManager
         //        if (perspective.getFastViewManager() != 0)
         //          inTrim
         //              = perspective.getFastViewManager().getFastViews(folder.getID()).size()
         //                  > 0;
 
         if (childVisible == 0 && !inTrim)
         {
           ILayoutContainer::Pointer parentContainer = folder->GetContainer();
           hasChildren = folder->GetChildren().size()> 0;
 
           // We maintain the stack as a place-holder if it has children
           // (which at this point would represent view place-holders)
           if (hasChildren)
           {
             folder->Dispose();
 
             // replace the real container with a ContainerPlaceholder
             ContainerPlaceholder::Pointer placeholder(
             new ContainerPlaceholder(folder->GetID()));
             placeholder->SetRealContainer(folder);
             parentContainer->Replace(folder, placeholder);
           }
         }
         else if (childVisible == 1)
         {
           LayoutTree::Pointer layout = mainLayout->GetLayoutTree();
           layout = layout->Find(folder);
           layout->SetBounds(layout->GetBounds());
         }
       }
     }
 
     if (!hasChildren)
     {
       // There are no more children in this container, so get rid of
       // it
       if (oldContainer.Cast<LayoutPart> () != 0)
       {
         //BERRY_INFO << "No children left, removing container\n";
 
         LayoutPart::Pointer parent = oldContainer.Cast<LayoutPart>();
         ILayoutContainer::Pointer parentContainer = parent->GetContainer();
         if (parentContainer != 0)
         {
           parentContainer->Remove(parent);
           parent->Print(qDebug());
           parent->Dispose();
         }
       }
     }
   }
   else if (!wasDocked)
   {
     if (children.empty())
     {
       // There are no more children in this container, so get rid of
       // it
       // Turn on redraw again just in case it was off.
       //oldShell.setRedraw(true);
       DetachedWindow::Pointer w = oldShell->GetData().Cast<DetachedWindow>();
       oldShell->Close();
       detachedWindowList.removeAll(w);
     }
     else
     {
       // There are children. If none are visible hide detached
       // window.
       bool allInvisible = true;
       for (ILayoutContainer::ChildrenType::iterator iter = children.begin();
           iter != children.end(); ++iter)
       {
         if (iter->Cast<PartPlaceholder> () == 0)
         {
           allInvisible = false;
           break;
         }
       }
       if (allInvisible)
       {
         DetachedPlaceHolder::Pointer placeholder(new DetachedPlaceHolder("",
             oldShell->GetBounds()));
         for (ILayoutContainer::ChildrenType::iterator iter = children.begin();
             iter != children.end(); ++iter)
         {
           oldContainer->Remove(*iter);
           (*iter)->SetContainer(placeholder);
           placeholder->Add(*iter);
         }
         detachedPlaceHolderList.push_back(placeholder);
         DetachedWindow::Pointer w = oldShell->GetData().Cast<DetachedWindow>();
         oldShell->Close();
         detachedWindowList.removeAll(w);
       }
     }
   }
 
 }
 
 void PerspectiveHelper::Detach(LayoutPart::Pointer part, int x, int y)
 {
 
   // Detaching is disabled on some platforms ..
   if (!detachable)
   {
     return;
   }
 
   // Calculate detached window size.
   QSize size = part->GetSize();
   if (size.width() == 0 || size.height() == 0)
   {
     ILayoutContainer::Pointer container = part->GetContainer();
     if (container.Cast<LayoutPart> () != 0)
     {
       size = container.Cast<LayoutPart>()->GetSize();
     }
   }
   int width = std::max<int>(size.width(), MIN_DETACH_WIDTH);
   int height = std::max<int>(size.height(), MIN_DETACH_HEIGHT);
 
   // Create detached window.
   DetachedWindow::Pointer window(new DetachedWindow(page));
   detachedWindowList.push_back(window);
 
   // Open window.
   window->Create();
   window->GetShell()->SetBounds(x, y, width, height);
   window->Open();
 
   if (part.Cast<PartStack> () != 0)
   {
     //window.getShell().setRedraw(false);
     //parentWidget.setRedraw(false);
     PartStack::Pointer stack = part.Cast<PartStack>();
     LayoutPart::Pointer visiblePart = stack->GetSelection();
     ILayoutContainer::ChildrenType children = stack->GetChildren();
     for (ILayoutContainer::ChildrenType::iterator iter = children.begin();
         iter != children.end(); ++iter)
     {
       if (PartPane::Pointer partPane = iter->Cast<PartPane>()
           // && check it is a view?
           )
       {
         // remove the part from its current container
         this->DerefPart(*iter);
         // add part to detached window.
         window->Add(*iter);
       }
     }
     if (visiblePart != 0)
     {
       this->BringPartToTop(visiblePart);
       visiblePart->SetFocus();
     }
     //window.getShell().setRedraw(true);
     //parentWidget.setRedraw(true);
   }
 
 }
 
 void PerspectiveHelper::DetachPart(LayoutPart::Pointer part, int x, int y)
 {
 
   // Detaching is disabled on some platforms ..
   if (!detachable)
   {
     return;
   }
 
   // Calculate detached window size.
   QSize size = part->GetSize();
   if (size.width() == 0 || size.height() == 0)
   {
     ILayoutContainer::Pointer container = part->GetContainer();
     if (container.Cast<LayoutPart> () != 0)
     {
       size = container.Cast<LayoutPart>()->GetSize();
     }
   }
   int width = std::max<int>(size.width(), MIN_DETACH_WIDTH);
   int height = std::max<int>(size.height(), MIN_DETACH_HEIGHT);
 
   // Create detached window.
   DetachedWindow::Pointer window(new DetachedWindow(page));
   detachedWindowList.push_back(window);
 
   // Open window.
   window->Create();
   window->GetShell()->SetBounds(x, y, width, height);
   window->Open();
 
   // remove the part from its current container
   this->DerefPart(part);
   // add part to detached window.
   window->Add(part);
   part->SetFocus();
 
 }
 
 void PerspectiveHelper::DetachPart(IViewReference::Pointer ref)
 {
   PartPane::Pointer pane = ref.Cast<WorkbenchPartReference>()->GetPane();
   if (this->CanDetach() && pane != 0)
   {
     //    if (getMaximizedStack() != 0)
     //      getMaximizedStack().setState(IStackPresentationSite.STATE_RESTORED);
 
     QRect bounds = pane->GetParentBounds();
     this->DetachPart(pane, bounds.x(), bounds.y());
   }
 }
 
 void PerspectiveHelper::AddDetachedPart(LayoutPart::Pointer part)
 {
   // Calculate detached window size.
   QRect bounds = Tweaklets::Get(GuiWidgetsTweaklet::KEY)->GetShell(parentWidget)->GetBounds();
   bounds.setX(bounds.x() + (bounds.width() - 300) / 2);
   bounds.setY(bounds.y() + (bounds.height() - 300) / 2);
 
   this->AddDetachedPart(part, bounds);
 }
 
 void PerspectiveHelper::AddDetachedPart(LayoutPart::Pointer part,
     const QRect& bounds)
 {
   // Detaching is disabled on some platforms ..
   if (!detachable)
   {
     this->AddPart(part);
     return;
   }
 
   // Create detached window.
   DetachedWindow::Pointer window(new DetachedWindow(page));
   detachedWindowList.push_back(window);
   window->Create();
 
   // add part to detached window.
   part->CreateControl(window->GetShell()->GetControl());
   window->Add(part);
 
   // Open window.
   window->GetShell()->SetBounds(bounds.x(), bounds.y(), bounds.width(), bounds.height());
   window->Open();
 
   part->SetFocus();
 
 }
 
 void PerspectiveHelper::DisableAllDrag()
 {
   DragUtil::RemoveDragTarget(nullptr, dragTarget.data());
 }
 
 void PerspectiveHelper::EnableAllDrag()
 {
   DragUtil::AddDragTarget(nullptr, dragTarget.data());
 }
 
 LayoutPart::Pointer PerspectiveHelper::FindPart(const QString& id)
 {
   return this->FindPart(id, "");
 }
 
 LayoutPart::Pointer PerspectiveHelper::FindPart(const QString& primaryId,
     const QString& secondaryId)
 {
 
   //BERRY_INFO << "Looking for part: " << primaryId << ":" << secondaryId << std::endl;
 
   // check main window.
   QList<MatchingPart> matchingParts;
   LayoutPart::Pointer part = (secondaryId != "") ? this->FindPart(primaryId, secondaryId,
       mainLayout->GetChildren(), matchingParts) : this->FindPart(primaryId,
       mainLayout->GetChildren(), matchingParts);
   if (part != 0)
   {
     return part;
   }
 
   // check each detached windows.
   for (DetachedWindowsType::iterator iter = detachedWindowList.begin();
       iter != detachedWindowList.end(); ++iter)
   {
     DetachedWindow::Pointer window = *iter;
     part = (secondaryId != "") ? this->FindPart(primaryId, secondaryId,
         window->GetChildren(), matchingParts) : this->FindPart(primaryId,
         window->GetChildren(), matchingParts);
     if (part != 0)
     {
       return part;
     }
   }
 
   for (DetachedPlaceHoldersType::iterator iter = detachedPlaceHolderList.begin();
       iter != detachedPlaceHolderList.end(); ++iter)
   {
     DetachedPlaceHolder::Pointer holder = *iter;
     part = (secondaryId != "") ? this->FindPart(primaryId, secondaryId,
         holder->GetChildren(), matchingParts) : this->FindPart(primaryId,
         holder->GetChildren(), matchingParts);
     if (part != 0)
     {
       return part;
     }
   }
 
   //BERRY_INFO << "Looking through the matched parts (count: " << matchingParts.size() << ")\n";
 
   // sort the matching parts
   if (matchingParts.size()> 0)
   {
     std::partial_sort(matchingParts.begin(), (matchingParts.begin()), matchingParts.end(), CompareMatchingParts());
     const MatchingPart& mostSignificantPart = matchingParts.front();
     return mostSignificantPart.part;
   }
 
   // Not found.
   return LayoutPart::Pointer(nullptr);
 }
 
 LayoutPart::Pointer PerspectiveHelper::FindPart(const QString& id,
     const QList<LayoutPart::Pointer>& parts,
     QList<MatchingPart>& matchingParts)
 {
   for (QList<LayoutPart::Pointer>::const_iterator iter = parts.begin();
       iter != parts.end(); ++iter)
   {
     LayoutPart::Pointer part = *iter;
     // check for part equality, parts with secondary ids fail
     if (part->GetID() == id)
     {
       if (part.Cast<PartPane> () != 0)
       {
         PartPane::Pointer pane = part.Cast<PartPane>();
         IViewReference::Pointer ref = pane->GetPartReference().Cast<IViewReference>();
         if (ref->GetSecondaryId() != "")
         {
           continue;
         }
       }
       return part;
     }
     // check pattern matching placeholders
 
     else if (part->IsPlaceHolder()
              && part.Cast<PartPlaceholder>()->HasWildCard())
     {
-      QRegExp re(id, Qt::CaseInsensitive);
-      if (re.exactMatch(part->GetID()))
+      QRegularExpression re(QString("^%1$").arg(id), QRegularExpression::CaseInsensitiveOption);
+      if (re.match(part->GetID()).hasMatch())
       {
         matchingParts.push_back(MatchingPart(part->GetID(), "", part));
       }
       //      StringMatcher sm = new StringMatcher(part.getID(), true, false);
       //      if (sm.match(id))
       //      {
       //        matchingParts .add(new MatchingPart(part.getID(), 0, part));
       //      }
     }
     else if (ILayoutContainer::Pointer layoutContainer = part.Cast<ILayoutContainer>())
     {
       part = FindPart(id, layoutContainer->GetChildren(),
                       matchingParts);
       if (part)
       {
         return part;
       }
     }
   }
 
   //BERRY_INFO << "Returning 0\n";
   return LayoutPart::Pointer(nullptr);
 }
 
 LayoutPart::Pointer PerspectiveHelper::FindPart(const QString& primaryId,
     const QString& secondaryId,
     const QList<LayoutPart::Pointer>& parts,
     QList<MatchingPart>& matchingParts)
 {
   for (QList<LayoutPart::Pointer>::const_iterator iter = parts.begin();
       iter != parts.end(); ++iter)
   {
     LayoutPart::Pointer part = *iter;
     // check containers first
     if (ILayoutContainer::Pointer layoutContainer = part.Cast<ILayoutContainer>())
     {
       LayoutPart::Pointer testPart = FindPart(primaryId, secondaryId,
                                               layoutContainer->GetChildren(), matchingParts);
       if (testPart)
       {
         return testPart;
       }
     }
     // check for view part equality
     if (part.Cast<PartPane> () != 0)
     {
       PartPane::Pointer pane = part.Cast<PartPane>();
       IViewReference::Pointer ref = pane->GetPartReference().Cast<IViewReference>();
       if (ref->GetId() == primaryId && ref->GetSecondaryId() == secondaryId)
       {
         return part;
       }
     }
     // check placeholders
 
     else if (part.Cast<PartPlaceholder> () != 0)
     {
       QString id = part->GetID();
 
       // optimization: don't bother parsing id if it has no separator -- it can't match
       QString phSecondaryId = ViewFactory::ExtractSecondaryId(id);
       if (phSecondaryId == "")
       {
         // but still need to check for wildcard case
         if (id == PartPlaceholder::WILD_CARD)
         {
           matchingParts.push_back(MatchingPart(id, "", part));
         }
         continue;
       }
 
       QString phPrimaryId = ViewFactory::ExtractPrimaryId(id);
       // perfect matching pair
       if (phPrimaryId == primaryId && phSecondaryId == secondaryId)
       {
         return part;
       }
       // check for partial matching pair
-      QRegExp pre(phPrimaryId, Qt::CaseInsensitive);
-      if (pre.exactMatch(primaryId))
+      QRegularExpression pre(QString("^%1$").arg(phPrimaryId), QRegularExpression::CaseInsensitiveOption);
+      if (pre.match(primaryId).hasMatch())
       {
-        QRegExp sre(phSecondaryId, Qt::CaseInsensitive);
-        if (sre.exactMatch(secondaryId))
+        QRegularExpression sre(QString("^%1$").arg(phSecondaryId), QRegularExpression::CaseInsensitiveOption);
+        if (sre.match(secondaryId).hasMatch())
         {
           matchingParts.push_back(MatchingPart(phPrimaryId, phSecondaryId, part));
         }
       }
     }
   }
   return LayoutPart::Pointer(nullptr);
 }
 
 bool PerspectiveHelper::HasPlaceholder(const QString& id)
 {
   return this->HasPlaceholder(id, nullptr);
 }
 
 bool PerspectiveHelper::HasPlaceholder(const QString& primaryId,
     const QString& secondaryId)
 {
   LayoutPart::Pointer testPart;
   if (secondaryId == "")
   {
     testPart = this->FindPart(primaryId);
   }
   else
   {
     testPart = this->FindPart(primaryId, secondaryId);
   }
   return (testPart != 0 && testPart.Cast<PartPlaceholder> () != 0);
 }
 
 PartSashContainer::Pointer PerspectiveHelper::GetLayout() const
 {
   return mainLayout;
 }
 
 bool PerspectiveHelper::IsActive()
 {
   return active;
 }
 
 float PerspectiveHelper::GetDockingRatio(LayoutPart::Pointer source,
     LayoutPart::Pointer target)
 {
   if ((source.Cast<PartPane> () != 0 || source.Cast<PartStack> () != 0)
       && target.Cast<EditorSashContainer> () != 0)
   {
     return 0.25f;
   }
   return 0.5f;
 }
 
 void PerspectiveHelper::RemovePart(LayoutPart::Pointer part)
 {
 
   // Reparent the part back to the main window
   QWidget* parent = mainLayout->GetParent();
   part->Reparent(parent);
 
   // Replace part with a placeholder
   ILayoutContainer::Pointer container = part->GetContainer();
   if (container != 0)
   {
     QString placeHolderId = part->GetPlaceHolderId();
     container->Replace(part, LayoutPart::Pointer(new PartPlaceholder(placeHolderId)));
 
 //    // If the parent is root we're done. Do not try to replace
 //    // it with placeholder.
 //    if (container == mainLayout)
 //    {
 //      return;
 //    }
 
     // If the parent is empty replace it with a placeholder.
     QList<LayoutPart::Pointer> children = container->GetChildren();
 
     bool allInvisible = true;
     for (QList<LayoutPart::Pointer>::iterator childIter = children.begin();
         childIter != children.end(); ++childIter)
     {
       if (childIter->Cast<PartPlaceholder> () == 0)
       {
         allInvisible = false;
         break;
       }
     }
     if (allInvisible && (container.Cast<LayoutPart> () != 0))
     {
       // what type of window are we in?
       LayoutPart::Pointer cPart = container.Cast<LayoutPart>();
       //Window oldWindow = cPart.getWindow();
       bool wasDocked = cPart->IsDocked();
       Shell::Pointer oldShell = cPart->GetShell();
       if (wasDocked)
       {
 
         // PR 1GDFVBY: ViewStack not disposed when page
         // closed.
         if (container.Cast<PartStack> () != 0)
         {
           container.Cast<PartStack>()->Dispose();
         }
 
         // replace the real container with a
         // ContainerPlaceholder
         ILayoutContainer::Pointer parentContainer = cPart->GetContainer();
         ContainerPlaceholder::Pointer placeholder(
         new ContainerPlaceholder(cPart->GetID()));
         placeholder->SetRealContainer(container);
         parentContainer->Replace(cPart, placeholder);
 
       }
       else
       {
         DetachedPlaceHolder::Pointer placeholder(
         new DetachedPlaceHolder("", oldShell->GetBounds())); //$NON-NLS-1$
         for (QList<LayoutPart::Pointer>::iterator childIter2 = children.begin();
             childIter2 != children.end(); ++childIter2)
         {
           (*childIter2)->GetContainer()->Remove(*childIter2);
           (*childIter2)->SetContainer(placeholder);
           placeholder->Add(*childIter2);
         }
         detachedPlaceHolderList.push_back(placeholder);
         DetachedWindow::Pointer w = oldShell->GetData().Cast<DetachedWindow>();
         oldShell->Close();
         detachedWindowList.removeAll(w);
       }
 
     }
   }
 }
 
 void PerspectiveHelper::ReplacePlaceholderWithPart(LayoutPart::Pointer part)
 {
 
   // Look for a PartPlaceholder that will tell us how to position this
   // object
   QList<PartPlaceholder::Pointer> placeholders = this->CollectPlaceholders();
   for (int i = 0; i < placeholders.size(); i++)
   {
     if (placeholders[i]->GetID() == part->GetID())
     {
       // found a matching placeholder which we can replace with the
       // new View
       ILayoutContainer::Pointer container = placeholders[i]->GetContainer();
       if (container != 0)
       {
         if (ContainerPlaceholder::Pointer containerPlaceholder = container.Cast<ContainerPlaceholder> ())
         {
           // One of the children is now visible so replace the
           // ContainerPlaceholder with the real container
           ILayoutContainer::Pointer parentContainer =
               containerPlaceholder->GetContainer();
           container = containerPlaceholder->GetRealContainer().Cast<ILayoutContainer>();
           if (LayoutPart::Pointer layoutPart = container.Cast<LayoutPart> ())
           {
             parentContainer->Replace(containerPlaceholder, layoutPart);
           }
           containerPlaceholder->SetRealContainer(ILayoutContainer::Pointer(nullptr));
         }
         container->Replace(placeholders[i], part);
         return;
       }
     }
   }
 }
 
 bool PerspectiveHelper::RestoreState(IMemento::Pointer memento)
 {
   // Restore main window.
   IMemento::Pointer childMem = memento->GetChild(WorkbenchConstants::TAG_MAIN_WINDOW);
   //IStatus r = mainLayout->RestoreState(childMem);
   bool r = mainLayout->RestoreState(childMem);
 
   // Restore each floating window.
   if (detachable)
   {
     QList<IMemento::Pointer> detachedWindows(memento->GetChildren(
         WorkbenchConstants::TAG_DETACHED_WINDOW));
     for (QList<IMemento::Pointer>::iterator iter = detachedWindows.begin();
         iter != detachedWindows.end(); ++iter)
     {
       DetachedWindow::Pointer win(new DetachedWindow(page));
       detachedWindowList.push_back(win);
       win->RestoreState(*iter);
     }
 
     QList<IMemento::Pointer> childrenMem(memento->GetChildren(
         WorkbenchConstants::TAG_HIDDEN_WINDOW));
     for (QList<IMemento::Pointer>::iterator iter = childrenMem.begin();
         iter != childrenMem.end(); ++iter)
     {
       DetachedPlaceHolder::Pointer holder(
           new DetachedPlaceHolder("", QRect(0, 0, 0, 0)));
       holder->RestoreState(*iter);
       detachedPlaceHolderList.push_back(holder);
     }
   }
 
   // Get the cached id of the currently maximized stack
   //maximizedStackId = childMem.getString(IWorkbenchConstants.TAG_MAXIMIZED);
 
   return r;
 }
 
 bool PerspectiveHelper::SaveState(IMemento::Pointer memento)
 {
   // Persist main window.
   IMemento::Pointer childMem = memento->CreateChild(WorkbenchConstants::TAG_MAIN_WINDOW);
   //IStatus r = mainLayout->SaveState(childMem);
   bool r = mainLayout->SaveState(childMem);
 
   if (detachable)
   {
     // Persist each detached window.
     for (DetachedWindowsType::iterator iter = detachedWindowList.begin();
         iter != detachedWindowList.end(); ++iter)
     {
       childMem = memento->CreateChild(WorkbenchConstants::TAG_DETACHED_WINDOW);
       (*iter)->SaveState(childMem);
     }
     for (DetachedPlaceHoldersType::iterator iter = detachedPlaceHolderList.begin();
         iter != detachedPlaceHolderList.end(); ++iter)
     {
       childMem = memento->CreateChild(WorkbenchConstants::TAG_HIDDEN_WINDOW);
       (*iter)->SaveState(childMem);
     }
   }
 
   // Write out the id of the maximized (View) stack (if any)
   // NOTE: we only write this out if it's a ViewStack since the
   // Editor Area is handled by the perspective
 //  if (maximizedStack.Cast<PartStack> () != 0)
 //  {
 //    childMem.putString(IWorkbenchConstants.TAG_MAXIMIZED,
 //        maximizedStack.getID());
 //  }
 //  else if (maximizedStackId != 0)
 //  {
 //    // Maintain the cache if the perspective has never been activated
 //    childMem.putString(IWorkbenchConstants.TAG_MAXIMIZED, maximizedStackId);
 //  }
 
   return r;
 }
 
 void PerspectiveHelper::UpdateBoundsMap()
 {
   boundsMap.clear();
 
   // Walk the layout gathering the current bounds of each stack
   // and the editor area
   QList<LayoutPart::Pointer> kids = mainLayout->GetChildren();
   for (QList<LayoutPart::Pointer>::iterator iter = kids.begin();
       iter != kids.end(); ++iter)
   {
     if (iter->Cast<PartStack> () != 0)
     {
       PartStack::Pointer vs = iter->Cast<PartStack>();
       boundsMap.insert(vs->GetID(), vs->GetBounds());
     }
     else if (iter->Cast<EditorSashContainer> () != 0)
     {
       EditorSashContainer::Pointer esc = iter->Cast<EditorSashContainer>();
       boundsMap.insert(esc->GetID(), esc->GetBounds());
     }
   }
 }
 
 void PerspectiveHelper::ResetBoundsMap()
 {
   boundsMap.clear();
 }
 
 QRect PerspectiveHelper::GetCachedBoundsFor(const QString& id)
 {
   return boundsMap[id];
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp
index bf38e33d11..04a00c6a33 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp
@@ -1,328 +1,328 @@
 /*============================================================================
 
 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 "berryQtShowViewDialog.h"
 
 #include <berryIViewDescriptor.h>
 
 #include <berryViewTreeModel.h>
 
 #include "berryWorkbenchPlugin.h"
 #include "berryXMLMemento.h"
 
 #include <QSortFilterProxyModel>
 #include <QPushButton>
 
 #include <mitkIPreferences.h>
 
 namespace berry {
 
 static const QString TAG_SHOWVIEWDIALOG = "ShowViewDialog";
 static const QString TAG_CATEGORY = "category";
 static const QString TAG_SELECTION = "selection";
 static const QString TAG_GEOMETRY = "geometry";
 
 class ViewFilterProxyModel : public QSortFilterProxyModel
 {
 public:
   ViewFilterProxyModel(QObject* parent = nullptr)
     : QSortFilterProxyModel(parent)
     , m_FilterOnKeywords(true)
   {
     this->setFilterCaseSensitivity(Qt::CaseInsensitive);
   }
 
   bool filterOnKeywords() const
   {
     return m_FilterOnKeywords;
   }
 
   void setFilterOnKeywords(bool filterOnKeywords)
   {
     if (m_FilterOnKeywords != filterOnKeywords)
     {
       m_FilterOnKeywords = filterOnKeywords;
       this->filterChanged();
     }
   }
 
 protected:
 
   bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const override
   {
-    QRegExp regExp = filterRegExp();
-    if (!regExp.isValid() || regExp.isEmpty()) return true;
+    QRegularExpression regExp = filterRegularExpression();
+    if (!regExp.isValid() || regExp.pattern().isEmpty()) return true;
 
     QModelIndex sourceIndex = sourceModel()->index(sourceRow, 0, sourceParent);
     QStringList keywords;
 
     if (m_FilterOnKeywords)
     {
       keywords = sourceModel()->data(sourceIndex, ViewTreeModel::Keywords).toStringList();
     }
     else
     {
       if (sourceModel()->hasChildren(sourceIndex))
       {
         // this is a category item
         int numChildren = sourceModel()->rowCount(sourceIndex);
         for (int i = 0; i < numChildren; ++i)
         {
           keywords.push_back(sourceModel()->data(sourceIndex.child(i, 0)).toString());
         }
       }
       else
       {
         // this is a view item
         keywords.push_back(sourceModel()->data(sourceIndex).toString());
       }
     }
 
     for(auto& keyword : keywords)
     {
       if (keyword.contains(regExp)) return true;
     }
     return false;
   }
 
 private:
 
   bool m_FilterOnKeywords;
 };
 
 QtShowViewDialog::QtShowViewDialog(const IWorkbenchWindow* window, IViewRegistry* registry,
                                    QWidget* parent, Qt::WindowFlags f)
   : QDialog(parent, f)
   , m_Window(window)
   , m_ViewReg(registry)
   , m_FilterModel(nullptr)
 {
   m_UserInterface.setupUi(this);
   m_UserInterface.m_TreeView->header()->setVisible(false);
   m_UserInterface.m_TreeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
   m_FilterModel = new ViewFilterProxyModel(this);
   auto   sourceModel = new ViewTreeModel(window, m_FilterModel);
   m_FilterModel->setSourceModel(sourceModel);
   m_UserInterface.m_TreeView->setModel(m_FilterModel);
 
   connect(m_UserInterface.m_Filter, SIGNAL(textChanged(QString)), this, SLOT(setFilter(QString)));
   connect(m_UserInterface.m_TreeView, SIGNAL(clicked(QModelIndex)), this, SLOT(setDescription(QModelIndex)));
   connect(m_UserInterface.m_TreeView, SIGNAL(collapsed(QModelIndex)), this, SLOT(categoryCollapsed(QModelIndex)));
   connect(m_UserInterface.m_TreeView, SIGNAL(expanded(QModelIndex)), this, SLOT(categoryExpanded(QModelIndex)));
   connect(m_UserInterface.m_TreeView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(accept()));
   connect(m_UserInterface.m_TreeView, SIGNAL(activated(QModelIndex)), this, SLOT(accept()));
   connect(m_UserInterface.m_TreeView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), this, SLOT(selectionChanged(QItemSelection,QItemSelection)));
   connect(m_UserInterface.m_KeywordFilter, SIGNAL(clicked(bool)), this, SLOT(enableKeywordFilter(bool)));
 
   this->RestoreState();
   m_UserInterface.m_Filter->selectAll();
   this->UpdateButtons();
 }
 
 void QtShowViewDialog::setDescription(const QModelIndex& index)
 {
   QString description = m_UserInterface.m_TreeView->model()->data(index, Qt::WhatsThisRole).toString();
   m_UserInterface.m_Description->setText(description);
 }
 
 void QtShowViewDialog::enableKeywordFilter(bool enable)
 {
   m_FilterModel->setFilterOnKeywords(enable);
   this->RestoreExpandedState();
 }
 
 void QtShowViewDialog::setFilter(const QString& filter)
 {
   m_FilterModel->setFilterWildcard(filter);
   this->RestoreExpandedState();
 }
 
 void QtShowViewDialog::categoryCollapsed(const QModelIndex& index)
 {
   m_ExpandedCategories.removeAll(m_FilterModel->mapToSource(index));
 }
 
 void QtShowViewDialog::categoryExpanded(const QModelIndex& index)
 {
   m_ExpandedCategories.push_back(m_FilterModel->mapToSource(index));
 }
 
 void QtShowViewDialog::selectionChanged(const QItemSelection& /*selected*/, const QItemSelection& /*deselected*/)
 {
   UpdateButtons();
 }
 
 void QtShowViewDialog::RestoreExpandedState()
 {
   int rowCount = m_FilterModel->rowCount();
   for (int i = 0; i < rowCount; ++i)
   {
     QModelIndex index = m_FilterModel->index(i, 0);
     if (m_ExpandedCategories.contains(m_FilterModel->mapToSource(index)))
     {
       m_UserInterface.m_TreeView->expand(index);
     }
   }
 }
 
 void QtShowViewDialog::UpdateButtons()
 {
   QPushButton* okBtn = m_UserInterface.m_ButtonBox->button(QDialogButtonBox::Ok);
   if (okBtn)
   {
     okBtn->setEnabled(!m_UserInterface.m_TreeView->selectionModel()->selection().isEmpty());
   }
 }
 
 void QtShowViewDialog::RestoreState()
 {
   auto* prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
   auto str = QString::fromStdString(prefs->Get(TAG_SHOWVIEWDIALOG.toStdString(), ""));
   if (str.isEmpty()) return;
 
   std::stringstream ss(str.toStdString());
 
   XMLMemento::Pointer memento = XMLMemento::CreateReadRoot(ss);
 
   bool keywordFilter = false;
   if (memento->GetBoolean("keywordFilter", keywordFilter))
   {
     m_UserInterface.m_KeywordFilter->setChecked(keywordFilter);
     m_FilterModel->setFilterOnKeywords(keywordFilter);
   }
 
   QString filter;
   if (memento->GetString("filter", filter))
   {
     m_UserInterface.m_Filter->setText(filter);
   }
 
   IMemento::Pointer geomChild = memento->GetChild(TAG_GEOMETRY);
   if (geomChild.IsNotNull())
   {
     QString geom = geomChild->GetTextData();
     if (!geom.isEmpty())
     {
       QByteArray ba = QByteArray::fromBase64(geom.toLatin1());
       this->restoreGeometry(ba);
     }
   }
 
   QHash<QString, QModelIndex> rootIndices;
   int rowCount = m_FilterModel->sourceModel()->rowCount();
   for (int i = 0; i < rowCount; ++i)
   {
     QModelIndex sourceIndex = m_FilterModel->sourceModel()->index(i, 0);
     QString id = sourceIndex.data(ViewTreeModel::Id).toString();
     if (!id.isEmpty())
     {
       rootIndices[id] = sourceIndex;
     }
   }
   for (const IMemento::Pointer &categoryChild : memento->GetChildren(TAG_CATEGORY))
   {
     QString id = categoryChild->GetID();
     if (!id.isEmpty())
     {
       if (rootIndices.contains(id))
       {
         m_ExpandedCategories.push_back(rootIndices[id]);
       }
     }
   }
   this->RestoreExpandedState();
 
   QItemSelection itemSelection;
   for (const IMemento::Pointer &selectionChild : memento->GetChildren(TAG_SELECTION))
   {
     QString id = selectionChild->GetID();
     if (!id.isEmpty())
     {
       QModelIndexList indexList = m_FilterModel->match(m_FilterModel->index(0, 0), ViewTreeModel::Id, QVariant::fromValue(id),
                                                        1, Qt::MatchExactly | Qt::MatchRecursive);
       if (!indexList.isEmpty())
       {
         QItemSelection subSelection(indexList.front(), indexList.front());
         itemSelection.merge(subSelection, QItemSelectionModel::SelectCurrent);
       }
     }
   }
   m_UserInterface.m_TreeView->selectionModel()->select(itemSelection, QItemSelectionModel::ClearAndSelect);
 }
 
 void QtShowViewDialog::SaveState()
 {
   XMLMemento::Pointer memento = XMLMemento::CreateWriteRoot(TAG_SHOWVIEWDIALOG);
   memento->PutString("filter", m_UserInterface.m_Filter->text());
   memento->PutBoolean("keywordFilter", m_UserInterface.m_KeywordFilter->isChecked());
 
   // dialog geometry
   QByteArray geom = this->saveGeometry();
   IMemento::Pointer geomChild = memento->CreateChild(TAG_GEOMETRY);
   geomChild->PutTextData(geom.toBase64().constData());
 
   // expanded categories
   for (const QPersistentModelIndex &index : qAsConst(m_ExpandedCategories))
   {
     if (index.isValid())
     {
       QString id = index.data(ViewTreeModel::Id).toString();
       if (!id.isEmpty())
       {
         memento->CreateChild(TAG_CATEGORY, id);
       }
     }
   }
 
   // we only record a single selected item. restoring a multi-selection might be
   // confusing for the user
   QModelIndexList selectedIndices = m_UserInterface.m_TreeView->selectionModel()->selectedIndexes();
   if (!selectedIndices.isEmpty())
   {
     QString id = selectedIndices.back().data(ViewTreeModel::Id).toString();
     if (!id.isEmpty())
     {
       memento->CreateChild(TAG_SELECTION, id);
     }
   }
 
   std::stringstream ss;
   memento->Save(ss);
 
   auto* prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
   prefs->Put(TAG_SHOWVIEWDIALOG.toStdString(), ss.str());
   prefs->Flush();
 }
 
 void QtShowViewDialog::done(int r)
 {
   this->SaveState();
   QDialog::done(r);
 }
 
 QList<QString>
 QtShowViewDialog::GetSelection() const
 {
   QList<QString> selected;
 
   QModelIndexList indices = m_UserInterface.m_TreeView->selectionModel()->selectedIndexes();
   for(QModelIndex index : qAsConst(indices))
   {
     QString id = m_FilterModel->data(index, ViewTreeModel::Id).toString();
     selected.push_back(id);
   }
 
   return selected;
 }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
index b6f5c20ae0..d9020f909b 100644
--- a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
+++ b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
@@ -1,1444 +1,1444 @@
 /*============================================================================
 
 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 "QmitkExtWorkbenchWindowAdvisor.h"
 #include "QmitkExtActionBarAdvisor.h"
 
 #include <QMenu>
 #include <QMenuBar>
 #include <QMainWindow>
 #include <QStatusBar>
 #include <QString>
 #include <QFile>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QTextStream>
 #include <QSettings>
 
 #include <ctkPluginException.h>
 #include <service/event/ctkEventAdmin.h>
 
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIActionBarConfigurer.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryIPerspectiveDescriptor.h>
 #include <berryIProduct.h>
 #include <berryIWorkbenchPartConstants.h>
 #include <berryQtPreferences.h>
 #include <berryQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 
 #include <internal/berryQtShowViewAction.h>
 #include <internal/berryQtOpenPerspectiveAction.h>
 
 #include <QmitkFileOpenAction.h>
 #include <QmitkFileSaveAction.h>
 #include <QmitkExtFileSaveProjectAction.h>
 #include <QmitkFileExitAction.h>
 #include <QmitkCloseProjectAction.h>
 #include <QmitkUndoAction.h>
 #include <QmitkRedoAction.h>
 #include <QmitkDefaultDropTargetListener.h>
 #include <QmitkStatusBar.h>
 #include <QmitkProgressBar.h>
 #include <QmitkMemoryUsageIndicatorView.h>
 #include <QmitkPreferencesDialog.h>
 #include <QmitkOpenDicomEditorAction.h>
 #include <QmitkOpenMxNMultiWidgetEditorAction.h>
 #include <QmitkOpenStdMultiWidgetEditorAction.h>
 
 #include <itkConfigure.h>
 #include <mitkVersion.h>
 #include <mitkIDataStorageService.h>
 #include <mitkIDataStorageReference.h>
 #include <mitkDataStorageEditorInput.h>
 #include <mitkWorkbenchUtil.h>
 #include <mitkCoreServices.h>
 #include <mitkIPreferencesService.h>
 #include <mitkIPreferences.h>
 #include <vtkVersionMacros.h>
 
 // UGLYYY
 #include "internal/QmitkExtWorkbenchWindowAdvisorHack.h"
 #include "internal/QmitkCommonExtPlugin.h"
 #include "mitkUndoController.h"
 #include "mitkVerboseLimitedLinearUndo.h"
 #include <QToolBar>
 #include <QToolButton>
 #include <QMessageBox>
 #include <QMouseEvent>
 #include <QLabel>
 #include <QmitkAboutDialog.h>
 
 QmitkExtWorkbenchWindowAdvisorHack* QmitkExtWorkbenchWindowAdvisorHack::undohack =
   new QmitkExtWorkbenchWindowAdvisorHack();
 
 QString QmitkExtWorkbenchWindowAdvisor::QT_SETTINGS_FILENAME = "QtSettings.ini";
 
 static bool USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS = false;
 
 class PartListenerForTitle: public berry::IPartListener
 {
 public:
 
   PartListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
   {
   }
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::ACTIVATED | Events::BROUGHT_TO_TOP | Events::CLOSED
       | Events::HIDDEN | Events::VISIBLE;
   }
 
   void PartActivated(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref.Cast<berry::IEditorReference> ())
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
   void PartBroughtToTop(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref.Cast<berry::IEditorReference> ())
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& /*ref*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     auto lockedLastActiveEditor = windowAdvisor->lastActiveEditor.Lock();
 
     if (lockedLastActiveEditor.IsNotNull() && ref->GetPart(false) == lockedLastActiveEditor)
     {
       windowAdvisor->UpdateTitle(true);
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     auto lockedLastActiveEditor = windowAdvisor->lastActiveEditor.Lock();
 
     if (lockedLastActiveEditor.IsNotNull() && ref->GetPart(false) == lockedLastActiveEditor)
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
 private:
   QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
 };
 
 class PartListenerForViewNavigator: public berry::IPartListener
 {
 public:
 
   PartListenerForViewNavigator(QAction* act)
     : viewNavigatorAction(act)
   {
   }
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::OPENED | Events::CLOSED | Events::HIDDEN |
       Events::VISIBLE;
   }
 
   void PartOpened(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.viewnavigator")
     {
       viewNavigatorAction->setChecked(true);
     }
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.viewnavigator")
     {
       viewNavigatorAction->setChecked(false);
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.viewnavigator")
     {
       viewNavigatorAction->setChecked(true);
     }
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.viewnavigator")
     {
       viewNavigatorAction->setChecked(false);
     }
   }
 
 private:
   QAction* viewNavigatorAction;
 };
 
 class PartListenerForImageNavigator: public berry::IPartListener
 {
 public:
 
   PartListenerForImageNavigator(QAction* act)
     : imageNavigatorAction(act)
   {
   }
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::OPENED | Events::CLOSED | Events::HIDDEN |
       Events::VISIBLE;
   }
 
   void PartOpened(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(true);
     }
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(false);
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(true);
     }
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(false);
     }
   }
 
 private:
   QAction* imageNavigatorAction;
 };
 
 class PerspectiveListenerForTitle: public berry::IPerspectiveListener
 {
 public:
 
   PerspectiveListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
     , perspectivesClosed(false)
   {
   }
 
   Events::Types GetPerspectiveEventTypes() const override
   {
     if (USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS)
     {
       return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED;
     }
     else
     {
       return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED
         | Events::CLOSED | Events::OPENED;
     }
   }
 
   void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveSavedAs(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*oldPerspective*/,
     const berry::IPerspectiveDescriptor::Pointer& /*newPerspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveOpened(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     if (perspectivesClosed)
     {
       QListIterator<QAction*> i(windowAdvisor->viewActions);
       while (i.hasNext())
       {
         i.next()->setEnabled(true);
       }
 
       //GetViewRegistry()->Find("org.mitk.views.imagenavigator");
       if(windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
       {
         windowAdvisor->openDicomEditorAction->setEnabled(true);
       }
       if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
       {
         windowAdvisor->openStdMultiWidgetEditorAction->setEnabled(true);
       }
       if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
       {
         windowAdvisor->openMxNMultiWidgetEditorAction->setEnabled(true);
       }
 
       windowAdvisor->fileSaveProjectAction->setEnabled(true);
       windowAdvisor->closeProjectAction->setEnabled(true);
       windowAdvisor->undoAction->setEnabled(true);
       windowAdvisor->redoAction->setEnabled(true);
       windowAdvisor->imageNavigatorAction->setEnabled(true);
       windowAdvisor->viewNavigatorAction->setEnabled(true);
       windowAdvisor->resetPerspAction->setEnabled(true);
       if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
       {
         windowAdvisor->closePerspAction->setEnabled(true);
       }
     }
 
     perspectivesClosed = false;
   }
 
   void PerspectiveClosed(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     berry::IWorkbenchWindow::Pointer wnd = windowAdvisor->GetWindowConfigurer()->GetWindow();
     bool allClosed = true;
     if (wnd->GetActivePage())
     {
       QList<berry::IPerspectiveDescriptor::Pointer> perspectives(wnd->GetActivePage()->GetOpenPerspectives());
       allClosed = perspectives.empty();
     }
 
     if (allClosed)
     {
       perspectivesClosed = true;
 
       QListIterator<QAction*> i(windowAdvisor->viewActions);
       while (i.hasNext())
       {
         i.next()->setEnabled(false);
       }
 
       if(windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
       {
         windowAdvisor->openDicomEditorAction->setEnabled(false);
       }
       if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
       {
         windowAdvisor->openStdMultiWidgetEditorAction->setEnabled(false);
       }
       if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
       {
         windowAdvisor->openMxNMultiWidgetEditorAction->setEnabled(false);
       }
 
       windowAdvisor->fileSaveProjectAction->setEnabled(false);
       windowAdvisor->closeProjectAction->setEnabled(false);
       windowAdvisor->undoAction->setEnabled(false);
       windowAdvisor->redoAction->setEnabled(false);
       windowAdvisor->imageNavigatorAction->setEnabled(false);
       windowAdvisor->viewNavigatorAction->setEnabled(false);
       windowAdvisor->resetPerspAction->setEnabled(false);
       if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
       {
         windowAdvisor->closePerspAction->setEnabled(false);
       }
     }
   }
 
 private:
   QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
   bool perspectivesClosed;
 };
 
 class PerspectiveListenerForMenu: public berry::IPerspectiveListener
 {
 public:
 
   PerspectiveListenerForMenu(QmitkExtWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
   {
   }
 
   Events::Types GetPerspectiveEventTypes() const override
   {
     return Events::ACTIVATED | Events::DEACTIVATED;
   }
 
   void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& perspective) override
   {
     QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
     if (action)
     {
       action->setChecked(true);
     }
   }
 
   void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& perspective) override
   {
     QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
     if (action)
     {
       action->setChecked(false);
     }
   }
 
 private:
   QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
 };
 
 QmitkExtWorkbenchWindowAdvisor::QmitkExtWorkbenchWindowAdvisor(berry::WorkbenchAdvisor* wbAdvisor,
                                                                berry::IWorkbenchWindowConfigurer::Pointer configurer)
   : berry::WorkbenchWindowAdvisor(configurer)
   , lastInput(nullptr)
   , wbAdvisor(wbAdvisor)
   , showViewToolbar(true)
   , showPerspectiveToolbar(false)
   , showVersionInfo(true)
   , showMitkVersionInfo(true)
   , showViewMenuItem(true)
   , showNewWindowMenuItem(false)
   , showClosePerspectiveMenuItem(true)
   , viewNavigatorFound(false)
   , showMemoryIndicator(true)
   , dropTargetListener(new QmitkDefaultDropTargetListener)
 {
   productName = QCoreApplication::applicationName();
   viewExcludeList.push_back("org.mitk.views.viewnavigator");
 }
 
 QmitkExtWorkbenchWindowAdvisor::~QmitkExtWorkbenchWindowAdvisor()
 {
 }
 
 berry::ActionBarAdvisor::Pointer QmitkExtWorkbenchWindowAdvisor::CreateActionBarAdvisor(berry::IActionBarConfigurer::Pointer configurer)
 {
   if (USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS)
   {
     berry::ActionBarAdvisor::Pointer actionBarAdvisor(new QmitkExtActionBarAdvisor(configurer));
     return actionBarAdvisor;
   }
   else
   {
     return berry::WorkbenchWindowAdvisor::CreateActionBarAdvisor(configurer);
   }
 }
 
 QWidget* QmitkExtWorkbenchWindowAdvisor::CreateEmptyWindowContents(QWidget* parent)
 {
   QWidget* parentWidget = static_cast<QWidget*>(parent);
   auto   label = new QLabel(parentWidget);
   label->setText("<b>No perspectives are open. Open a perspective in the <i>Window->Open Perspective</i> menu.</b>");
   label->setContentsMargins(10,10,10,10);
   label->setAlignment(Qt::AlignTop);
   label->setEnabled(false);
   parentWidget->layout()->addWidget(label);
   return label;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowClosePerspectiveMenuItem(bool show)
 {
   showClosePerspectiveMenuItem = show;
 }
 
 bool QmitkExtWorkbenchWindowAdvisor::GetShowClosePerspectiveMenuItem()
 {
   return showClosePerspectiveMenuItem;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowMemoryIndicator(bool show)
 {
   showMemoryIndicator = show;
 }
 
 bool QmitkExtWorkbenchWindowAdvisor::GetShowMemoryIndicator()
 {
   return showMemoryIndicator;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowNewWindowMenuItem(bool show)
 {
   showNewWindowMenuItem = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowViewToolbar(bool show)
 {
   showViewToolbar = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowViewMenuItem(bool show)
 {
   showViewMenuItem = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowPerspectiveToolbar(bool show)
 {
   showPerspectiveToolbar = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowVersionInfo(bool show)
 {
   showVersionInfo = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowMitkVersionInfo(bool show)
 {
   showMitkVersionInfo = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetProductName(const QString& product)
 {
   productName = product;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetWindowIcon(const QString& wndIcon)
 {
   windowIcon = wndIcon;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
 {
   // very bad hack...
   berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
   QMainWindow* mainWindow = qobject_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   if (!windowIcon.isEmpty())
   {
     mainWindow->setWindowIcon(QIcon(windowIcon));
   }
   mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
 
   // Load icon theme
   QIcon::setThemeSearchPaths(QStringList() << QStringLiteral(":/org_mitk_icons/icons/"));
   QIcon::setThemeName(QStringLiteral("awesome"));
 
   // ==== Application menu ============================
 
   QMenuBar* menuBar = mainWindow->menuBar();
   menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
 
 #ifdef __APPLE__
   menuBar->setNativeMenuBar(true);
 #else
   menuBar->setNativeMenuBar(false);
 #endif
 
   auto basePath = QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/");
 
   auto fileOpenAction = new QmitkFileOpenAction(berry::QtStyleManager::ThemeIcon(basePath + "document-open.svg"), window);
   fileOpenAction->setShortcut(QKeySequence::Open);
   auto fileSaveAction = new QmitkFileSaveAction(berry::QtStyleManager::ThemeIcon(basePath + "document-save.svg"), window);
   fileSaveAction->setShortcut(QKeySequence::Save);
   fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
   fileSaveProjectAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "document-save.svg"));
   closeProjectAction = new QmitkCloseProjectAction(window);
   closeProjectAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "edit-delete.svg"));
 
   auto   perspGroup = new QActionGroup(menuBar);
   std::map<QString, berry::IViewDescriptor::Pointer> VDMap;
 
   // sort elements (converting vector to map...)
   QList<berry::IViewDescriptor::Pointer>::const_iterator iter;
 
   berry::IViewRegistry* viewRegistry =
     berry::PlatformUI::GetWorkbench()->GetViewRegistry();
   const QList<berry::IViewDescriptor::Pointer> viewDescriptors = viewRegistry->GetViews();
 
   bool skip = false;
   for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
   {
     // if viewExcludeList is set, it contains the id-strings of view, which
     // should not appear as an menu-entry in the menu
     if (viewExcludeList.size() > 0)
     {
       for (int i=0; i<viewExcludeList.size(); i++)
       {
         if (viewExcludeList.at(i) == (*iter)->GetId())
         {
           skip = true;
           break;
         }
       }
       if (skip)
       {
         skip = false;
         continue;
       }
     }
 
     if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
       continue;
     if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
       continue;
     if ((*iter)->GetId() == "org.mitk.views.viewnavigator")
       continue;
 
     std::pair<QString, berry::IViewDescriptor::Pointer> p((*iter)->GetLabel(), (*iter));
     VDMap.insert(p);
   }
 
   std::map<QString, berry::IViewDescriptor::Pointer>::const_iterator MapIter;
   for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
   {
     berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window, (*MapIter).second);
     viewActions.push_back(viewAction);
   }
 
   if (!USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS)
   {
     QMenu* fileMenu = menuBar->addMenu("&File");
     fileMenu->setObjectName("FileMenu");
     fileMenu->addAction(fileOpenAction);
     fileMenu->addAction(fileSaveAction);
     fileMenu->addAction(fileSaveProjectAction);
     fileMenu->addAction(closeProjectAction);
     fileMenu->addSeparator();
 
     QAction* fileExitAction = new QmitkFileExitAction(window);
     fileExitAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "system-log-out.svg"));
     fileExitAction->setShortcut(QKeySequence::Quit);
     fileExitAction->setObjectName("QmitkFileExitAction");
     fileMenu->addAction(fileExitAction);
 
     // another bad hack to get an edit/undo menu...
     QMenu* editMenu = menuBar->addMenu("&Edit");
     undoAction = editMenu->addAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-undo.svg"),
       "&Undo",
       QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
       QKeySequence("CTRL+Z"));
     undoAction->setToolTip("Undo the last action (not supported by all modules)");
     redoAction = editMenu->addAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-redo.svg"),
       "&Redo",
       QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
       QKeySequence("CTRL+Y"));
     redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
 
     // ==== Window Menu ==========================
     QMenu* windowMenu = menuBar->addMenu("Window");
     if (showNewWindowMenuItem)
     {
       windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
       windowMenu->addSeparator();
     }
 
     QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
 
     QMenu* viewMenu = nullptr;
     if (showViewMenuItem)
     {
       viewMenu = windowMenu->addMenu("Show &View");
       viewMenu->setObjectName("Show View");
     }
     windowMenu->addSeparator();
     resetPerspAction = windowMenu->addAction("&Reset Perspective",
       QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
 
     if(showClosePerspectiveMenuItem)
       closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
 
     windowMenu->addSeparator();
     windowMenu->addAction("&Preferences...",
       QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
       QKeySequence("CTRL+P"));
 
     // fill perspective menu
     berry::IPerspectiveRegistry* perspRegistry =
       window->GetWorkbench()->GetPerspectiveRegistry();
 
     QList<berry::IPerspectiveDescriptor::Pointer> perspectives(
       perspRegistry->GetPerspectives());
 
     skip = false;
     for (QList<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
       perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
     {
       // if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
       // should not appear as an menu-entry in the perspective menu
       if (perspectiveExcludeList.size() > 0)
       {
         for (int i=0; i<perspectiveExcludeList.size(); i++)
         {
           if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
           {
             skip = true;
             break;
           }
         }
         if (skip)
         {
           skip = false;
           continue;
         }
       }
 
       QAction* perspAction = new berry::QtOpenPerspectiveAction(window, *perspIt, perspGroup);
       mapPerspIdToAction.insert((*perspIt)->GetId(), perspAction);
     }
     perspMenu->addActions(perspGroup->actions());
 
     if (showViewMenuItem)
     {
       for (auto viewAction : qAsConst(viewActions))
       {
         viewMenu->addAction(viewAction);
       }
     }
 
     // ===== Help menu ====================================
     QMenu* helpMenu = menuBar->addMenu("&Help");
     helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
     helpMenu->addAction("&Open Help Perspective", this, SLOT(onHelpOpenHelpPerspective()));
     helpMenu->addAction("&Context Help",this, SLOT(onHelp()),  QKeySequence("F1"));
     helpMenu->addAction("&About",this, SLOT(onAbout()));
     // =====================================================
   }
   else
   {
     undoAction = new QmitkUndoAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-undo.svg"), nullptr);
     undoAction->setShortcut(QKeySequence::Undo);
     redoAction = new QmitkRedoAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-redo.svg"), nullptr);
     redoAction->setShortcut(QKeySequence::Redo);
   }
 
   // toolbar for showing file open, undo, redo and other main actions
   auto   mainActionsToolBar = new QToolBar;
   mainActionsToolBar->setObjectName("mainActionsToolBar");
   mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
 #ifdef __APPLE__
   mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
 #else
   mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
 #endif
 
   basePath = QStringLiteral(":/org.mitk.gui.qt.ext/");
   imageNavigatorAction = new QAction(berry::QtStyleManager::ThemeIcon(basePath + "image_navigator.svg"), "&Image Navigator", nullptr);
   bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
 
   if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
   {
     openDicomEditorAction = new QmitkOpenDicomEditorAction(berry::QtStyleManager::ThemeIcon(basePath + "dicom.svg"), window);
   }
   if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
   {
     openStdMultiWidgetEditorAction = new QmitkOpenStdMultiWidgetEditorAction(berry::QtStyleManager::ThemeIcon(basePath + "Editor.svg"), window);
   }
   if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
   {
     openMxNMultiWidgetEditorAction = new QmitkOpenMxNMultiWidgetEditorAction(berry::QtStyleManager::ThemeIcon(basePath + "Editor.svg"), window);
   }
 
   if (imageNavigatorViewFound)
   {
     QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
     imageNavigatorAction->setCheckable(true);
 
     // add part listener for image navigator
     imageNavigatorPartListener.reset(new PartListenerForImageNavigator(imageNavigatorAction));
     window->GetPartService()->AddPartListener(imageNavigatorPartListener.data());
     berry::IViewPart::Pointer imageNavigatorView = window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
     imageNavigatorAction->setChecked(false);
     if (imageNavigatorView)
     {
       bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
       if (isImageNavigatorVisible)
         imageNavigatorAction->setChecked(true);
     }
     imageNavigatorAction->setToolTip("Toggle image navigator for navigating through image");
   }
 
   viewNavigatorAction = new QAction(berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org.mitk.gui.qt.ext/view-manager.svg")),"&View Navigator", nullptr);
   viewNavigatorFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.viewnavigator");
   if (viewNavigatorFound)
   {
     QObject::connect(viewNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onViewNavigator()));
     viewNavigatorAction->setCheckable(true);
 
     // add part listener for view navigator
     viewNavigatorPartListener.reset(new PartListenerForViewNavigator(viewNavigatorAction));
     window->GetPartService()->AddPartListener(viewNavigatorPartListener.data());
     berry::IViewPart::Pointer viewnavigatorview = window->GetActivePage()->FindView("org.mitk.views.viewnavigator");
     viewNavigatorAction->setChecked(false);
     if (viewnavigatorview)
     {
       bool isViewNavigatorVisible = window->GetActivePage()->IsPartVisible(viewnavigatorview);
       if (isViewNavigatorVisible)
         viewNavigatorAction->setChecked(true);
     }
     viewNavigatorAction->setToolTip("Toggle View Navigator");
   }
 
   mainActionsToolBar->addAction(fileOpenAction);
   mainActionsToolBar->addAction(fileSaveProjectAction);
   mainActionsToolBar->addAction(closeProjectAction);
   mainActionsToolBar->addAction(undoAction);
   mainActionsToolBar->addAction(redoAction);
   if(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
   {
     mainActionsToolBar->addAction(openDicomEditorAction);
   }
   if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
   {
     mainActionsToolBar->addAction(openStdMultiWidgetEditorAction);
   }
   if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
   {
     mainActionsToolBar->addAction(openMxNMultiWidgetEditorAction);
   }
 
   if (imageNavigatorViewFound)
   {
     mainActionsToolBar->addAction(imageNavigatorAction);
   }
   if (viewNavigatorFound)
   {
     mainActionsToolBar->addAction(viewNavigatorAction);
   }
   mainWindow->addToolBar(mainActionsToolBar);
 
   // ==== Perspective Toolbar ==================================
   auto   qPerspectiveToolbar = new QToolBar;
   qPerspectiveToolbar->setObjectName("perspectiveToolBar");
 
   if (showPerspectiveToolbar)
   {
     qPerspectiveToolbar->addActions(perspGroup->actions());
     mainWindow->addToolBar(qPerspectiveToolbar);
   }
   else
     delete qPerspectiveToolbar;
 
   if (showViewToolbar)
   {
     auto* prefService = mitk::CoreServices::GetPreferencesService();
     auto* stylePrefs = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
     bool showCategoryNames = stylePrefs->GetBool(berry::QtPreferences::QT_SHOW_TOOLBAR_CATEGORY_NAMES, true);
 
     // Order view descriptors by category
 
     QMultiMap<QString, berry::IViewDescriptor::Pointer> categoryViewDescriptorMap;
 
     for (const auto &labelViewDescriptorPair : VDMap)
     {
       auto viewDescriptor = labelViewDescriptorPair.second;
       auto category = !viewDescriptor->GetCategoryPath().isEmpty()
         ? viewDescriptor->GetCategoryPath().back()
         : QString();
 
       categoryViewDescriptorMap.insert(category, viewDescriptor);
     }
 
     // Create a separate toolbar for each category
 
     for (const auto &category : categoryViewDescriptorMap.uniqueKeys())
     {
       auto viewDescriptorsInCurrentCategory = categoryViewDescriptorMap.values(category);
 
       if (!viewDescriptorsInCurrentCategory.isEmpty())
       {
         auto toolbar = new QToolBar;
         toolbar->setObjectName(category + " View Toolbar");
         mainWindow->addToolBar(toolbar);
 
         if (showCategoryNames && !category.isEmpty())
         {
           auto categoryButton = new QToolButton;
           categoryButton->setToolButtonStyle(Qt::ToolButtonTextOnly);
           categoryButton->setText(category);
           categoryButton->setStyleSheet("background: transparent; margin: 0; padding: 0;");
           toolbar->addWidget(categoryButton);
 
           connect(categoryButton, &QToolButton::clicked, [toolbar]()
           {
             for (QWidget* widget : toolbar->findChildren<QWidget*>())
             {
               if (QStringLiteral("qt_toolbar_ext_button") == widget->objectName() && widget->isVisible())
               {
                 QMouseEvent pressEvent(QEvent::MouseButtonPress, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                 QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                 QApplication::sendEvent(widget, &pressEvent);
                 QApplication::sendEvent(widget, &releaseEvent);
               }
             }
           });
         }
 
         for (const auto &viewDescriptor : qAsConst(viewDescriptorsInCurrentCategory))
         {
           auto viewAction = new berry::QtShowViewAction(window, viewDescriptor);
           toolbar->addAction(viewAction);
         }
       }
     }
   }
 
   QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
   mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
 
   auto   qStatusBar = new QStatusBar();
 
   //creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
   auto  statusBar = new QmitkStatusBar(qStatusBar);
   //disabling the SizeGrip in the lower right corner
   statusBar->SetSizeGripEnabled(false);
 
   auto  progBar = new QmitkProgressBar();
 
   qStatusBar->addPermanentWidget(progBar, 0);
   progBar->hide();
   // progBar->AddStepsToDo(2);
   // progBar->Progress(1);
 
   mainWindow->setStatusBar(qStatusBar);
 
   if (showMemoryIndicator)
   {
     auto   memoryIndicator = new QmitkMemoryUsageIndicatorView();
     qStatusBar->addPermanentWidget(memoryIndicator, 0);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PreWindowOpen()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
   // show the shortcut bar and progress indicator, which are hidden by
   // default
   //configurer->SetShowPerspectiveBar(true);
   //configurer->SetShowFastViewBars(true);
   //configurer->SetShowProgressIndicator(true);
 
   //  // add the drag and drop support for the editor area
   //  configurer.addEditorAreaTransfer(EditorInputTransfer.getInstance());
   //  configurer.addEditorAreaTransfer(ResourceTransfer.getInstance());
   //  configurer.addEditorAreaTransfer(FileTransfer.getInstance());
   //  configurer.addEditorAreaTransfer(MarkerTransfer.getInstance());
   //  configurer.configureEditorAreaDropListener(new EditorAreaDropAdapter(
   //      configurer.getWindow()));
 
   this->HookTitleUpdateListeners(configurer);
 
   menuPerspectiveListener.reset(new PerspectiveListenerForMenu(this));
   configurer->GetWindow()->AddPerspectiveListener(menuPerspectiveListener.data());
 
   configurer->AddEditorAreaTransfer(QStringList("text/uri-list"));
   configurer->ConfigureEditorAreaDropListener(dropTargetListener.data());
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowOpen()
 {
   berry::WorkbenchWindowAdvisor::PostWindowOpen();
   // Force Rendering Window Creation on startup.
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
   ctkPluginContext* context = QmitkCommonExtPlugin::getContext();
   ctkServiceReference serviceRef = context->getServiceReference<mitk::IDataStorageService>();
   if (serviceRef)
   {
     mitk::IDataStorageService *dsService = context->getService<mitk::IDataStorageService>(serviceRef);
     if (dsService)
     {
       mitk::IDataStorageReference::Pointer dsRef = dsService->GetDataStorage();
       mitk::DataStorageEditorInput::Pointer dsInput(new mitk::DataStorageEditorInput(dsRef));
       mitk::WorkbenchUtil::OpenEditor(configurer->GetWindow()->GetActivePage(),dsInput);
     }
   }
 
   auto introPart = configurer->GetWindow()->GetWorkbench()->GetIntroManager()->GetIntro();
   if (introPart.IsNotNull())
   {
     configurer->GetWindow()->GetWorkbench()->GetIntroManager()->ShowIntro(GetWindowConfigurer()->GetWindow(), false);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onIntro()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onIntro();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onHelp()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelp();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onHelpOpenHelpPerspective()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelpOpenHelpPerspective();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onAbout()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onAbout();
 }
 
 //--------------------------------------------------------------------------------
 // Ugly hack from here on. Feel free to delete when command framework
 // and undo buttons are done.
 //--------------------------------------------------------------------------------
 
 QmitkExtWorkbenchWindowAdvisorHack::QmitkExtWorkbenchWindowAdvisorHack()
   : QObject()
 {
 }
 
 QmitkExtWorkbenchWindowAdvisorHack::~QmitkExtWorkbenchWindowAdvisorHack()
 {
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onUndo()
 {
   mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
   if (model)
   {
     if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>( model ))
     {
       mitk::VerboseLimitedLinearUndo::StackDescription descriptions = verboseundo->GetUndoDescriptions();
       if (descriptions.size() >= 1)
       {
         MITK_INFO << "Undo " << descriptions.front().second;
       }
     }
     model->Undo();
   }
   else
   {
     MITK_ERROR << "No undo model instantiated";
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onRedo()
 {
   mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
   if (model)
   {
     if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>( model ))
     {
       mitk::VerboseLimitedLinearUndo::StackDescription descriptions = verboseundo->GetRedoDescriptions();
       if (descriptions.size() >= 1)
       {
         MITK_INFO << "Redo " << descriptions.front().second;
       }
     }
     model->Redo();
   }
   else
   {
     MITK_ERROR << "No undo model instantiated";
   }
 }
 
 // safe calls to the complete chain
 // berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->FindView("org.mitk.views.imagenavigator");
 // to cover for all possible cases of closed pages etc.
 static void SafeHandleNavigatorView(QString view_query_name)
 {
   berry::IWorkbench* wbench = berry::PlatformUI::GetWorkbench();
   if( wbench == nullptr )
     return;
 
   berry::IWorkbenchWindow::Pointer wbench_window = wbench->GetActiveWorkbenchWindow();
   if( wbench_window.IsNull() )
     return;
 
   berry::IWorkbenchPage::Pointer wbench_page = wbench_window->GetActivePage();
   if( wbench_page.IsNull() )
     return;
 
   auto wbench_view = wbench_page->FindView( view_query_name );
 
   if( wbench_view.IsNotNull() )
   {
     bool isViewVisible = wbench_page->IsPartVisible( wbench_view );
     if( isViewVisible )
     {
       wbench_page->HideView( wbench_view );
       return;
     }
 
   }
 
   wbench_page->ShowView( view_query_name );
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onImageNavigator()
 {
   // show/hide ImageNavigatorView
   SafeHandleNavigatorView("org.mitk.views.imagenavigator");
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onViewNavigator()
 {
   // show/hide viewnavigatorView
   SafeHandleNavigatorView("org.mitk.views.viewnavigator");
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onEditPreferences()
 {
   QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
   _PreferencesDialog.exec();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onQuit()
 {
   berry::PlatformUI::GetWorkbench()->Close();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onResetPerspective()
 {
   berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onClosePerspective()
 {
   berry::IWorkbenchPage::Pointer page =
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
   page->ClosePerspective(page->GetPerspective(), true, true);
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onNewWindow()
 {
   berry::PlatformUI::GetWorkbench()->OpenWorkbenchWindow(nullptr);
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onIntro()
 {
   bool hasIntro =
     berry::PlatformUI::GetWorkbench()->GetIntroManager()->HasIntro();
   if (!hasIntro)
   {
-    QRegExp reg("(.*)<title>(\\n)*");
-    QRegExp reg2("(\\n)*</title>(.*)");
+    QRegularExpression reg("(.*)<title>(\\n)*");
+    QRegularExpression reg2("(\\n)*</title>(.*)");
     QFile file(":/org.mitk.gui.qt.ext/index.html");
     file.open(QIODevice::ReadOnly | QIODevice::Text); //text file only for reading
 
     QString text = QString(file.readAll());
 
     file.close();
 
     QString title = text;
     title.replace(reg, "");
     title.replace(reg2, "");
 
     std::cout << title.toStdString() << std::endl;
 
     QMessageBox::information(nullptr, title,
       text, "Close");
   }
   else
   {
     berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
       berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow(), false);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onHelp()
 {
   ctkPluginContext* context = QmitkCommonExtPlugin::getContext();
   if (context == nullptr)
   {
     MITK_WARN << "Plugin context not set, unable to open context help";
     return;
   }
 
   // Check if the org.blueberry.ui.qt.help plug-in is installed and started
   QList<QSharedPointer<ctkPlugin> > plugins = context->getPlugins();
   foreach(QSharedPointer<ctkPlugin> p, plugins)
   {
     if (p->getSymbolicName() == "org.blueberry.ui.qt.help")
     {
       if (p->getState() != ctkPlugin::ACTIVE)
       {
         // try to activate the plug-in explicitly
         try
         {
           p->start(ctkPlugin::START_TRANSIENT);
         }
         catch (const ctkPluginException& pe)
         {
           MITK_ERROR << "Activating org.blueberry.ui.qt.help failed: " << pe.what();
           return;
         }
       }
     }
   }
 
   ctkServiceReference eventAdminRef = context->getServiceReference<ctkEventAdmin>();
   ctkEventAdmin* eventAdmin = nullptr;
   if (eventAdminRef)
   {
     eventAdmin = context->getService<ctkEventAdmin>(eventAdminRef);
   }
   if (eventAdmin == nullptr)
   {
     MITK_WARN << "ctkEventAdmin service not found. Unable to open context help";
   }
   else
   {
     ctkEvent ev("org/blueberry/ui/help/CONTEXTHELP_REQUESTED");
     eventAdmin->postEvent(ev);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onHelpOpenHelpPerspective()
 {
   berry::PlatformUI::GetWorkbench()->ShowPerspective("org.blueberry.perspectives.help",
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow());
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onAbout()
 {
   auto aboutDialog = new QmitkAboutDialog(QApplication::activeWindow(),nullptr);
   aboutDialog->open();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::HookTitleUpdateListeners(berry::IWorkbenchWindowConfigurer::Pointer configurer)
 {
   // hook up the listeners to update the window title
   titlePartListener.reset(new PartListenerForTitle(this));
   titlePerspectiveListener.reset(new PerspectiveListenerForTitle(this));
   editorPropertyListener.reset(new berry::PropertyChangeIntAdapter<
     QmitkExtWorkbenchWindowAdvisor>(this,
     &QmitkExtWorkbenchWindowAdvisor::PropertyChange));
 
   //    configurer.getWindow().addPageListener(new IPageListener() {
   //      public void pageActivated(IWorkbenchPage page) {
   //        updateTitle(false);
   //      }
   //
   //      public void pageClosed(IWorkbenchPage page) {
   //        updateTitle(false);
   //      }
   //
   //      public void pageOpened(IWorkbenchPage page) {
   //        // do nothing
   //      }
   //    });
 
   configurer->GetWindow()->AddPerspectiveListener(titlePerspectiveListener.data());
   configurer->GetWindow()->GetPartService()->AddPartListener(titlePartListener.data());
 }
 
 QString QmitkExtWorkbenchWindowAdvisor::ComputeTitle()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   berry::IWorkbenchPage::Pointer currentPage = configurer->GetWindow()->GetActivePage();
   berry::IEditorPart::Pointer activeEditor;
   if (currentPage)
   {
     activeEditor = lastActiveEditor.Lock();
   }
 
   QString title;
   berry::IProduct::Pointer product = berry::Platform::GetProduct();
   if (product.IsNotNull())
   {
     title = product->GetName();
   }
   if (title.isEmpty())
   {
     // instead of the product name, we use a custom variable for now
     title = productName;
   }
 
   if(showMitkVersionInfo)
   {
     QString mitkVersionInfo = MITK_REVISION_DESC;
 
     if(mitkVersionInfo.isEmpty())
       mitkVersionInfo = MITK_VERSION_STRING;
 
     title += " " + mitkVersionInfo;
   }
 
   if (showVersionInfo)
   {
     // add version informatioin
     QString versions = QString(" (ITK %1.%2.%3 | VTK %4.%5.%6 | Qt %7)")
       .arg(ITK_VERSION_MAJOR).arg(ITK_VERSION_MINOR).arg(ITK_VERSION_PATCH)
       .arg(VTK_MAJOR_VERSION).arg(VTK_MINOR_VERSION).arg(VTK_BUILD_VERSION)
       .arg(QT_VERSION_STR);
 
     title += versions;
   }
 
   if (currentPage)
   {
     if (activeEditor)
     {
       lastEditorTitle = activeEditor->GetTitleToolTip();
       if (!lastEditorTitle.isEmpty())
         title = lastEditorTitle + " - " + title;
     }
     berry::IPerspectiveDescriptor::Pointer persp = currentPage->GetPerspective();
     QString label = "";
     if (persp)
     {
       label = persp->GetLabel();
     }
     berry::IAdaptable* input = currentPage->GetInput();
     if (input && input != wbAdvisor->GetDefaultPageInput())
     {
       label = currentPage->GetLabel();
     }
     if (!label.isEmpty())
     {
       title = label + " - " + title;
     }
   }
 
   title += " (Not for use in diagnosis or treatment of patients)";
 
   return title;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::RecomputeTitle()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   QString oldTitle = configurer->GetTitle();
   QString newTitle = ComputeTitle();
   if (newTitle != oldTitle)
   {
     configurer->SetTitle(newTitle);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::UpdateTitle(bool editorHidden)
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   berry::IWorkbenchWindow::Pointer window = configurer->GetWindow();
   berry::IEditorPart::Pointer activeEditor;
   berry::IWorkbenchPage::Pointer currentPage = window->GetActivePage();
   berry::IPerspectiveDescriptor::Pointer persp;
   berry::IAdaptable* input = nullptr;
 
   if (currentPage)
   {
     activeEditor = currentPage->GetActiveEditor();
     persp = currentPage->GetPerspective();
     input = currentPage->GetInput();
   }
 
   if (editorHidden)
   {
     activeEditor = nullptr;
   }
 
   // Nothing to do if the editor hasn't changed
   if (activeEditor == lastActiveEditor.Lock() && currentPage == lastActivePage.Lock()
     && persp == lastPerspective.Lock() && input == lastInput)
   {
     return;
   }
 
   auto lockedLastActiveEditor = lastActiveEditor.Lock();
 
   if (lockedLastActiveEditor.IsNotNull())
   {
     lockedLastActiveEditor->RemovePropertyListener(editorPropertyListener.data());
   }
 
   lastActiveEditor = activeEditor;
   lastActivePage = currentPage;
   lastPerspective = persp;
   lastInput = input;
 
   if (activeEditor)
   {
     activeEditor->AddPropertyListener(editorPropertyListener.data());
   }
 
   RecomputeTitle();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PropertyChange(const berry::Object::Pointer& /*source*/, int propId)
 {
   if (propId == berry::IWorkbenchPartConstants::PROP_TITLE)
   {
     auto lockedLastActiveEditor = lastActiveEditor.Lock();
 
     if (lockedLastActiveEditor.IsNotNull())
     {
       QString newTitle = lockedLastActiveEditor->GetPartName();
       if (lastEditorTitle != newTitle)
       {
         RecomputeTitle();
       }
     }
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetPerspectiveExcludeList(const QList<QString>& v)
 {
   this->perspectiveExcludeList = v;
 }
 
 QList<QString> QmitkExtWorkbenchWindowAdvisor::GetPerspectiveExcludeList()
 {
   return this->perspectiveExcludeList;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetViewExcludeList(const QList<QString>& v)
 {
   this->viewExcludeList = v;
 }
 
 QList<QString> QmitkExtWorkbenchWindowAdvisor::GetViewExcludeList()
 {
   return this->viewExcludeList;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowClose()
 {
   berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
   QMainWindow* mainWindow = static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   auto fileName = this->GetQSettingsFile();
 
   if (!fileName.isEmpty())
   {
     QSettings settings(fileName, QSettings::IniFormat);
     settings.setValue("ToolbarPosition", mainWindow->saveState());
   }
 }
 
 QString QmitkExtWorkbenchWindowAdvisor::GetQSettingsFile() const
 {
   QFileInfo settingsInfo = QmitkCommonExtPlugin::getContext()->getDataFile(QT_SETTINGS_FILENAME);
   return settingsInfo.canonicalFilePath();
 }
diff --git a/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisor.cpp b/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisor.cpp
index 35379f49fa..3cbb9d8ac1 100644
--- a/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisor.cpp
+++ b/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisor.cpp
@@ -1,1158 +1,1158 @@
 /*============================================================================
 
 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 "QmitkFlowApplicationWorkbenchWindowAdvisor.h"
 
 #include <QMenu>
 #include <QMenuBar>
 #include <QMainWindow>
 #include <QStatusBar>
 #include <QString>
 #include <QFile>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QTextStream>
 #include <QSettings>
 
 #include <ctkPluginException.h>
 #include <service/event/ctkEventAdmin.h>
 
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIActionBarConfigurer.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryIPerspectiveDescriptor.h>
 #include <berryIProduct.h>
 #include <berryIWorkbenchPartConstants.h>
 #include <berryQtPreferences.h>
 #include <berryQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 
 #include <internal/berryQtShowViewAction.h>
 #include <internal/berryQtOpenPerspectiveAction.h>
 
 #include <QmitkFileExitAction.h>
 #include <QmitkCloseProjectAction.h>
 #include <QmitkUndoAction.h>
 #include <QmitkRedoAction.h>
 #include <QmitkDefaultDropTargetListener.h>
 #include <QmitkStatusBar.h>
 #include <QmitkProgressBar.h>
 #include <QmitkMemoryUsageIndicatorView.h>
 #include <QmitkPreferencesDialog.h>
 #include "QmitkExtFileSaveProjectAction.h"
 
 #include <itkConfigure.h>
 #include <mitkVersion.h>
 #include <mitkIDataStorageService.h>
 #include <mitkIDataStorageReference.h>
 #include <mitkDataStorageEditorInput.h>
 #include <mitkWorkbenchUtil.h>
 #include <vtkVersionMacros.h>
 #include <mitkCoreServices.h>
 #include <mitkIPreferencesService.h>
 #include <mitkIPreferences.h>
 
 // UGLYYY
 #include "QmitkFlowApplicationWorkbenchWindowAdvisorHack.h"
 #include "QmitkFlowApplicationPlugin.h"
 #include "mitkUndoController.h"
 #include "mitkVerboseLimitedLinearUndo.h"
 #include <QToolBar>
 #include <QToolButton>
 #include <QMessageBox>
 #include <QMouseEvent>
 #include <QLabel>
 #include <QmitkAboutDialog.h>
 
 QmitkFlowApplicationWorkbenchWindowAdvisorHack* QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack =
   new QmitkFlowApplicationWorkbenchWindowAdvisorHack();
 
 QString QmitkFlowApplicationWorkbenchWindowAdvisor::QT_SETTINGS_FILENAME = "QtSettings.ini";
 
 class PartListenerForTitle: public berry::IPartListener
 {
 public:
 
   PartListenerForTitle(QmitkFlowApplicationWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
   {
   }
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::ACTIVATED | Events::BROUGHT_TO_TOP | Events::CLOSED
       | Events::HIDDEN | Events::VISIBLE;
   }
 
   void PartActivated(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref.Cast<berry::IEditorReference> ())
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
   void PartBroughtToTop(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref.Cast<berry::IEditorReference> ())
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& /*ref*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     auto lockedLastActiveEditor = windowAdvisor->lastActiveEditor.Lock();
 
     if (lockedLastActiveEditor.IsNotNull() && ref->GetPart(false) == lockedLastActiveEditor)
     {
       windowAdvisor->UpdateTitle(true);
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     auto lockedLastActiveEditor = windowAdvisor->lastActiveEditor.Lock();
 
     if (lockedLastActiveEditor.IsNotNull() && ref->GetPart(false) == lockedLastActiveEditor)
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
 private:
   QmitkFlowApplicationWorkbenchWindowAdvisor* windowAdvisor;
 };
 
 class PartListenerForImageNavigator: public berry::IPartListener
 {
 public:
 
   PartListenerForImageNavigator(QAction* act)
     : imageNavigatorAction(act)
   {
   }
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::OPENED | Events::CLOSED | Events::HIDDEN |
       Events::VISIBLE;
   }
 
   void PartOpened(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(true);
     }
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(false);
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(true);
     }
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(false);
     }
   }
 
 private:
   QAction* imageNavigatorAction;
 };
 
 class PerspectiveListenerForTitle: public berry::IPerspectiveListener
 {
 public:
 
   PerspectiveListenerForTitle(QmitkFlowApplicationWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
     , perspectivesClosed(false)
   {
   }
 
   Events::Types GetPerspectiveEventTypes() const override
   {
     return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED
       | Events::CLOSED | Events::OPENED;
   }
 
   void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveSavedAs(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*oldPerspective*/,
     const berry::IPerspectiveDescriptor::Pointer& /*newPerspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveOpened(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     if (perspectivesClosed)
     {
       QListIterator<QAction*> i(windowAdvisor->viewActions);
       while (i.hasNext())
       {
         i.next()->setEnabled(true);
       }
 
       windowAdvisor->fileSaveProjectAction->setEnabled(true);
       windowAdvisor->undoAction->setEnabled(true);
       windowAdvisor->redoAction->setEnabled(true);
       windowAdvisor->imageNavigatorAction->setEnabled(true);
       windowAdvisor->resetPerspAction->setEnabled(true);
     }
 
     perspectivesClosed = false;
   }
 
   void PerspectiveClosed(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     berry::IWorkbenchWindow::Pointer wnd = windowAdvisor->GetWindowConfigurer()->GetWindow();
     bool allClosed = true;
     if (wnd->GetActivePage())
     {
       QList<berry::IPerspectiveDescriptor::Pointer> perspectives(wnd->GetActivePage()->GetOpenPerspectives());
       allClosed = perspectives.empty();
     }
 
     if (allClosed)
     {
       perspectivesClosed = true;
 
       QListIterator<QAction*> i(windowAdvisor->viewActions);
       while (i.hasNext())
       {
         i.next()->setEnabled(false);
       }
 
       windowAdvisor->fileSaveProjectAction->setEnabled(false);
       windowAdvisor->undoAction->setEnabled(false);
       windowAdvisor->redoAction->setEnabled(false);
       windowAdvisor->imageNavigatorAction->setEnabled(false);
       windowAdvisor->resetPerspAction->setEnabled(false);
     }
   }
 
 private:
   QmitkFlowApplicationWorkbenchWindowAdvisor* windowAdvisor;
   bool perspectivesClosed;
 };
 
 class PerspectiveListenerForMenu: public berry::IPerspectiveListener
 {
 public:
 
   PerspectiveListenerForMenu(QmitkFlowApplicationWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
   {
   }
 
   Events::Types GetPerspectiveEventTypes() const override
   {
     return Events::ACTIVATED | Events::DEACTIVATED;
   }
 
   void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& perspective) override
   {
     QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
     if (action)
     {
       action->setChecked(true);
     }
   }
 
   void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& perspective) override
   {
     QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
     if (action)
     {
       action->setChecked(false);
     }
   }
 
 private:
   QmitkFlowApplicationWorkbenchWindowAdvisor* windowAdvisor;
 };
 
 QmitkFlowApplicationWorkbenchWindowAdvisor::QmitkFlowApplicationWorkbenchWindowAdvisor(berry::WorkbenchAdvisor* wbAdvisor,
                                                                berry::IWorkbenchWindowConfigurer::Pointer configurer)
   : berry::WorkbenchWindowAdvisor(configurer)
   , lastInput(nullptr)
   , wbAdvisor(wbAdvisor)
   , showViewToolbar(true)
   , showVersionInfo(true)
   , showMitkVersionInfo(true)
   , showMemoryIndicator(true)
   , dropTargetListener(new QmitkDefaultDropTargetListener)
 {
   productName = QCoreApplication::applicationName();
   viewExcludeList.push_back("org.mitk.views.viewnavigator");
 }
 
 QmitkFlowApplicationWorkbenchWindowAdvisor::~QmitkFlowApplicationWorkbenchWindowAdvisor()
 {
 }
 
 QWidget* QmitkFlowApplicationWorkbenchWindowAdvisor::CreateEmptyWindowContents(QWidget* parent)
 {
   QWidget* parentWidget = static_cast<QWidget*>(parent);
   auto   label = new QLabel(parentWidget);
   label->setText("<b>No perspectives are open. Open a perspective in the <i>Window->Open Perspective</i> menu.</b>");
   label->setContentsMargins(10,10,10,10);
   label->setAlignment(Qt::AlignTop);
   label->setEnabled(false);
   parentWidget->layout()->addWidget(label);
   return label;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::ShowMemoryIndicator(bool show)
 {
   showMemoryIndicator = show;
 }
 
 bool QmitkFlowApplicationWorkbenchWindowAdvisor::GetShowMemoryIndicator()
 {
   return showMemoryIndicator;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::ShowViewToolbar(bool show)
 {
   showViewToolbar = show;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::ShowVersionInfo(bool show)
 {
   showVersionInfo = show;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::ShowMitkVersionInfo(bool show)
 {
   showMitkVersionInfo = show;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::SetProductName(const QString& product)
 {
   productName = product;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::SetWindowIcon(const QString& wndIcon)
 {
   windowIcon = wndIcon;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::PostWindowCreate()
 {
   // very bad hack...
   berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
   QMainWindow* mainWindow = qobject_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   if (!windowIcon.isEmpty())
   {
     mainWindow->setWindowIcon(QIcon(windowIcon));
   }
   mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
 
   // Load icon theme
   QIcon::setThemeSearchPaths(QStringList() << QStringLiteral(":/org_mitk_icons/icons/"));
   QIcon::setThemeName(QStringLiteral("awesome"));
 
   // ==== Application menu ============================
 
   QMenuBar* menuBar = mainWindow->menuBar();
   menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
 
 #ifdef __APPLE__
   menuBar->setNativeMenuBar(true);
 #else
   menuBar->setNativeMenuBar(false);
 #endif
 
   auto basePath = QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/");
 
   fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
   fileSaveProjectAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "document-save.svg"));
 
   auto   perspGroup = new QActionGroup(menuBar);
   std::map<QString, berry::IViewDescriptor::Pointer> VDMap;
 
   // sort elements (converting vector to map...)
   QList<berry::IViewDescriptor::Pointer>::const_iterator iter;
 
   berry::IViewRegistry* viewRegistry =
     berry::PlatformUI::GetWorkbench()->GetViewRegistry();
   const QList<berry::IViewDescriptor::Pointer> viewDescriptors = viewRegistry->GetViews();
 
   bool skip = false;
   for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
   {
     // if viewExcludeList is set, it contains the id-strings of view, which
     // should not appear as an menu-entry in the menu
     if (viewExcludeList.size() > 0)
     {
       for (int i=0; i<viewExcludeList.size(); i++)
       {
         if (viewExcludeList.at(i) == (*iter)->GetId())
         {
           skip = true;
           break;
         }
       }
       if (skip)
       {
         skip = false;
         continue;
       }
     }
 
     if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
       continue;
     if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
       continue;
     if ((*iter)->GetId() == "org.mitk.views.viewnavigator")
       continue;
 
     std::pair<QString, berry::IViewDescriptor::Pointer> p((*iter)->GetLabel(), (*iter));
     VDMap.insert(p);
   }
 
   std::map<QString, berry::IViewDescriptor::Pointer>::const_iterator MapIter;
   for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
   {
     berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window, (*MapIter).second);
     viewActions.push_back(viewAction);
   }
 
   QMenu* fileMenu = menuBar->addMenu("&File");
   fileMenu->setObjectName("FileMenu");
   fileMenu->addAction(fileSaveProjectAction);
   fileMenu->addSeparator();
 
   QAction* fileExitAction = new QmitkFileExitAction(window);
   fileExitAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "system-log-out.svg"));
   fileExitAction->setShortcut(QKeySequence::Quit);
   fileExitAction->setObjectName("QmitkFileExitAction");
   fileMenu->addAction(fileExitAction);
 
   // another bad hack to get an edit/undo menu...
   QMenu* editMenu = menuBar->addMenu("&Edit");
   undoAction = editMenu->addAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-undo.svg"),
     "&Undo",
     QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
     QKeySequence("CTRL+Z"));
   undoAction->setToolTip("Undo the last action (not supported by all modules)");
   redoAction = editMenu->addAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-redo.svg"),
     "&Redo",
     QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
     QKeySequence("CTRL+Y"));
   redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
 
   // ==== Window Menu ==========================
   QMenu* windowMenu = menuBar->addMenu("Window");
 
   QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
 
   windowMenu->addSeparator();
   resetPerspAction = windowMenu->addAction("&Reset Perspective",
     QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
 
   windowMenu->addSeparator();
   windowMenu->addAction("&Preferences...",
     QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
     QKeySequence("CTRL+P"));
 
   // fill perspective menu
   berry::IPerspectiveRegistry* perspRegistry =
     window->GetWorkbench()->GetPerspectiveRegistry();
 
   QList<berry::IPerspectiveDescriptor::Pointer> perspectives(
     perspRegistry->GetPerspectives());
 
   skip = false;
   for (QList<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
     perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
   {
     // if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
     // should not appear as an menu-entry in the perspective menu
     if (perspectiveExcludeList.size() > 0)
     {
       for (int i=0; i<perspectiveExcludeList.size(); i++)
       {
         if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
         {
           skip = true;
           break;
         }
       }
       if (skip)
       {
         skip = false;
         continue;
       }
     }
 
     QAction* perspAction = new berry::QtOpenPerspectiveAction(window, *perspIt, perspGroup);
     mapPerspIdToAction.insert((*perspIt)->GetId(), perspAction);
   }
   perspMenu->addActions(perspGroup->actions());
 
   // ===== Help menu ====================================
   QMenu* helpMenu = menuBar->addMenu("&Help");
   helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
   helpMenu->addAction("&Open Help Perspective", this, SLOT(onHelpOpenHelpPerspective()));
   helpMenu->addAction("&Context Help",this, SLOT(onHelp()),  QKeySequence("F1"));
   helpMenu->addAction("&About",this, SLOT(onAbout()));
   // =====================================================
 
 
   // toolbar for showing file open, undo, redo and other main actions
   auto   mainActionsToolBar = new QToolBar;
   mainActionsToolBar->setObjectName("mainActionsToolBar");
   mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
 #ifdef __APPLE__
   mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
 #else
   mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
 #endif
 
   basePath = QStringLiteral(":/org.mitk.gui.qt.ext/");
   imageNavigatorAction = new QAction(berry::QtStyleManager::ThemeIcon(basePath + "image_navigator.svg"), "&Image Navigator", nullptr);
   bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
 
   if (imageNavigatorViewFound)
   {
     QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
     imageNavigatorAction->setCheckable(true);
 
     // add part listener for image navigator
     imageNavigatorPartListener.reset(new PartListenerForImageNavigator(imageNavigatorAction));
     window->GetPartService()->AddPartListener(imageNavigatorPartListener.data());
     berry::IViewPart::Pointer imageNavigatorView = window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
     imageNavigatorAction->setChecked(false);
     if (imageNavigatorView)
     {
       bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
       if (isImageNavigatorVisible)
         imageNavigatorAction->setChecked(true);
     }
     imageNavigatorAction->setToolTip("Toggle image navigator for navigating through image");
   }
 
   mainActionsToolBar->addAction(undoAction);
   mainActionsToolBar->addAction(redoAction);
 
   if (imageNavigatorViewFound)
   {
     mainActionsToolBar->addAction(imageNavigatorAction);
   }
 
   mainWindow->addToolBar(mainActionsToolBar);
 
   // ==== View Toolbar ==================================
 
   if (showViewToolbar)
   {
     auto* prefService = mitk::CoreServices::GetPreferencesService();
     auto* stylePrefs = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
     bool showCategoryNames = stylePrefs->GetBool(berry::QtPreferences::QT_SHOW_TOOLBAR_CATEGORY_NAMES, true);
 
     // Order view descriptors by category
 
     QMultiMap<QString, berry::IViewDescriptor::Pointer> categoryViewDescriptorMap;
 
     for (auto labelViewDescriptorPair : VDMap)
     {
       auto viewDescriptor = labelViewDescriptorPair.second;
       auto category = !viewDescriptor->GetCategoryPath().isEmpty()
         ? viewDescriptor->GetCategoryPath().back()
         : QString();
 
       categoryViewDescriptorMap.insert(category, viewDescriptor);
     }
 
     // Create a separate toolbar for each category
 
     for (auto category : categoryViewDescriptorMap.uniqueKeys())
     {
       auto viewDescriptorsInCurrentCategory = categoryViewDescriptorMap.values(category);
       QList<berry::SmartPointer<berry::IViewDescriptor> > relevantViewDescriptors;
 
       for (auto viewDescriptor : viewDescriptorsInCurrentCategory)
       {
         if (viewDescriptor->GetId() != "org.mitk.views.flow.control" &&
             viewDescriptor->GetId() != "org.mitk.views.segmentationtasklist")
         {
           relevantViewDescriptors.push_back(viewDescriptor);
         }
       }
 
       if (!relevantViewDescriptors.isEmpty())
       {
         auto toolbar = new QToolBar;
         toolbar->setObjectName(category + " View Toolbar");
         mainWindow->addToolBar(toolbar);
 
         if (showCategoryNames && !category.isEmpty())
         {
           auto categoryButton = new QToolButton;
           categoryButton->setToolButtonStyle(Qt::ToolButtonTextOnly);
           categoryButton->setText(category);
           categoryButton->setStyleSheet("background: transparent; margin: 0; padding: 0;");
           toolbar->addWidget(categoryButton);
 
           connect(categoryButton, &QToolButton::clicked, [toolbar]()
           {
             for (QWidget* widget : toolbar->findChildren<QWidget*>())
             {
               if (QStringLiteral("qt_toolbar_ext_button") == widget->objectName() && widget->isVisible())
               {
                 QMouseEvent pressEvent(QEvent::MouseButtonPress, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                 QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                 QApplication::sendEvent(widget, &pressEvent);
                 QApplication::sendEvent(widget, &releaseEvent);
               }
             }
           });
         }
 
         for (auto viewDescriptor : relevantViewDescriptors)
         {
           auto viewAction = new berry::QtShowViewAction(window, viewDescriptor);
           toolbar->addAction(viewAction);
         }
       }
     }
   }
 
   QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
   mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
 
   auto   qStatusBar = new QStatusBar();
 
   //creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
   auto  statusBar = new QmitkStatusBar(qStatusBar);
   //disabling the SizeGrip in the lower right corner
   statusBar->SetSizeGripEnabled(false);
 
   auto  progBar = new QmitkProgressBar();
 
   qStatusBar->addPermanentWidget(progBar, 0);
   progBar->hide();
 
   mainWindow->setStatusBar(qStatusBar);
 
   if (showMemoryIndicator)
   {
     auto   memoryIndicator = new QmitkMemoryUsageIndicatorView();
     qStatusBar->addPermanentWidget(memoryIndicator, 0);
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::PreWindowOpen()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
   this->HookTitleUpdateListeners(configurer);
 
   menuPerspectiveListener.reset(new PerspectiveListenerForMenu(this));
   configurer->GetWindow()->AddPerspectiveListener(menuPerspectiveListener.data());
 
   configurer->AddEditorAreaTransfer(QStringList("text/uri-list"));
   configurer->ConfigureEditorAreaDropListener(dropTargetListener.data());
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::PostWindowOpen()
 {
   berry::WorkbenchWindowAdvisor::PostWindowOpen();
   // Force Rendering Window Creation on startup.
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
   ctkPluginContext* context = QmitkFlowApplicationPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference serviceRef = context->getServiceReference<mitk::IDataStorageService>();
   if (serviceRef)
   {
     mitk::IDataStorageService *dsService = context->getService<mitk::IDataStorageService>(serviceRef);
     if (dsService)
     {
       mitk::IDataStorageReference::Pointer dsRef = dsService->GetDataStorage();
       mitk::DataStorageEditorInput::Pointer dsInput(new mitk::DataStorageEditorInput(dsRef));
       mitk::WorkbenchUtil::OpenEditor(configurer->GetWindow()->GetActivePage(),dsInput);
     }
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::onIntro()
 {
   QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack->onIntro();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::onHelp()
 {
   QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack->onHelp();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::onHelpOpenHelpPerspective()
 {
   QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack->onHelpOpenHelpPerspective();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::onAbout()
 {
   QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack->onAbout();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::HookTitleUpdateListeners(berry::IWorkbenchWindowConfigurer::Pointer configurer)
 {
   // hook up the listeners to update the window title
   titlePartListener.reset(new PartListenerForTitle(this));
   titlePerspectiveListener.reset(new PerspectiveListenerForTitle(this));
   editorPropertyListener.reset(new berry::PropertyChangeIntAdapter<
     QmitkFlowApplicationWorkbenchWindowAdvisor>(this,
     &QmitkFlowApplicationWorkbenchWindowAdvisor::PropertyChange));
 
   configurer->GetWindow()->AddPerspectiveListener(titlePerspectiveListener.data());
   configurer->GetWindow()->GetPartService()->AddPartListener(titlePartListener.data());
 }
 
 QString QmitkFlowApplicationWorkbenchWindowAdvisor::ComputeTitle()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   berry::IWorkbenchPage::Pointer currentPage = configurer->GetWindow()->GetActivePage();
   berry::IEditorPart::Pointer activeEditor;
   if (currentPage)
   {
     activeEditor = lastActiveEditor.Lock();
   }
 
   QString title;
   berry::IProduct::Pointer product = berry::Platform::GetProduct();
   if (product.IsNotNull())
   {
     title = product->GetName();
   }
   if (title.isEmpty())
   {
     // instead of the product name, we use a custom variable for now
     title = productName;
   }
 
   if(showMitkVersionInfo)
   {
     QString mitkVersionInfo = MITK_REVISION_DESC;
 
     if(mitkVersionInfo.isEmpty())
       mitkVersionInfo = MITK_VERSION_STRING;
 
     title += " " + mitkVersionInfo;
   }
 
   if (showVersionInfo)
   {
     // add version informatioin
     QString versions = QString(" (ITK %1.%2.%3 | VTK %4.%5.%6 | Qt %7)")
       .arg(ITK_VERSION_MAJOR).arg(ITK_VERSION_MINOR).arg(ITK_VERSION_PATCH)
       .arg(VTK_MAJOR_VERSION).arg(VTK_MINOR_VERSION).arg(VTK_BUILD_VERSION)
       .arg(QT_VERSION_STR);
 
     title += versions;
   }
 
   if (currentPage)
   {
     if (activeEditor)
     {
       lastEditorTitle = activeEditor->GetTitleToolTip();
       if (!lastEditorTitle.isEmpty())
         title = lastEditorTitle + " - " + title;
     }
     berry::IPerspectiveDescriptor::Pointer persp = currentPage->GetPerspective();
     QString label = "";
     if (persp)
     {
       label = persp->GetLabel();
     }
     berry::IAdaptable* input = currentPage->GetInput();
     if (input && input != wbAdvisor->GetDefaultPageInput())
     {
       label = currentPage->GetLabel();
     }
     if (!label.isEmpty())
     {
       title = label + " - " + title;
     }
   }
 
   title += " (Not for use in diagnosis or treatment of patients)";
 
   return title;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::RecomputeTitle()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   QString oldTitle = configurer->GetTitle();
   QString newTitle = ComputeTitle();
   if (newTitle != oldTitle)
   {
     configurer->SetTitle(newTitle);
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::UpdateTitle(bool editorHidden)
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   berry::IWorkbenchWindow::Pointer window = configurer->GetWindow();
   berry::IEditorPart::Pointer activeEditor;
   berry::IWorkbenchPage::Pointer currentPage = window->GetActivePage();
   berry::IPerspectiveDescriptor::Pointer persp;
   berry::IAdaptable* input = nullptr;
 
   if (currentPage)
   {
     activeEditor = currentPage->GetActiveEditor();
     persp = currentPage->GetPerspective();
     input = currentPage->GetInput();
   }
 
   if (editorHidden)
   {
     activeEditor = nullptr;
   }
 
   // Nothing to do if the editor hasn't changed
   if (activeEditor == lastActiveEditor.Lock() && currentPage == lastActivePage.Lock()
     && persp == lastPerspective.Lock() && input == lastInput)
   {
     return;
   }
 
   auto lockedLastActiveEditor = lastActiveEditor.Lock();
 
   if (lockedLastActiveEditor.IsNotNull())
   {
     lockedLastActiveEditor->RemovePropertyListener(editorPropertyListener.data());
   }
 
   lastActiveEditor = activeEditor;
   lastActivePage = currentPage;
   lastPerspective = persp;
   lastInput = input;
 
   if (activeEditor)
   {
     activeEditor->AddPropertyListener(editorPropertyListener.data());
   }
 
   RecomputeTitle();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::PropertyChange(const berry::Object::Pointer& /*source*/, int propId)
 {
   if (propId == berry::IWorkbenchPartConstants::PROP_TITLE)
   {
     auto lockedLastActiveEditor = lastActiveEditor.Lock();
 
     if (lockedLastActiveEditor.IsNotNull())
     {
       QString newTitle = lockedLastActiveEditor->GetPartName();
       if (lastEditorTitle != newTitle)
       {
         RecomputeTitle();
       }
     }
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::SetPerspectiveExcludeList(const QList<QString>& v)
 {
   this->perspectiveExcludeList = v;
 }
 
 QList<QString> QmitkFlowApplicationWorkbenchWindowAdvisor::GetPerspectiveExcludeList()
 {
   return this->perspectiveExcludeList;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::SetViewExcludeList(const QList<QString>& v)
 {
   this->viewExcludeList = v;
 }
 
 QList<QString> QmitkFlowApplicationWorkbenchWindowAdvisor::GetViewExcludeList()
 {
   return this->viewExcludeList;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::PostWindowClose()
 {
   berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
   QMainWindow* mainWindow = static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   auto fileName = this->GetQSettingsFile();
 
   if (!fileName.isEmpty())
   {
     QSettings settings(fileName, QSettings::IniFormat);
     settings.setValue("ToolbarPosition", mainWindow->saveState());
   }
 }
 
 QString QmitkFlowApplicationWorkbenchWindowAdvisor::GetQSettingsFile() const
 {
   QFileInfo settingsInfo = QmitkFlowApplicationPlugin::GetDefault()->GetPluginContext()->getDataFile(QT_SETTINGS_FILENAME);
   return settingsInfo.canonicalFilePath();
 }
 
 //--------------------------------------------------------------------------------
 // Ugly hack from here on. Feel free to delete when command framework
 // and undo buttons are done.
 //--------------------------------------------------------------------------------
 
 QmitkFlowApplicationWorkbenchWindowAdvisorHack::QmitkFlowApplicationWorkbenchWindowAdvisorHack()
   : QObject()
 {
 }
 
 QmitkFlowApplicationWorkbenchWindowAdvisorHack::~QmitkFlowApplicationWorkbenchWindowAdvisorHack()
 {
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onUndo()
 {
   mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
   if (model)
   {
     if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>(model))
     {
       mitk::VerboseLimitedLinearUndo::StackDescription descriptions = verboseundo->GetUndoDescriptions();
       if (descriptions.size() >= 1)
       {
         MITK_INFO << "Undo " << descriptions.front().second;
       }
     }
     model->Undo();
   }
   else
   {
     MITK_ERROR << "No undo model instantiated";
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onRedo()
 {
   mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
   if (model)
   {
     if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>(model))
     {
       mitk::VerboseLimitedLinearUndo::StackDescription descriptions = verboseundo->GetRedoDescriptions();
       if (descriptions.size() >= 1)
       {
         MITK_INFO << "Redo " << descriptions.front().second;
       }
     }
     model->Redo();
   }
   else
   {
     MITK_ERROR << "No undo model instantiated";
   }
 }
 
 // safe calls to the complete chain
 // berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->FindView("org.mitk.views.imagenavigator");
 // to cover for all possible cases of closed pages etc.
 static void SafeHandleNavigatorView(QString view_query_name)
 {
   berry::IWorkbench* wbench = berry::PlatformUI::GetWorkbench();
   if (wbench == nullptr)
     return;
 
   berry::IWorkbenchWindow::Pointer wbench_window = wbench->GetActiveWorkbenchWindow();
   if (wbench_window.IsNull())
     return;
 
   berry::IWorkbenchPage::Pointer wbench_page = wbench_window->GetActivePage();
   if (wbench_page.IsNull())
     return;
 
   auto wbench_view = wbench_page->FindView(view_query_name);
 
   if (wbench_view.IsNotNull())
   {
     bool isViewVisible = wbench_page->IsPartVisible(wbench_view);
     if (isViewVisible)
     {
       wbench_page->HideView(wbench_view);
       return;
     }
 
   }
 
   wbench_page->ShowView(view_query_name);
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onImageNavigator()
 {
   // show/hide ImageNavigatorView
   SafeHandleNavigatorView("org.mitk.views.imagenavigator");
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onEditPreferences()
 {
   QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
   _PreferencesDialog.exec();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onQuit()
 {
   berry::PlatformUI::GetWorkbench()->Close();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onResetPerspective()
 {
   berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onClosePerspective()
 {
   berry::IWorkbenchPage::Pointer page =
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
   page->ClosePerspective(page->GetPerspective(), true, true);
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onIntro()
 {
   bool hasIntro =
     berry::PlatformUI::GetWorkbench()->GetIntroManager()->HasIntro();
   if (!hasIntro)
   {
-    QRegExp reg("(.*)<title>(\\n)*");
-    QRegExp reg2("(\\n)*</title>(.*)");
+    QRegularExpression reg("(.*)<title>(\\n)*");
+    QRegularExpression reg2("(\\n)*</title>(.*)");
     QFile file(":/org.mitk.gui.qt.ext/index.html");
     file.open(QIODevice::ReadOnly | QIODevice::Text); //text file only for reading
 
     QString text = QString(file.readAll());
 
     file.close();
 
     QString title = text;
     title.replace(reg, "");
     title.replace(reg2, "");
 
     std::cout << title.toStdString() << std::endl;
 
     QMessageBox::information(nullptr, title,
       text, "Close");
   }
   else
   {
     berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
       berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow(), false);
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onHelp()
 {
   ctkPluginContext* context = QmitkFlowApplicationPlugin::GetDefault()->GetPluginContext();
   if (context == nullptr)
   {
     MITK_WARN << "Plugin context not set, unable to open context help";
     return;
   }
 
   // Check if the org.blueberry.ui.qt.help plug-in is installed and started
   QList<QSharedPointer<ctkPlugin> > plugins = context->getPlugins();
   foreach(QSharedPointer<ctkPlugin> p, plugins)
   {
     if (p->getSymbolicName() == "org.blueberry.ui.qt.help")
     {
       if (p->getState() != ctkPlugin::ACTIVE)
       {
         // try to activate the plug-in explicitly
         try
         {
           p->start(ctkPlugin::START_TRANSIENT);
         }
         catch (const ctkPluginException& pe)
         {
           MITK_ERROR << "Activating org.blueberry.ui.qt.help failed: " << pe.what();
           return;
         }
       }
     }
   }
 
   ctkServiceReference eventAdminRef = context->getServiceReference<ctkEventAdmin>();
   ctkEventAdmin* eventAdmin = nullptr;
   if (eventAdminRef)
   {
     eventAdmin = context->getService<ctkEventAdmin>(eventAdminRef);
   }
   if (eventAdmin == nullptr)
   {
     MITK_WARN << "ctkEventAdmin service not found. Unable to open context help";
   }
   else
   {
     ctkEvent ev("org/blueberry/ui/help/CONTEXTHELP_REQUESTED");
     eventAdmin->postEvent(ev);
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onHelpOpenHelpPerspective()
 {
   berry::PlatformUI::GetWorkbench()->ShowPerspective("org.blueberry.perspectives.help",
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow());
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onAbout()
 {
   auto aboutDialog = new QmitkAboutDialog(QApplication::activeWindow(), nullptr);
   aboutDialog->open();
 }
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.cpp b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.cpp
index f54284c507..a34c9c62f6 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.cpp
@@ -1,269 +1,269 @@
 /*============================================================================
 
 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 "org_mitk_gui_qt_matchpoint_algorithm_browser_Activator.h"
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkMatchPointBrowser.h"
 
 // Qt
 #include <QMessageBox>
 #include <QErrorMessage>
 #include <QDir>
 #include <QStringList>
 
 //MITK
 #include <mitkStatusBar.h>
 #include "MatchPointBrowserConstants.h"
 #include "mitkAlgorithmInfoSelectionProvider.h"
 #include <mitkCoreServices.h>
 #include <mitkIPreferencesService.h>
 #include <mitkIPreferences.h>
 
 // MatchPoint
 #include "mapRegistrationAlgorithmInterface.h"
 #include "mapAlgorithmEvents.h"
 #include "mapAlgorithmWrapperEvent.h"
 #include "mapExceptionObjectMacros.h"
 #include "mapDeploymentDLLDirectoryBrowser.h"
 #include "mapDeploymentEvents.h"
 
 const std::string QmitkMatchPointBrowser::VIEW_ID = "org.mitk.views.matchpoint.algorithm.browser";
 
 QmitkMatchPointBrowser::QmitkMatchPointBrowser()
     : m_Parent(nullptr), m_LoadedDLLHandle(nullptr), m_LoadedAlgorithm(nullptr)
 {
 }
 
 QmitkMatchPointBrowser::~QmitkMatchPointBrowser()
 {
 }
 
 void QmitkMatchPointBrowser::OnPreferencesChanged(const mitk::IPreferences* /*prefs*/)
 {
     this->OnSearchFolderButtonPushed();
 }
 
 void QmitkMatchPointBrowser::CreateConnections()
 {
     connect(m_Controls.m_pbSearchFolder, SIGNAL(clicked()), this, SLOT(OnSearchFolderButtonPushed()));
     connect(m_Controls.m_algoTreeView, SIGNAL(clicked(const QModelIndex&)), this,
         SLOT(OnAlgoListSelectionChanged(const QModelIndex&)));
     connect(m_Controls.pbClearSearch, SIGNAL(clicked()), m_Controls.lineSearch, SLOT(clear()));
     connect(m_Controls.lineSearch, SIGNAL(textChanged(const QString&)), this,
         SLOT(OnSearchChanged(const QString&)));
 }
 
 void QmitkMatchPointBrowser::OnSearchFolderButtonPushed()
 {
     RetrieveAndStorePreferenceValues();
     // test if some folder list non-empty
     int folderCount = m_currentSearchPaths.count();
 
     if (!folderCount)
     {
         Error(QString("No search folder selected for MatchPoint algorithm browser! Please set search paths in the MatchPoint preference page."));
         m_DLLInfoList.clear();
     }
     else
     {
         map::deployment::DLLDirectoryBrowser::Pointer browser = map::deployment::DLLDirectoryBrowser::New();
         auto validCommand = ::itk::MemberCommand<QmitkMatchPointBrowser>::New();
         validCommand->SetCallbackFunction(this, &QmitkMatchPointBrowser::OnValidDeploymentEvent);
         browser->AddObserver(::map::events::ValidDLLEvent(), validCommand);
         auto invalidCommand = ::itk::MemberCommand<QmitkMatchPointBrowser>::New();
         invalidCommand->SetCallbackFunction(this, &QmitkMatchPointBrowser::OnInvalidDeploymentEvent);
         browser->AddObserver(::map::events::InvalidDLLEvent(), invalidCommand);
 
         foreach(QString path, m_currentSearchPaths)
         {
             browser->addDLLSearchLocation(path.toStdString());
         }
 
         browser->update();
         m_DLLInfoList = browser->getLibraryInfos();
     }
 
     m_Controls.groupWarning->setVisible(m_DLLInfoList.empty());
     m_Controls.groupList->setVisible(!m_DLLInfoList.empty());
 
     m_algModel->SetAlgorithms(m_DLLInfoList);
     m_Controls.lineSearch->clear();
 }
 
 void QmitkMatchPointBrowser::OnAlgoListSelectionChanged(const QModelIndex& index)
 {
     QVariant vIndex = index.data(Qt::UserRole).toInt();
     map::deployment::DLLInfo::ConstPointer currentItemInfo = nullptr;
 
     if (vIndex.isValid())
     {
         std::size_t algListIndex = vIndex.toInt();
 
         if (algListIndex < m_DLLInfoList.size())
         {
             currentItemInfo = m_DLLInfoList[algListIndex];
         }
     }
 
     m_Controls.m_teAlgorithmDetails->updateInfo(currentItemInfo);
 
     if (currentItemInfo)
     {
         //update selection provider
         mitk::MAPAlgorithmInfoSelection::Pointer infoSelection = mitk::MAPAlgorithmInfoSelection::Pointer(
             new mitk::MAPAlgorithmInfoSelection(currentItemInfo));
         this->m_SelectionProvider->SetInfoSelection(infoSelection);
     }
 }
 
 
 void QmitkMatchPointBrowser::OnSearchChanged(const QString& text)
 {
-    m_filterProxy->setFilterRegExp(text);
+    m_filterProxy->setFilterRegularExpression(text);
     m_filterProxy->setFilterCaseSensitivity(Qt::CaseInsensitive);
 };
 
 void QmitkMatchPointBrowser::OnInvalidDeploymentEvent(const ::itk::Object *, const itk::EventObject &event)
 {
   auto deployEvent = dynamic_cast<const ::map::events::InvalidDLLEvent*>(&event);
 
   this->Error(QString("Error when try to inspect deployed registration algorithm. Details: ")+QString::fromStdString(deployEvent->getComment()));
 }
 
 void QmitkMatchPointBrowser::OnValidDeploymentEvent(const ::itk::Object *, const itk::EventObject &event)
 {
   auto deployEvent = dynamic_cast<const ::map::events::ValidDLLEvent*>(&event);
 
   auto info = static_cast<const ::map::deployment::DLLInfo*>(deployEvent->getData());
 
   MITK_INFO << "Successfully inspected deployed registration algorithm. UID: " << info->getAlgorithmUID().toStr() << ". Path: " << info->getLibraryFilePath();
 
 }
 
 
 void QmitkMatchPointBrowser::CreateQtPartControl(QWidget* parent)
 {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls.setupUi(parent);
     m_Parent = parent;
 
     m_algModel = new QmitkAlgorithmListModel(parent);
     m_filterProxy = new QSortFilterProxyModel(parent);
 
     //! [Qt Selection Provider registration]
     // create new qt selection provider
     m_SelectionProvider = new mitk::AlgorithmInfoSelectionProvider();
 
     m_filterProxy->setSourceModel(m_algModel);
     m_filterProxy->setDynamicSortFilter(true);
     m_filterProxy->setFilterKeyColumn(-1);
     m_Controls.m_algoTreeView->setModel(m_filterProxy);
     m_Controls.m_algoTreeView->setSelectionMode(QAbstractItemView::SingleSelection);
 
     m_Controls.m_algoTreeView->header()->setStretchLastSection(false);
     m_Controls.m_algoTreeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
     m_Controls.m_algoTreeView->setColumnHidden(3, true);
 
     this->CreateConnections();
 }
 
 void QmitkMatchPointBrowser::SetSelectionProvider()
 {
     this->GetSite()->SetSelectionProvider(m_SelectionProvider);
 }
 
 void QmitkMatchPointBrowser::SetFocus()
 {
 }
 
 void QmitkMatchPointBrowser::Error(QString msg)
 {
     mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
     MITK_ERROR << msg.toStdString().c_str();
 }
 
 void QmitkMatchPointBrowser::RetrieveAndStorePreferenceValues()
 {
     auto* prefs = this->RetrievePreferences();
 
     bool loadApplicationDir = prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_APPLICATION_DIR, true);
     bool loadHomeDir = prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_HOME_DIR, false);
     bool loadCurrentDir = prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_CURRENT_DIR, false);
     bool loadAutoLoadDir = prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_AUTO_LOAD_DIR, false);
 
     // Get some default application paths.
     QStringList newPaths;
 
     // Here we can use the preferences to set up the builder,
     if (loadApplicationDir)
     {
         newPaths << QCoreApplication::applicationDirPath();
     }
 
     if (loadHomeDir)
     {
         newPaths << QDir::homePath();
     }
 
     if (loadCurrentDir)
     {
         newPaths << QDir::currentPath();
     }
 
     if (loadAutoLoadDir)
     {
         char* deployedAlgorithmLoadPath = getenv("MAP_MDRA_LOAD_PATH");
 
         if (deployedAlgorithmLoadPath != nullptr)
         {
             // The load path may in fact be a semi-colon or colon separated list of directories, not just one.
             QString paths(deployedAlgorithmLoadPath);
 
 #ifdef Q_OS_WIN32
             QString pathSeparator(";");
 #else
             QString pathSeparator(":");
 #endif
 
             QStringList splitPath = paths.split(pathSeparator, Qt::SkipEmptyParts);
 
             foreach(QString path, splitPath)
             {
                 QDir dir = QDir(path);
                 newPaths << dir.absolutePath();
             }
         }
 
     }
 
     // We get additional directory paths from preferences.
     const auto pathString = QString::fromStdString(prefs->Get(MatchPointBrowserConstants::MDAR_DIRECTORIES_NODE_NAME, ""));
     QStringList additionalPaths = pathString.split(";", Qt::SkipEmptyParts);
     newPaths << additionalPaths;
 
     const auto additionalAlgorirthmsString = QString::fromStdString(prefs->Get(MatchPointBrowserConstants::MDAR_FILES_NODE_NAME, ""));
     additionalPaths = additionalAlgorirthmsString.split(";", Qt::SkipEmptyParts);
     newPaths << additionalPaths;
 
     m_currentSearchPaths = newPaths;
 }
 
 mitk::IPreferences* QmitkMatchPointBrowser::RetrievePreferences()
 {
   const auto id = "/" + MatchPointBrowserConstants::VIEW_ID;
   return mitk::CoreServices::GetPreferencesService()->GetSystemPreferences()->Node(id);
 }
diff --git a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.cpp b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.cpp
index 5a2270499a..061fecfaa5 100644
--- a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.cpp
@@ -1,531 +1,531 @@
 /*============================================================================
 
 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 <memory>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkAddNewPropertyDialog.h"
 #include "QmitkOverlayManagerView.h"
 #include "QmitkPropertyItemDelegate.h"
 #include "QmitkPropertyItemModel.h"
 #include <QmitkRenderWindow.h>
 
 // Qt
 #include <QMessageBox>
 #include <QPainter>
 #include <QSortFilterProxyModel>
 
 #include "internal/org_mitk_gui_qt_overlaymanager_Activator.h"
 
 #include "mitkAnnotationUtils.h"
 #include "mitkGetPropertyService.h"
 #include "mitkLayoutAnnotationRenderer.h"
 #include "mitkManualPlacementAnnotationRenderer.h"
 #include "mitkRenderingManager.h"
 #include <mitkColorBarAnnotation.h>
 #include <mitkIPropertyAliases.h>
 #include <mitkIPropertyDescriptions.h>
 #include <mitkIPropertyPersistence.h>
 #include <mitkLabelAnnotation3D.h>
 #include <mitkLogoAnnotation.h>
 #include <mitkScaleLegendAnnotation.h>
 #include <mitkTextAnnotation2D.h>
 #include <mitkTextAnnotation3D.h>
 
 const std::string QmitkOverlayManagerView::VIEW_ID = "org.mitk.views.overlaymanager";
 
 QmitkOverlayManagerView::QmitkOverlayManagerView()
   : m_Parent(nullptr),
     m_PropertyNameChangedTag(0),
     m_OverlayManagerObserverTag(0),
     m_PropertyAliases(nullptr),
     m_PropertyDescriptions(nullptr),
     m_PropertyPersistence(nullptr),
     m_ProxyModel(nullptr),
     m_Model(nullptr),
     m_Delegate(nullptr),
     m_Renderer(nullptr),
     m_AddOverlayMenu(nullptr)
 {
 }
 
 QmitkOverlayManagerView::~QmitkOverlayManagerView()
 {
 }
 
 void QmitkOverlayManagerView::SetFocus()
 {
 }
 
 void QmitkOverlayManagerView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   m_Controls.m_OverlayList->clear();
 
   auto* renderWindowPart = this->GetRenderWindowPart();
 
   if (renderWindowPart != nullptr)
   {
     QHash<QString, QmitkRenderWindow *> renderWindows = renderWindowPart->GetQmitkRenderWindows();
 
     Q_FOREACH (QString renderWindow, renderWindows.keys())
     {
       if (!m_Renderer)
         m_Renderer = renderWindows[renderWindow]->GetRenderer();
       m_Controls.m_RendererCB->addItem(renderWindow);
     }
   }
 
   InitializeAddOverlayMenu();
 
   m_ProxyModel = new QSortFilterProxyModel(m_Controls.m_PropertyTree);
   m_Model = new QmitkPropertyItemModel(m_ProxyModel);
 
   m_ProxyModel->setSourceModel(m_Model);
   m_ProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
   m_ProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
   m_ProxyModel->setDynamicSortFilter(true);
 
   m_Delegate = new QmitkPropertyItemDelegate(m_Controls.m_PropertyTree);
 
   m_Controls.m_PropertyTree->setItemDelegateForColumn(1, m_Delegate);
   m_Controls.m_PropertyTree->setModel(m_ProxyModel);
   m_Controls.m_PropertyTree->setColumnWidth(0, 160);
   m_Controls.m_PropertyTree->sortByColumn(0, Qt::AscendingOrder);
   m_Controls.m_PropertyTree->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_Controls.m_PropertyTree->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.m_PropertyTree->setEditTriggers(QAbstractItemView::SelectedClicked | QAbstractItemView::DoubleClicked);
 
   connect(m_Controls.m_RendererCB, SIGNAL(currentIndexChanged(int)), this, SLOT(OnPropertyListChanged(int)));
   connect(m_Controls.newButton, SIGNAL(clicked()), this, SLOT(OnAddNewProperty()));
   connect(m_Controls.m_PropertyTree->selectionModel(),
           SIGNAL(currentRowChanged(const QModelIndex &, const QModelIndex &)),
           this,
           SLOT(OnCurrentRowChanged(const QModelIndex &, const QModelIndex &)));
   connect(m_Controls.m_OverlayList,
           SIGNAL(currentItemChanged(QListWidgetItem *, QListWidgetItem *)),
           this,
           SLOT(OnOverlaySelectionChanged(QListWidgetItem *, QListWidgetItem *)));
   connect(m_Controls.m_DeleteOverlay, SIGNAL(clicked()), this, SLOT(OnDelete()));
   connect(m_Controls.m_AddOverlay, SIGNAL(clicked()), this, SLOT(OnAddOverlay()));
 
   itk::MemberCommand<QmitkOverlayManagerView>::Pointer command = itk::MemberCommand<QmitkOverlayManagerView>::New();
   command->SetCallbackFunction(this, &QmitkOverlayManagerView::OnFocusChanged);
   m_RenderWindowFocusObserverTag =
     mitk::RenderingManager::GetInstance()->AddObserver(mitk::FocusChangedEvent(), command);
 }
 
 void QmitkOverlayManagerView::OnFocusChanged(itk::Object * /*caller*/, const itk::EventObject &event)
 {
   const mitk::FocusChangedEvent *focusEvent = dynamic_cast<const mitk::FocusChangedEvent *>(&event);
   if (focusEvent)
   {
     QHash<QString, QmitkRenderWindow *> renderWindows = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindows();
     m_Controls.m_RendererCB->clear();
     Q_FOREACH (QString renderWindow, renderWindows.keys())
     {
       m_Controls.m_RendererCB->addItem(renderWindow);
       if (renderWindows[renderWindow]->GetVtkRenderWindow() ==
           mitk::RenderingManager::GetInstance()->GetFocusedRenderWindow())
       {
         m_Controls.m_RendererCB->setCurrentText(renderWindow);
       }
     }
     this->OnActivateOverlayList();
   }
 }
 
 QString QmitkOverlayManagerView::GetPropertyNameOrAlias(const QModelIndex &index)
 {
   QString propertyName;
 
   if (index.isValid())
   {
     QModelIndex current = index;
 
     while (current.isValid())
     {
       QString name = m_ProxyModel->data(m_ProxyModel->index(current.row(), 0, current.parent())).toString();
 
       propertyName.prepend(propertyName.isEmpty() ? name : name.append('.'));
 
       current = current.parent();
     }
   }
 
   return propertyName;
 }
 
 void QmitkOverlayManagerView::OnCurrentRowChanged(const QModelIndex &current, const QModelIndex &)
 {
   if (m_PropertyDescriptions != nullptr && current.isValid())
   {
     QString name = this->GetPropertyNameOrAlias(current);
 
     if (!name.isEmpty())
     {
       QString alias;
       bool isTrueName = true;
 
       if (m_PropertyAliases != nullptr)
       {
         std::string trueName = m_PropertyAliases->GetPropertyName(name.toStdString());
 
         if (trueName.empty() && !m_SelectionClassName.empty())
           trueName = m_PropertyAliases->GetPropertyName(name.toStdString(), m_SelectionClassName);
 
         if (!trueName.empty())
         {
           alias = name;
           name = QString::fromStdString(trueName);
           isTrueName = false;
         }
       }
 
       QString description = QString::fromStdString(m_PropertyDescriptions->GetDescription(name.toStdString()));
       std::vector<std::string> aliases;
 
       if (!isTrueName && m_PropertyAliases != nullptr)
       {
         aliases = m_PropertyAliases->GetAliases(name.toStdString(), m_SelectionClassName);
 
         if (aliases.empty() && !m_SelectionClassName.empty())
           aliases = m_PropertyAliases->GetAliases(name.toStdString());
       }
 
       bool isPersistent = false;
       // QString persistenceKey;
 
       if (m_PropertyPersistence != nullptr)
       {
         isPersistent = m_PropertyPersistence->HasInfo(name.toStdString());
 
         /*if (isPersistent)
         {
           persistenceKey = QString::fromStdString(m_PropertyPersistence->GetInfo(name.toStdString())->GetKey());
 
           if (persistenceKey.isEmpty())
             persistenceKey = name;
         }*/
       }
 
       if (!description.isEmpty() || !aliases.empty() || isPersistent)
       {
         QString customizedDescription;
 
         if (!description.isEmpty())
           customizedDescription += "<p>" + description + "</p>";
 
         if (!aliases.empty() || isPersistent)
         {
           customizedDescription += "<div align=\"right\">";
 
           if (!aliases.empty())
           {
             customizedDescription += aliases.size() > 1 ?
                                        "<img height=\"32\" src=\":/org_mitk_icons/icons/awesome/scalable/tags.svg\"/>" :
                                        "<img height=\"32\" src=\":/org_mitk_icons/icons/awesome/scalable/tag.svg\"/>";
           }
 
           if (isPersistent)
             customizedDescription +=
               "<img height=\"32\" src=\":/org_mitk_icons/icons/awesome/scalable/actions/document-save.svg\"/>";
 
           customizedDescription += "</div>";
         }
 
         return;
       }
     }
   }
 }
 
 void QmitkOverlayManagerView::OnPropertyNameChanged(const itk::EventObject &)
 {
   mitk::PropertyList *propertyList = m_Model->GetPropertyList();
 
   if (propertyList != nullptr)
   {
     mitk::BaseProperty *nameProperty = propertyList->GetProperty("name");
 
     if (nameProperty != nullptr)
     {
       QString partName = "Properties (";
       partName.append(QString::fromStdString(nameProperty->GetValueAsString())).append(')');
       this->SetPartName(partName);
     }
   }
 }
 
 void QmitkOverlayManagerView::OnSelectionChanged(berry::IWorkbenchPart::Pointer,
                                                  const QList<mitk::DataNode::Pointer> &)
 {
 }
 
 void QmitkOverlayManagerView::InitializeAddOverlayMenu()
 {
   m_AddOverlayMenu = new QMenu(m_Controls.m_AddOverlay);
 
   m_AddOverlayMenu->addAction("TextAnnotation2D");
   m_AddOverlayMenu->addAction("TextAnnotation3D");
   m_AddOverlayMenu->addAction("LabelAnnotation");
   m_AddOverlayMenu->addAction("ColorBarAnnotation");
   m_AddOverlayMenu->addAction("ScaleLegendAnnotation");
   m_AddOverlayMenu->addAction("LogoAnnotation");
 }
 
 void QmitkOverlayManagerView::Activated()
 {
   //  this->OnActivateOverlayList();
 }
 
 void QmitkOverlayManagerView::Deactivated()
 {
 }
 
 void QmitkOverlayManagerView::Visible()
 {
   this->OnActivateOverlayList();
 }
 
 void QmitkOverlayManagerView::Hidden()
 {
 }
 
 void QmitkOverlayManagerView::OnPropertyListChanged(int index)
 {
   if (index == -1)
     return;
 
   QString renderer = m_Controls.m_RendererCB->itemText(index);
 
   auto *renwin = this->GetRenderWindowPart()->GetQmitkRenderWindow(renderer);
   m_Renderer = renwin ? renwin->GetRenderer() : nullptr;
 
   this->OnOverlaySelectionChanged(m_Controls.m_OverlayList->currentItem(), nullptr);
   this->OnActivateOverlayList();
 }
 
 void QmitkOverlayManagerView::OnAddNewProperty()
 {
   std::unique_ptr<QmitkAddNewPropertyDialog> dialog(
     new QmitkAddNewPropertyDialog(m_SelectedOverlay, m_Renderer, m_Parent));
 
   if (dialog->exec() == QDialog::Accepted)
     this->m_Model->Update();
 }
 
 void QmitkOverlayManagerView::OnActivateOverlayList()
 {
   if (!m_Renderer)
     return;
   std::vector<mitk::AbstractAnnotationRenderer *> arList =
     mitk::AnnotationUtils::GetAnnotationRenderer(m_Renderer->GetName());
   m_Controls.m_OverlayList->clear();
   for (auto ar : arList)
   {
     for (auto overlay : ar->GetServices())
     {
       QListWidgetItem *item = new QListWidgetItem();
       item->setData(Qt::UserRole, QVariant(overlay->GetMicroserviceID().c_str()));
       QString text(overlay->GetName().c_str());
       if (text.length() > 0)
       {
         text.append(" : ");
       }
       text.append(overlay->GetNameOfClass());
       item->setText(text);
       m_Controls.m_OverlayList->addItem(item);
     }
   }
 }
 
 void QmitkOverlayManagerView::OnOverlaySelectionChanged(QListWidgetItem *current, QListWidgetItem *)
 {
   mitk::PropertyList *propertyList = m_Model->GetPropertyList();
 
   if (propertyList != nullptr)
   {
     mitk::BaseProperty *nameProperty = propertyList->GetProperty("name");
 
     if (nameProperty != nullptr)
       nameProperty->RemoveObserver(m_PropertyNameChangedTag);
 
     m_PropertyNameChangedTag = 0;
   }
 
   mitk::Annotation *overlay = nullptr;
   QString oID;
   if (current)
   {
     oID = current->data(Qt::UserRole).toString();
     OverlayMapType::iterator it = m_OverlayMap.find(oID.toStdString());
     if (it != m_OverlayMap.end())
       overlay = it->second;
     else
     {
       overlay = mitk::AnnotationUtils::GetAnnotation(oID.toStdString());
     }
   }
 
   if (!overlay)
   {
     m_SelectedOverlay = nullptr;
 
     this->SetPartName("Overlay Properties");
     m_Model->SetPropertyList(nullptr);
     m_Delegate->SetPropertyList(nullptr);
 
     m_Controls.newButton->setEnabled(false);
   }
   else
   {
     m_SelectedOverlay = overlay;
 
     QString selectionClassName = m_SelectedOverlay->GetNameOfClass();
 
     m_SelectionClassName = selectionClassName.toStdString();
 
     mitk::PropertyList::Pointer propertyList = overlay->GetPropertyList();
 
     m_Model->SetPropertyList(propertyList, selectionClassName);
     m_Delegate->SetPropertyList(propertyList);
 
     OnPropertyNameChanged(itk::ModifiedEvent());
 
     mitk::BaseProperty *nameProperty = m_SelectedOverlay->GetProperty("name");
 
     if (nameProperty != nullptr)
     {
       itk::ReceptorMemberCommand<QmitkOverlayManagerView>::Pointer command =
         itk::ReceptorMemberCommand<QmitkOverlayManagerView>::New();
       command->SetCallbackFunction(this, &QmitkOverlayManagerView::OnPropertyNameChanged);
       m_PropertyNameChangedTag = nameProperty->AddObserver(itk::ModifiedEvent(), command);
     }
 
     m_Controls.newButton->setEnabled(true);
   }
 
-  if (!m_ProxyModel->filterRegExp().isEmpty())
+  if (!m_ProxyModel->filterRegularExpression().pattern().isEmpty())
     m_Controls.m_PropertyTree->expandAll();
 }
 
 void QmitkOverlayManagerView::OnDelete()
 {
   if (m_SelectedOverlay.IsNotNull())
   {
     m_OverlayMap.erase(m_SelectedOverlay->GetMicroserviceID());
     m_SelectedOverlay = nullptr;
     OnActivateOverlayList();
   }
 }
 
 void QmitkOverlayManagerView::OnAddOverlay()
 {
   QAction *action = m_AddOverlayMenu->exec(QCursor::pos());
 
   mitk::Annotation::Pointer overlay;
 
   if (action != nullptr)
   {
     const QString widgetKey = action->text();
 
     if (widgetKey == "TextAnnotation2D")
       overlay = CreateTextOverlay2D();
 
     else if (widgetKey == "TextAnnotation3D")
       overlay = CreateTextOverlay3D();
 
     else if (widgetKey == "LabelAnnotation")
       overlay = CreateLabelOverlay();
 
     else if (widgetKey == "ColorBarAnnotation")
       overlay = CreateColorBarOverlay();
 
     else if (widgetKey == "ScaleLegendAnnotation")
       overlay = CreateScaleLegendOverlay();
 
     else if (widgetKey == "LogoAnnotation")
       overlay = CreateLogoOverlay();
 
     mitk::BaseRenderer *renderer =
       this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow(m_Controls.m_RendererCB->currentText())->GetRenderer();
     mitk::LayoutAnnotationRenderer::AddAnnotation(overlay, renderer);
     m_OverlayMap[overlay->GetMicroserviceID()] = overlay;
   }
   OnActivateOverlayList();
 }
 
 mitk::Annotation::Pointer QmitkOverlayManagerView::CreateTextOverlay2D()
 {
   mitk::TextAnnotation2D::Pointer to = mitk::TextAnnotation2D::New();
   to->SetText("Test");
   return to.GetPointer();
 }
 
 mitk::Annotation::Pointer QmitkOverlayManagerView::CreateTextOverlay3D()
 {
   mitk::TextAnnotation3D::Pointer to = mitk::TextAnnotation3D::New();
   return to.GetPointer();
 }
 
 mitk::Annotation::Pointer QmitkOverlayManagerView::CreateLabelOverlay()
 {
   mitk::LabelAnnotation3D::Pointer to = mitk::LabelAnnotation3D::New();
   return to.GetPointer();
 }
 
 mitk::Annotation::Pointer QmitkOverlayManagerView::CreateColorBarOverlay()
 {
   mitk::ColorBarAnnotation::Pointer to = mitk::ColorBarAnnotation::New();
   return to.GetPointer();
 }
 
 mitk::Annotation::Pointer QmitkOverlayManagerView::CreateScaleLegendOverlay()
 {
   mitk::ScaleLegendAnnotation::Pointer to = mitk::ScaleLegendAnnotation::New();
   return to.GetPointer();
 }
 
 mitk::Annotation::Pointer QmitkOverlayManagerView::CreateLogoOverlay()
 {
   mitk::LogoAnnotation::Pointer to = mitk::LogoAnnotation::New();
   return to.GetPointer();
 }
 
 void QmitkOverlayManagerView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_Controls.m_RendererCB->count() == 0)
   {
     QHash<QString, QmitkRenderWindow *> renderWindows = renderWindowPart->GetQmitkRenderWindows();
 
     Q_FOREACH (QString renderWindow, renderWindows.keys())
     {
       m_Controls.m_RendererCB->addItem(renderWindow);
     }
   }
   OnActivateOverlayList();
 }
 
 void QmitkOverlayManagerView::RenderWindowPartDeactivated(mitk::IRenderWindowPart *)
 {
   if (m_Controls.m_RendererCB->count() > 0)
   {
     m_Controls.m_RendererCB->clear();
   }
   m_Controls.m_OverlayList->clear();
 }
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemSortFilterProxyModel.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemSortFilterProxyModel.cpp
index c0cceb0cdb..ae94c7b090 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemSortFilterProxyModel.cpp
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemSortFilterProxyModel.cpp
@@ -1,54 +1,54 @@
 /*============================================================================
 
 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 "QmitkPropertyItemSortFilterProxyModel.h"
 
 QmitkPropertyItemSortFilterProxyModel::QmitkPropertyItemSortFilterProxyModel(QObject* parent)
   : QSortFilterProxyModel(parent)
 {
 }
 
 QmitkPropertyItemSortFilterProxyModel::~QmitkPropertyItemSortFilterProxyModel()
 {
 }
 
 bool QmitkPropertyItemSortFilterProxyModel::FilterAcceptsAnyChildRow(const QModelIndex& sourceParent) const
 {
   QString propertyName = this->sourceModel()->data(sourceParent).toString();
 
-  if (propertyName.contains(this->filterRegExp()))
+  if (propertyName.contains(this->filterRegularExpression()))
     return true;
 
   if (this->sourceModel()->hasChildren(sourceParent))
   {
     for (int row = 0; row < this->sourceModel()->rowCount(sourceParent); ++row)
     {
       if(this->FilterAcceptsAnyChildRow(this->sourceModel()->index(row, 0, sourceParent)))
         return true;
     }
   }
 
   return false;
 }
 
 bool QmitkPropertyItemSortFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const
 {
   return this->FilterAcceptsAnyChildRow(this->sourceModel()->index(sourceRow, 0, sourceParent));
 }
 
 bool QmitkPropertyItemSortFilterProxyModel::lessThan(const QModelIndex& left, const QModelIndex& right) const
 {
   QString leftString = this->sourceModel()->data(left).toString();
   QString rightString = this->sourceModel()->data(right).toString();
 
   return leftString.compare(rightString, this->sortCaseSensitivity()) < 0;
 }
diff --git a/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp b/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp
index d431fa5643..44be82cacb 100644
--- a/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.viewnavigator/src/QmitkViewNavigatorWidget.cpp
@@ -1,730 +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(filterRegExp()))
+    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(filterRegExp()))
+            if (tag.contains(filterRegularExpression()))
             {
                 return true;
             }
         }
-        if (viewItem->m_Description.contains(filterRegExp()))
+        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(filterRegExp()))
+            if (tag.contains(filterRegularExpression()))
             {
                 return true;
             }
         }
-        if (perspectiveItem->m_Description.contains(filterRegExp()))
+        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();
 
-    Qt::CaseSensitivity caseSensitivity = Qt::CaseInsensitive;
     QString strPattern = "^*" + filterString;
-    QRegExp regExp(strPattern, caseSensitivity);
+    QRegularExpression regExp(strPattern, QRegularExpression::CaseInsensitiveOption);
 
-    m_FilterProxyModel->setFilterRegExp(regExp);
+    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);
 
   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);
 
   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);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
index 5eaf8a507d..7c69d7a407 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
@@ -1,296 +1,296 @@
 /*============================================================================
 
 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 "QmitkXnatConnectionPreferencePage.h"
 #include "QmitkXnatTreeBrowserView.h"
 
 #include "org_mitk_gui_qt_xnatinterface_Activator.h"
 
 #include <QFileDialog>
 #include <QLabel>
 #include <QPushButton>
 #include <QLineEdit>
 #include <QGridLayout>
 #include <QMessageBox>
 #include <QApplication>
 #include <QMap>
 
 #include "ctkXnatSession.h"
 #include "ctkXnatLoginProfile.h"
 #include "ctkXnatException.h"
 
 #include <mitkIOUtil.h>
 #include <mitkCoreServices.h>
 #include <mitkIPreferencesService.h>
 #include <mitkIPreferences.h>
 
 using namespace berry;
 
 namespace
 {
   mitk::IPreferences* GetPreferences()
   {
     auto* preferencesService = mitk::CoreServices::GetPreferencesService();
     return preferencesService->GetSystemPreferences()->Node(QmitkXnatTreeBrowserView::VIEW_ID.toStdString());
   }
 }
 
 QmitkXnatConnectionPreferencePage::QmitkXnatConnectionPreferencePage()
   : m_Control(nullptr)
 {
 }
 
 void QmitkXnatConnectionPreferencePage::Init(berry::IWorkbench::Pointer)
 {
 }
 
 void QmitkXnatConnectionPreferencePage::CreateQtControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   m_Control = new QWidget(parent);
   m_Control->setLayout(m_Controls.gridLayout);
 
   ctkXnatSession* session;
 
   try
   {
     session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
           mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
   }
   catch (std::invalid_argument&)
   {
     session = nullptr;
   }
 
   if (session != nullptr && session->isOpen())
   {
     m_Controls.xnatTestConnectionLabel->setStyleSheet("color: green");
     m_Controls.xnatTestConnectionLabel->setText("Already connected.");
     m_Controls.xnatTestConnectionButton->setEnabled(false);
   }
   const QIntValidator *portV = new QIntValidator(0, 65535, parent);
   m_Controls.inXnatPort->setValidator(portV);
 
-  const QRegExp hostRx("^(https?)://[^ /](\\S)+$");
-  const QRegExpValidator *hostV = new QRegExpValidator(hostRx, parent);
+  const QRegularExpression hostRx("^(https?)://[^ /](\\S)+$");
+  const QRegularExpressionValidator *hostV = new QRegularExpressionValidator(hostRx, parent);
   m_Controls.inXnatHostAddress->setValidator(hostV);
 
   connect(m_Controls.xnatTestConnectionButton, SIGNAL(clicked()), this, SLOT(TestConnection()));
 
   connect(m_Controls.inXnatHostAddress, SIGNAL(editingFinished()), this, SLOT(UrlChanged()));
   connect(m_Controls.inXnatDownloadPath, SIGNAL(editingFinished()), this, SLOT(DownloadPathChanged()));
 
   connect(m_Controls.cbUseNetworkProxy, SIGNAL(toggled(bool)), this, SLOT(onUseNetworkProxy(bool)));
 
   connect(m_Controls.btnDownloadPath, SIGNAL(clicked()), this, SLOT(OnDownloadPathButtonClicked()));
 
   m_Controls.groupBoxProxySettings->setVisible(m_Controls.cbUseNetworkProxy->isChecked());
 
   this->Update();
 }
 
 QWidget* QmitkXnatConnectionPreferencePage::GetQtControl() const
 {
   return m_Control;
 }
 
 bool QmitkXnatConnectionPreferencePage::PerformOk()
 {
   auto* prefs = GetPreferences();
 
   if (prefs != nullptr)
   {
     prefs->Put(m_Controls.xnatHostAddressLabel->text().toStdString(), m_Controls.inXnatHostAddress->text().toStdString());
     prefs->Put(m_Controls.xnatPortLabel->text().toStdString(), m_Controls.inXnatPort->text().toStdString());
     prefs->Put(m_Controls.xnatUsernameLabel->text().toStdString(), m_Controls.inXnatUsername->text().toStdString());
     prefs->Put(m_Controls.xnatPasswortLabel->text().toStdString(), m_Controls.inXnatPassword->text().toStdString());
     prefs->Put(m_Controls.xnatDownloadPathLabel->text().toStdString(), m_Controls.inXnatDownloadPath->text().toStdString());
 
     // Network proxy settings
     prefs->PutBool(m_Controls.cbUseNetworkProxy->text().toStdString(), m_Controls.cbUseNetworkProxy->isChecked());
     prefs->Put(m_Controls.proxyAddressLabel->text().toStdString(), m_Controls.inProxyAddress->text().toStdString());
     prefs->Put(m_Controls.proxyPortLabel->text().toStdString(), m_Controls.inProxyPort->text().toStdString());
     prefs->Put(m_Controls.proxyUsernameLabel->text().toStdString(), m_Controls.inProxyUsername->text().toStdString());
     prefs->Put(m_Controls.proxyPasswordLabel->text().toStdString(), m_Controls.inProxyPassword->text().toStdString());
 
     // Silent Mode
     prefs->PutBool(m_Controls.cbUseSilentMode->text().toStdString(), m_Controls.cbUseSilentMode->isChecked());
 
     //Write
     prefs->Flush();
 
     return true;
   }
   return false;
 }
 
 void QmitkXnatConnectionPreferencePage::PerformCancel()
 {
 }
 
 bool QmitkXnatConnectionPreferencePage::UserInformationEmpty()
 {
   // To check empty QLineEdits in the following
   QString errString;
 
   if (m_Controls.inXnatHostAddress->text().isEmpty())
   {
     errString += "Server Address is empty.\n";
   }
 
   if (m_Controls.inXnatUsername->text().isEmpty())
   {
     errString += "Username is empty.\n";
   }
 
   if (m_Controls.inXnatPassword->text().isEmpty())
   {
     errString += "Password is empty.\n";
   }
 
   // if something is empty
   if (!errString.isEmpty())
   {
     m_Controls.xnatTestConnectionLabel->setStyleSheet("color: red");
     m_Controls.xnatTestConnectionLabel->setText("Connecting failed.\n" + errString);
     return true;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkXnatConnectionPreferencePage::Update()
 {
   auto* prefs = GetPreferences();
 
   if (prefs != nullptr)
   {
     m_Controls.inXnatHostAddress->setText(QString::fromStdString(prefs->Get(m_Controls.xnatHostAddressLabel->text().toStdString(), m_Controls.inXnatHostAddress->text().toStdString())));
     m_Controls.inXnatPort->setText(QString::fromStdString(prefs->Get(m_Controls.xnatPortLabel->text().toStdString(), m_Controls.inXnatPort->text().toStdString())));
     m_Controls.inXnatUsername->setText(QString::fromStdString(prefs->Get(m_Controls.xnatUsernameLabel->text().toStdString(), m_Controls.inXnatUsername->text().toStdString())));
     m_Controls.inXnatPassword->setText(QString::fromStdString(prefs->Get(m_Controls.xnatPasswortLabel->text().toStdString(), m_Controls.inXnatPassword->text().toStdString())));
     m_Controls.inXnatDownloadPath->setText(QString::fromStdString(prefs->Get(m_Controls.xnatDownloadPathLabel->text().toStdString(), m_Controls.inXnatDownloadPath->text().toStdString())));
 
     // Network proxy settings
     m_Controls.cbUseNetworkProxy->setChecked(prefs->GetBool(m_Controls.cbUseNetworkProxy->text().toStdString(), false));
     m_Controls.inProxyAddress->setText(QString::fromStdString(prefs->Get(m_Controls.proxyAddressLabel->text().toStdString(), m_Controls.inProxyAddress->text().toStdString())));
     m_Controls.inProxyPort->setText(QString::fromStdString(prefs->Get(m_Controls.proxyPortLabel->text().toStdString(), m_Controls.inProxyPort->text().toStdString())));
     m_Controls.inProxyUsername->setText(QString::fromStdString(prefs->Get(m_Controls.proxyUsernameLabel->text().toStdString(), m_Controls.inProxyUsername->text().toStdString())));
     m_Controls.inProxyPassword->setText(QString::fromStdString(prefs->Get(m_Controls.proxyPasswordLabel->text().toStdString(), m_Controls.inProxyPassword->text().toStdString())));
 
     // Silent Mode
     m_Controls.cbUseSilentMode->setChecked(prefs->GetBool(m_Controls.cbUseSilentMode->text().toStdString(), false));
   }
 }
 
 void QmitkXnatConnectionPreferencePage::UrlChanged()
 {
   m_Controls.inXnatHostAddress->setStyleSheet("");
   QString str = m_Controls.inXnatHostAddress->text();
 
   while (str.endsWith("/"))
   {
     str = str.left(str.length() - 1);
   }
 
   m_Controls.inXnatHostAddress->setText(str);
 
   QUrl url(m_Controls.inXnatHostAddress->text());
   if (!url.isValid())
   {
     m_Controls.inXnatHostAddress->setStyleSheet("background-color: red");
   }
 }
 
 void QmitkXnatConnectionPreferencePage::DownloadPathChanged()
 {
   m_Controls.inXnatDownloadPath->setStyleSheet("");
   QString downloadPath = m_Controls.inXnatDownloadPath->text();
   if (!downloadPath.isEmpty())
   {
     if (downloadPath.lastIndexOf("/") != downloadPath.size() - 1)
     {
       downloadPath.append("/");
       m_Controls.inXnatDownloadPath->setText(downloadPath);
     }
     QFileInfo path(m_Controls.inXnatDownloadPath->text());
     if (!path.isDir())
     {
       m_Controls.inXnatDownloadPath->setStyleSheet("background-color: red");
     }
   }
 }
 
 void QmitkXnatConnectionPreferencePage::onUseNetworkProxy(bool status)
 {
   m_Controls.groupBoxProxySettings->setVisible(status);
 }
 
 void QmitkXnatConnectionPreferencePage::OnDownloadPathButtonClicked()
 {
   QString dir = QFileDialog::getExistingDirectory();
   if (!dir.endsWith("/") || !dir.endsWith("\\"))
     dir.append("/");
   m_Controls.inXnatDownloadPath->setText(dir);
 }
 
 void QmitkXnatConnectionPreferencePage::TestConnection()
 {
   if(UserInformationEmpty())
   {
     return;
   }
 
   try
   {
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
   }
   catch (const std::invalid_argument &)
   {
     if (!UserInformationEmpty())
     {
       PerformOk();
 
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CreateXnatSession();
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
         mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
     }
   }
 
   try
   {
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->OpenXnatSession();
 
     m_Controls.xnatTestConnectionLabel->setStyleSheet("color: green");
     m_Controls.xnatTestConnectionLabel->setText("Connecting successful.");
 
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
   }
   catch (const ctkXnatAuthenticationException& auth)
   {
     m_Controls.xnatTestConnectionLabel->setStyleSheet("color: red");
     m_Controls.xnatTestConnectionLabel->setText("Connecting failed:\nAuthentication error.");
     MITK_INFO << auth.message().toStdString();
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
   }
   catch (const ctkException& e)
   {
     m_Controls.xnatTestConnectionLabel->setStyleSheet("color: red");
     m_Controls.xnatTestConnectionLabel->setText("Connecting failed:\nInvalid Server Address\nPossibly due to missing OpenSSL for HTTPS connections");
     MITK_INFO << e.message().toStdString();
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatEditor.cpp b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatEditor.cpp
index 20d52799b8..7d393bfb13 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatEditor.cpp
@@ -1,571 +1,570 @@
 /*============================================================================
 
 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 "QmitkXnatEditor.h"
 
 // Qmitk
 #include "QmitkXnatObjectEditorInput.h"
 #include "org_mitk_gui_qt_xnatinterface_Activator.h"
 
 // CTK XNAT Core
 #include "ctkXnatObject.h"
 #include "ctkXnatDataModel.h"
 #include "ctkXnatFile.h"
 #include "ctkXnatResource.h"
 #include "ctkXnatScan.h"
 #include "ctkXnatScanFolder.h"
 #include "ctkXnatAssessor.h"
 #include "ctkXnatAssessorFolder.h"
 #include "ctkXnatReconstruction.h"
 #include "ctkXnatReconstructionFolder.h"
 
 // CTK XNAT Widgets
 #include "ctkXnatListModel.h"
 
 // Blueberry
 #include <berryQModelIndexObject.h>
 #include <berryIWorkbenchPage.h>
 
 // Qt
 #include <QListView>
-#include <QRegExp>
 #include <QModelIndex>
 #include <QDir>
 #include <QDirIterator>
 #include <QMessageBox>
 
 // MITK
 #include <mitkDataStorage.h>
 #include <QmitkIOUtil.h>
 #include <mitkCoreServices.h>
 #include <mitkIPreferencesService.h>
 #include <mitkIPreferences.h>
 
 // Poco
 #include <Poco/Zip/Decompress.h>
 
 const QString QmitkXnatEditor::EDITOR_ID = "org.mitk.editors.xnat.browser";
 
 QmitkXnatEditor::QmitkXnatEditor() :
 m_DownloadPath(QString::fromStdString(mitk::CoreServices::GetPreferencesService()->
 GetSystemPreferences()->Node("/XnatConnection")->Get("Download Path", ""))),
 m_ListModel(new ctkXnatListModel()),
 m_Session(0),
 m_DataStorageServiceTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()),
 m_SelectionListener(new berry::SelectionChangedAdapter<QmitkXnatEditor>(this, &QmitkXnatEditor::SelectionChanged))
 {
   m_DataStorageServiceTracker.open();
   if (m_DownloadPath.isEmpty())
   {
     QString xnatFolder = "XNAT_DOWNLOADS";
     QDir dir(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()->getDataFile("").absoluteFilePath());
     dir.mkdir(xnatFolder);
     dir.setPath(dir.path() + "/" + xnatFolder);
     m_DownloadPath = dir.path() + "/";
   }
 }
 
 QmitkXnatEditor::~QmitkXnatEditor()
 {
   delete m_ListModel;
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   s->RemoveSelectionListener(m_SelectionListener.data());
   m_DataStorageServiceTracker.close();
 }
 
 bool QmitkXnatEditor::IsDirty() const
 {
   return false;
 }
 
 bool QmitkXnatEditor::IsSaveAsAllowed() const
 {
   return false;
 }
 
 void QmitkXnatEditor::Init(berry::IEditorSite::Pointer site, berry::IEditorInput::Pointer input)
 {
   this->SetSite(site);
   berry::QtEditorPart::SetInput(input);
   this->SetInput(input);
 }
 
 void QmitkXnatEditor::DoSave()
 {
 }
 
 void QmitkXnatEditor::DoSaveAs()
 {
 }
 
 void QmitkXnatEditor::SetInput(berry::IEditorInput::Pointer input)
 {
   QmitkXnatObjectEditorInput::Pointer oPtr = input.Cast<QmitkXnatObjectEditorInput>();
   if (oPtr.IsNotNull())
   {
     berry::QtEditorPart::SetInput(oPtr);
     this->GetEditorInput().Cast<QmitkXnatObjectEditorInput>()->GetXnatObject()->fetch();
   }
 }
 
 void QmitkXnatEditor::SetFocus()
 {
 }
 
 void QmitkXnatEditor::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   m_Controls.buttonDownload->setEnabled(false);
   m_Controls.labelDownload->setText("Select a xnat file, resource, scan, or scan folder to download...");
 
   GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddSelectionListener(m_SelectionListener.data());
 
   connect(m_Controls.treeView, SIGNAL(activated(const QModelIndex&)), this, SLOT(OnObjectActivated(const QModelIndex&)));
 
   connect(m_Controls.buttonDownload, SIGNAL(clicked()), this, SLOT(DownloadResource()));
   connect(m_Controls.buttonDataModel, SIGNAL(clicked()), this, SLOT(OnDataModelButtonClicked()));
   connect(m_Controls.buttonProject, SIGNAL(clicked()), this, SLOT(OnProjectButtonClicked()));
   connect(m_Controls.buttonSubject, SIGNAL(clicked()), this, SLOT(OnSubjectButtonClicked()));
   connect(m_Controls.buttonExperiment, SIGNAL(clicked()), this, SLOT(OnExperimentButtonClicked()));
   connect(m_Controls.buttonKindOfData, SIGNAL(clicked()), this, SLOT(OnKindOfDataButtonClicked()));
   connect(m_Controls.buttonSession, SIGNAL(clicked()), this, SLOT(OnSessionButtonClicked()));
   connect(m_Controls.buttonResource, SIGNAL(clicked()), this, SLOT(OnResourceButtonClicked()));
   connect(m_Controls.treeView, SIGNAL(clicked(const QModelIndex&)), SLOT(itemSelected(const QModelIndex&)));
 
   m_Tracker = new mitk::XnatSessionTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext());
 
   connect(m_Tracker, SIGNAL(AboutToBeClosed(ctkXnatSession*)), this, SLOT(CleanListModel(ctkXnatSession*)));
   connect(m_Tracker, SIGNAL(Opened(ctkXnatSession*)), this, SLOT(UpdateSession(ctkXnatSession*)));
 
   m_Tracker->Open();
 
   // Makes the breadcrumb feature invisible
   for (int i = 0; i < m_Controls.breadcrumbHorizontalLayout->count() - 1; i++)
   {
     QLayoutItem* child = m_Controls.breadcrumbHorizontalLayout->itemAt(i);
     child->widget()->setVisible(false);
   }
   for (int i = 0; i < m_Controls.breadcrumbDescriptionLayout->count() - 1; i++)
   {
     QLayoutItem* child = m_Controls.breadcrumbDescriptionLayout->itemAt(i);
     child->widget()->setVisible(false);
   }
   QmitkXnatObjectEditorInput::Pointer oPtr = GetEditorInput().Cast<QmitkXnatObjectEditorInput>();
   if (oPtr.IsNotNull())
   {
     UpdateList();
   }
   else
   {
     ctkXnatSession* session;
     try
     {
       session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
         mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
     }
     catch (std::invalid_argument)
     {
       session = 0;
     }
     UpdateSession(session);
   }
 }
 
 void QmitkXnatEditor::UpdateList()
 {
   QmitkXnatObjectEditorInput::Pointer xoPtr(GetEditorInput().Cast<QmitkXnatObjectEditorInput>());
   if (xoPtr.IsNull())
     return;
   ctkXnatObject* inputObject = xoPtr->GetXnatObject();
   if (inputObject == nullptr)
     return;
 
   m_Controls.treeView->setModel(m_ListModel);
   m_ListModel->setRootObject(inputObject);
   m_Controls.treeView->reset();
 
   // recursive method to check parents of the inputObject
   m_ParentCount = ParentChecker(inputObject);
 
   // breadcrumb labels
   for (int i = 0; i < m_Controls.breadcrumbHorizontalLayout->count() - 1; i++)
   {
     QLayoutItem* child = m_Controls.breadcrumbHorizontalLayout->itemAt(i);
     child->widget()->setVisible(false);
   }
   for (int i = 0; i < m_Controls.breadcrumbDescriptionLayout->count() - 1; i++)
   {
     QLayoutItem* child = m_Controls.breadcrumbDescriptionLayout->itemAt(i);
     child->widget()->setVisible(false);
   }
 
   ctkXnatObject* parent = nullptr;
   for (int i = m_ParentCount * 2; i >= 0; i--)
   {
     if (i > 12)
       break;
     m_Controls.breadcrumbDescriptionLayout->itemAt(i)->widget()->setVisible(true);
     QLayoutItem* child = m_Controls.breadcrumbHorizontalLayout->itemAt(i);
     child->widget()->setVisible(true);
     if (i > 0)
     {
       m_Controls.breadcrumbHorizontalLayout->itemAt(i - 1)->widget()->setVisible(true);
       m_Controls.breadcrumbDescriptionLayout->itemAt(i - 1)->widget()->setVisible(true);
     }
     if (parent == nullptr)
     {
       parent = inputObject;
     }
     // create breadcrumb button
     QPushButton* breadcrumbButton = dynamic_cast<QPushButton*>(child->widget());
     breadcrumbButton->setText(parent->id());
     parent = parent->parent();
     i--;
   }
   m_Controls.buttonDataModel->setText("root");
   m_Controls.buttonDownload->setEnabled(false);
   m_Controls.labelDownload->setVisible(true);
 }
 
 void QmitkXnatEditor::SelectionChanged(const berry::IWorkbenchPart::Pointer& sourcepart,
                                        const berry::ISelection::ConstPointer& selection)
 {
   // check for null selection
   if (selection.IsNull())
   {
     return;
   }
   // exclude own selection events and check whether this kind of selection can be handled
   if (sourcepart != this &&
     selection.Cast<const berry::IStructuredSelection>())
   {
     berry::IStructuredSelection::ConstPointer currentSelection = selection.Cast<const berry::IStructuredSelection>();
     // iterates over the selection
     for (berry::IStructuredSelection::iterator itr = currentSelection->Begin();
       itr != currentSelection->End(); ++itr)
     {
       if (berry::SmartPointer<berry::QModelIndexObject> objectPointer = itr->Cast<berry::QModelIndexObject>())
       {
         // get object of selected ListWidgetElement
         ctkXnatObject* object = objectPointer->GetQModelIndex().data(Qt::UserRole).value<ctkXnatObject*>();
 
         // if a file is selected, don't change the input and list view
         if (dynamic_cast<ctkXnatFile*>(object) == nullptr)
         {
           QmitkXnatObjectEditorInput::Pointer oPtr(new QmitkXnatObjectEditorInput(object));
           berry::IEditorInput::Pointer editorInput(oPtr);
           if (!(editorInput == this->GetEditorInput()))
             this->SetInput(editorInput);
 
           UpdateList();
         }
       }
     }
   }
 }
 
 void QmitkXnatEditor::DownloadResource()
 {
   if (!m_Controls.listView->selectionModel()->hasSelection())
     return;
 
   const QModelIndex index = m_Controls.listView->selectionModel()->currentIndex();
   QVariant variant = m_ListModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     ctkXnatObject* resource = variant.value<ctkXnatObject*>();
     if (dynamic_cast<ctkXnatFile*>(resource) == nullptr)
     {
       MITK_INFO << "Download started ...";
       MITK_INFO << "...";
       QString resourceName = m_ListModel->data(index, Qt::DisplayRole).toString();
       QString resourcePath = m_DownloadPath + resourceName + ".zip";
       resource->download(resourcePath);
 
       // Testing if the path exists
       QDir downDir(m_DownloadPath);
       if (downDir.exists(resourceName + ".zip"))
       {
         MITK_INFO << "Download of " << resourceName.toStdString() << ".zip was completed!";
       }
       else
       {
         MITK_INFO << "Download of " << resourceName.toStdString() << ".zip failed!";
       }
     }
     else
     {
       InternalFileDownload(index);
     }
   }
 }
 
 void QmitkXnatEditor::DownloadFile()
 {
   if (!m_Controls.listView->selectionModel()->hasSelection())
     return;
   const QModelIndex index = m_Controls.listView->selectionModel()->currentIndex();
   InternalFileDownload(index);
 }
 
 void QmitkXnatEditor::ToHigherLevel()
 {
   ctkXnatObject* parent = GetEditorInput().Cast<QmitkXnatObjectEditorInput>()->GetXnatObject()->parent();
   if (parent == nullptr)
   {
     return;
   }
   QmitkXnatObjectEditorInput::Pointer oPtr(new QmitkXnatObjectEditorInput(parent));
   berry::IEditorInput::Pointer editorInput(oPtr);
   this->SetInput(editorInput);
   UpdateList();
 }
 
 void QmitkXnatEditor::OnObjectActivated(const QModelIndex &index)
 {
   if (!index.isValid()) return;
 
   ctkXnatObject* child = GetEditorInput().Cast<QmitkXnatObjectEditorInput>()->GetXnatObject()->children().at(index.row());
   if (child != nullptr)
   {
     ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(child);
     if (file != nullptr)
     {
       // Download file and put into datamanager
       InternalFileDownload(index);
       mitk::IDataStorageService* dsService = m_DataStorageServiceTracker.getService();
       if (dsService != nullptr)
       {
         QString name = file->property("Name");
         QString filePath = m_DownloadPath + name;
 
         if (file->property("collection") == "DICOM")
         {
           QDirIterator it(m_DownloadPath, QStringList() << name, QDir::Files, QDirIterator::Subdirectories);
           while (it.hasNext()) {
             it.next();
             filePath = it.filePath();
           }
         }
 
         mitk::IDataStorageService* dsService = m_DataStorageServiceTracker.getService();
         mitk::DataStorage::Pointer dataStorage = dsService->GetDataStorage()->GetDataStorage();
         QStringList list;
         list << filePath;
         try
         {
           QmitkIOUtil::Load(list, *dataStorage);
         }
         catch (const mitk::Exception& e)
         {
           MITK_INFO << e;
           return;
         }
         mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(
           dsService->GetDataStorage()->GetDataStorage());
       }
     }
     else
     {
       // Updates the root item
       QmitkXnatObjectEditorInput::Pointer oPtr(new QmitkXnatObjectEditorInput(child));
       berry::IEditorInput::Pointer editorInput(oPtr);
       this->SetInput(editorInput);
 
       this->GetEditorInput().Cast<QmitkXnatObjectEditorInput>()->GetXnatObject()->fetch();
 
       UpdateList();
     }
   }
 }
 
 void QmitkXnatEditor::InternalFileDownload(const QModelIndex& index)
 {
   QVariant variant = m_ListModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(variant.value<ctkXnatObject*>());
     if (file != nullptr)
     {
       // Testing if the file exists
       QDir downDir(m_DownloadPath);
       if (downDir.exists(file->property("Name")))
       {
         MITK_INFO << "File exists already!";
         return;
       }
 
       if (file->property("collection") == QString("DICOM"))
       {
         ctkXnatObject* parent = file->parent();
 
         QString filePath = m_DownloadPath + parent->property("label") + ".zip";
         parent->download(filePath);
 
         std::ifstream in(filePath.toStdString().c_str(), std::ios::binary);
         poco_assert(in);
 
         // decompress to XNAT_DOWNLOAD dir
         Poco::Zip::Decompress dec(in, Poco::Path(m_DownloadPath.toStdString()));
         dec.decompressAllFiles();
 
         in.close();
         QFile::remove(filePath);
       }
       else
       {
         MITK_INFO << "Download started ...";
         MITK_INFO << "...";
         QString name = file->property("Name");
         QString filePath = m_DownloadPath + name;
         file->download(filePath);
 
         // Testing if the file exists
         QDir downDir(m_DownloadPath);
         if (downDir.exists(name))
         {
           MITK_INFO << "Download of " << file->name().toStdString() << " was completed!";
         }
         else
         {
           MITK_INFO << "Download of " << file->name().toStdString() << " failed!";
         }
       }
     }
     else
     {
       MITK_INFO << "Selection was not a file!";
     }
   }
 }
 
 int QmitkXnatEditor::ParentChecker(ctkXnatObject* child)
 {
   int sum;
   if (child->parent() == nullptr)
   {
     return 0;
   }
   else
   {
     sum = 1 + ParentChecker(child->parent());
   }
   return sum;
 }
 
 void QmitkXnatEditor::OnDataModelButtonClicked()
 {
   for (int i = m_ParentCount; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnProjectButtonClicked()
 {
   for (int i = m_ParentCount - 1; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnSubjectButtonClicked()
 {
   for (int i = m_ParentCount - 2; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnExperimentButtonClicked()
 {
   for (int i = m_ParentCount - 3; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnKindOfDataButtonClicked()
 {
   for (int i = m_ParentCount - 4; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnSessionButtonClicked()
 {
   for (int i = m_ParentCount - 5; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::OnResourceButtonClicked()
 {
   for (int i = m_ParentCount - 6; i > 0; i--)
   {
     ToHigherLevel();
   }
 }
 
 void QmitkXnatEditor::UpdateSession(ctkXnatSession* session)
 {
   GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemoveSelectionListener(m_SelectionListener.data());
 
   if (session != 0 && session->isOpen())
   {
     m_Controls.labelInfo->setText("Current Position:");
     m_Controls.labelInfo->setStyleSheet("QLabel { color: black; }");
 
     // Fill model and show in the GUI
     QmitkXnatObjectEditorInput::Pointer xoPtr(new QmitkXnatObjectEditorInput(session->dataModel()));
     berry::IEditorInput::Pointer editorInput(xoPtr);
     this->SetInput(editorInput);
     this->GetEditorInput().Cast<QmitkXnatObjectEditorInput>()->GetXnatObject()->fetch();
     UpdateList();
   }
   else
   {
     m_Controls.labelInfo->setText("Please check the Preferences of the XNAT Connection.\nMaybe they are not ok.");
     m_Controls.labelInfo->setStyleSheet("QLabel { color: red; }");
   }
 
   GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddSelectionListener(m_SelectionListener.data());
 }
 
 void QmitkXnatEditor::CleanListModel(ctkXnatSession* session)
 {
   if (session != 0)
   {
     m_Controls.listView->setModel(0);
     m_ListModel->setRootObject(0);
     m_Controls.treeView->reset();
   }
 }
 
 void QmitkXnatEditor::itemSelected(const QModelIndex &index)
 {
   ctkXnatObject* xnatObject = m_ListModel->data(index, Qt::UserRole).value<ctkXnatObject*>();
   bool downloadable = false;
   downloadable |= dynamic_cast<ctkXnatFile*>(xnatObject) != nullptr;
   downloadable |= dynamic_cast<ctkXnatScan*>(xnatObject) != nullptr;
   downloadable |= dynamic_cast<ctkXnatScanFolder*>(xnatObject) != nullptr;
   downloadable |= dynamic_cast<ctkXnatAssessor*>(xnatObject) != nullptr;
   downloadable |= dynamic_cast<ctkXnatAssessorFolder*>(xnatObject) != nullptr;
   downloadable |= dynamic_cast<ctkXnatResource*>(xnatObject) != nullptr;
   downloadable |= dynamic_cast<ctkXnatReconstruction*>(xnatObject) != nullptr;
   downloadable |= dynamic_cast<ctkXnatReconstructionFolder*>(xnatObject) != nullptr;
   m_Controls.buttonDownload->setEnabled(downloadable);
   m_Controls.labelDownload->setVisible(!downloadable);
 }
diff --git a/Utilities/qtsingleapplication/qtlocalpeer.cpp b/Utilities/qtsingleapplication/qtlocalpeer.cpp
index 1f1c7f2b2b..d52366e56d 100644
--- a/Utilities/qtsingleapplication/qtlocalpeer.cpp
+++ b/Utilities/qtsingleapplication/qtlocalpeer.cpp
@@ -1,202 +1,203 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the Qt Solutions component.
 **
 ** $QT_BEGIN_LICENSE:BSD$
 ** You may use this file under the terms of the BSD license as follows:
 **
 ** "Redistribution and use in source and binary forms, with or without
 ** modification, are permitted provided that the following conditions are
 ** met:
 **   * Redistributions of source code must retain the above copyright
 **     notice, this list of conditions and the following disclaimer.
 **   * Redistributions in binary form must reproduce the above copyright
 **     notice, this list of conditions and the following disclaimer in
 **     the documentation and/or other materials provided with the
 **     distribution.
 **   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
 **     of its contributors may be used to endorse or promote products derived
 **     from this software without specific prior written permission.
 **
 **
 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
 
 #include "qtlocalpeer.h"
 #include <QCoreApplication>
 #include <QDataStream>
+#include <QRegularExpression>
 #include <QTime>
 
 #if defined(Q_OS_WIN)
 #include <qt_windows.h>
 #include <QLibrary>
 typedef BOOL(WINAPI *PProcessIdToSessionId)(DWORD, DWORD *);
 static PProcessIdToSessionId pProcessIdToSessionId = 0;
 #endif
 #if defined(Q_OS_UNIX)
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
 #endif
 
 namespace QtLP_Private
 {
 #include "qtlockedfile.cpp"
 #if defined(Q_OS_WIN)
 #include "qtlockedfile_win.cpp"
 #else
 #include "qtlockedfile_unix.cpp"
 #endif
 }
 
 const char *QtLocalPeer::ack = "ack";
 
 QtLocalPeer::QtLocalPeer(QObject *parent, const QString &appId) : QObject(parent), id(appId)
 {
   QString prefix = id;
   if (id.isEmpty())
   {
     id = QCoreApplication::applicationFilePath();
 #if defined(Q_OS_WIN)
     id = id.toLower();
 #endif
     prefix = id.section(QLatin1Char('/'), -1);
   }
-  prefix.remove(QRegExp("[^a-zA-Z]"));
+  prefix.remove(QRegularExpression("[^a-zA-Z]"));
   prefix.truncate(6);
 
   QByteArray idc = id.toUtf8();
   quint16 idNum = qChecksum(idc.constData(), idc.size());
   socketName = QLatin1String("qtsingleapp-") + prefix + QLatin1Char('-') + QString::number(idNum, 16);
 
 #if defined(Q_OS_WIN)
   if (!pProcessIdToSessionId)
   {
     QLibrary lib("kernel32");
     pProcessIdToSessionId = (PProcessIdToSessionId)lib.resolve("ProcessIdToSessionId");
   }
   if (pProcessIdToSessionId)
   {
     DWORD sessionId = 0;
     pProcessIdToSessionId(GetCurrentProcessId(), &sessionId);
     socketName += QLatin1Char('-') + QString::number(sessionId, 16);
   }
 #else
   socketName += QLatin1Char('-') + QString::number(::getuid(), 16);
 #endif
 
   server = new QLocalServer(this);
   QString lockName = QDir(QDir::tempPath()).absolutePath() + QLatin1Char('/') + socketName + QLatin1String("-lockfile");
   lockFile.setFileName(lockName);
   lockFile.open(QIODevice::ReadWrite);
 }
 
 bool QtLocalPeer::isClient()
 {
   if (lockFile.isLocked())
     return false;
 
   if (!lockFile.lock(QtLP_Private::QtLockedFile::WriteLock, false))
     return true;
 
   bool res = server->listen(socketName);
 #if defined(Q_OS_UNIX)
   // ### Workaround
   if (!res && server->serverError() == QAbstractSocket::AddressInUseError)
   {
     QFile::remove(QDir::cleanPath(QDir::tempPath()) + QLatin1Char('/') + socketName);
     res = server->listen(socketName);
   }
 #endif
   if (!res)
     qWarning("QtSingleCoreApplication: listen on local socket failed, %s", qPrintable(server->errorString()));
   QObject::connect(server, SIGNAL(newConnection()), SLOT(receiveConnection()));
   return false;
 }
 
 bool QtLocalPeer::sendMessage(const QByteArray &message, int timeout)
 {
   if (!isClient())
     return false;
 
   QLocalSocket socket;
   bool connOk = false;
   for (int i = 0; i < 2; i++)
   {
     // Try twice, in case the other instance is just starting up
     socket.connectToServer(socketName);
     connOk = socket.waitForConnected(timeout / 2);
     if (connOk || i)
       break;
     int ms = 250;
 #if defined(Q_OS_WIN)
     Sleep(DWORD(ms));
 #else
     struct timespec ts = {ms / 1000, (ms % 1000) * 1000 * 1000};
     nanosleep(&ts, nullptr);
 #endif
   }
   if (!connOk)
     return false;
 
   QDataStream ds(&socket);
   ds.writeBytes(message.constData(), message.size());
   bool res = socket.waitForBytesWritten(timeout);
   if (res)
   {
     res &= socket.waitForReadyRead(timeout); // wait for ack
     if (res)
       res &= (socket.read(qstrlen(ack)) == ack);
   }
   return res;
 }
 
 void QtLocalPeer::receiveConnection()
 {
   QLocalSocket *socket = server->nextPendingConnection();
   if (!socket)
     return;
 
   while (socket->bytesAvailable() < (int)sizeof(quint32))
     socket->waitForReadyRead();
   QDataStream ds(socket);
   QByteArray uMsg;
   quint32 remaining;
   ds >> remaining;
   uMsg.resize(remaining);
   int got = 0;
   char *uMsgBuf = uMsg.data();
   do
   {
     got = ds.readRawData(uMsgBuf, remaining);
     remaining -= got;
     uMsgBuf += got;
   } while (remaining && got >= 0 && socket->waitForReadyRead(2000));
   if (got < 0)
   {
     qWarning("QtLocalPeer: Message reception failed %s", socket->errorString().toLatin1().constData());
     delete socket;
     return;
   }
   socket->write(ack, qstrlen(ack));
   socket->waitForBytesWritten(1000);
   socket->waitForDisconnected(1000); // make sure client reads ack
   delete socket;
   emit messageReceived(uMsg); //### (might take a long time to return)
 }