diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/volumetry/QmitkVolumetryView.cpp b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/volumetry/QmitkVolumetryView.cpp
index eb2ce45ff9..b5e4aee6f6 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/volumetry/QmitkVolumetryView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/volumetry/QmitkVolumetryView.cpp
@@ -1,252 +1,252 @@
 /*============================================================================
 
 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 "QmitkVolumetryView.h"
 
 #include "ui_QmitkVolumetryViewControls.h"
 
 #include "mitkImageStatisticsHolder.h"
 #include "mitkVolumeCalculator.h"
 
 #include <QDir>
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QTextStream>
 
 const std::string QmitkVolumetryView::VIEW_ID = "org.mitk.views.volumetry";
 
 QmitkVolumetryView::QmitkVolumetryView() : m_Controls(nullptr), m_ParentWidget(nullptr)
 {
 }
 
 void QmitkVolumetryView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     m_ParentWidget = parent;
     // create GUI widgets
     m_Controls = new Ui::QmitkVolumetryViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 }
 
 void QmitkVolumetryView::SetFocus()
 {
   m_Controls->m_CalcButton->setFocus();
 }
 
 void QmitkVolumetryView::CreateConnections()
 {
   if (m_Controls)
   {
     connect(
       (QObject *)(m_Controls->m_ThresholdSlider), SIGNAL(valueChanged(int)), this, SLOT(OnThresholdSliderChanged(int)));
     connect((QObject *)(m_Controls->m_CalcButton), SIGNAL(clicked()), this, SLOT(OnCalculateVolume()));
     connect((QObject *)(m_Controls->m_TimeSeriesButton), SIGNAL(clicked()), this, SLOT(OnTimeSeriesButtonClicked()));
     connect((QObject *)(m_Controls->m_SaveCsvButton), SIGNAL(clicked()), this, SLOT(OnSaveCsvButtonClicked()));
   }
 }
 
 void QmitkVolumetryView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
                                             const QList<mitk::DataNode::Pointer> &nodes)
 {
   m_SelectedDataNode = nullptr;
   if (!nodes.isEmpty() && dynamic_cast<mitk::Image *>(nodes.front()->GetData()))
   {
     m_SelectedDataNode = nodes.front();
     m_ParentWidget->setEnabled(true);
   }
 
   if (m_SelectedDataNode.IsExpired() || m_SelectedDataNode == m_OverlayNode)
   {
     m_SelectedDataNode = nullptr;
     m_ParentWidget->setEnabled(false);
     return;
   }
 
   if (m_OverlayNode)
   {
     this->GetDataStorage()->Remove(m_OverlayNode);
     m_OverlayNode = nullptr;
   }
 
   this->CreateOverlayChild();
 
   m_Controls->m_CalcButton->setEnabled(false);
   m_Controls->m_TimeSeriesButton->setEnabled(false);
   m_Controls->m_SaveCsvButton->setEnabled(false);
   m_Controls->m_TextEdit->clear();
 
   mitk::Image *image = dynamic_cast<mitk::Image *>(m_SelectedDataNode.Lock()->GetData());
   image->Update();
   if (image && image->IsInitialized())
   {
     if (image->GetDimension() == 4)
     {
       m_Controls->m_TimeSeriesButton->setEnabled(true);
     }
     else
     {
       m_Controls->m_CalcButton->setEnabled(true);
     }
     int minVal = (int)image->GetStatistics()->GetScalarValue2ndMin();
     int maxVal = (int)image->GetStatistics()->GetScalarValueMaxNoRecompute();
     if (minVal == maxVal)
       --minVal;
     m_Controls->m_ThresholdSlider->setMinimum(minVal);
     m_Controls->m_ThresholdSlider->setMaximum(maxVal);
     m_Controls->m_ThresholdSlider->setEnabled(true);
     this->UpdateSlider();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkVolumetryView::OnCalculateVolume()
 {
   auto selectedDataNode = m_SelectedDataNode.Lock();
 
   if (selectedDataNode.IsNotNull())
   {
     mitk::Image *image = dynamic_cast<mitk::Image *>(selectedDataNode->GetData());
     std::cout << "Dimension:" << image->GetDimension() << std::endl;
     std::cout << "Dimension[3]:" << image->GetDimension(3) << std::endl;
     mitk::VolumeCalculator::Pointer volCalc = mitk::VolumeCalculator::New();
     volCalc->SetImage(image);
     volCalc->SetThreshold(m_Controls->m_ThresholdSlider->value());
     volCalc->ComputeVolume();
     std::stringstream vs;
     vs << volCalc->GetVolume() << " ml";
     m_Controls->m_Result->setText(vs.str().c_str());
   }
 }
 
 void QmitkVolumetryView::OnTimeSeriesButtonClicked()
 {
   auto selectedDataNode = m_SelectedDataNode.Lock();
 
   if (selectedDataNode.IsNotNull())
   {
     mitk::Image *image = dynamic_cast<mitk::Image *>(selectedDataNode->GetData());
     mitk::VolumeCalculator::Pointer volCalc = mitk::VolumeCalculator::New();
     volCalc->SetImage(image);
     volCalc->SetThreshold(m_Controls->m_ThresholdSlider->value());
     volCalc->ComputeVolume();
     std::vector<float> volumes = volCalc->GetVolumes();
     std::stringstream vs;
     int timeStep = 0;
     for (auto it = volumes.begin(); it != volumes.end(); it++)
     {
       vs << timeStep++ << "\t" << *it << std::endl;
     }
     m_Controls->m_TextEdit->setText(vs.str().c_str());
-    m_Controls->m_TextEdit->setTabStopWidth(20);
+    m_Controls->m_TextEdit->setTabStopDistance(20);
     m_Controls->m_SaveCsvButton->setEnabled(true);
   }
 }
 
 const mitk::DataNode *QmitkVolumetryView::GetImageNode() const
 {
   return m_SelectedDataNode.Lock();
 }
 
 void QmitkVolumetryView::UpdateSlider()
 {
   auto selectedDataNode = m_SelectedDataNode.Lock();
 
   if (selectedDataNode.IsNotNull() && dynamic_cast<mitk::Image *>(selectedDataNode->GetData()))
   {
     int intSliderValue = (int)m_Controls->m_ThresholdSlider->value();
     QString stringSliderValue;
     stringSliderValue.setNum(intSliderValue);
     m_Controls->m_ThresholdLineEdit->setText(stringSliderValue);
   }
 }
 
 void QmitkVolumetryView::UpdateSliderLabel()
 {
   int sliderValue = atoi(m_Controls->m_ThresholdLineEdit->text().toLatin1());
   m_Controls->m_ThresholdSlider->setValue(sliderValue);
   this->UpdateSlider();
 }
 
 void QmitkVolumetryView::OnThresholdSliderChanged(int value)
 {
   if (m_OverlayNode)
   {
     m_OverlayNode->SetLevelWindow(mitk::LevelWindow(value, 1));
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     this->UpdateSlider();
   }
 }
 
 void QmitkVolumetryView::CreateOverlayChild()
 {
   auto selectedDataNode = m_SelectedDataNode.Lock();
 
   if (selectedDataNode.IsNotNull())
   {
     m_OverlayNode = mitk::DataNode::New();
     mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New("volume threshold overlay image");
     m_OverlayNode->SetProperty("reslice interpolation", selectedDataNode->GetProperty("reslice interpolation"));
     m_OverlayNode->SetProperty("name", nameProp);
     m_OverlayNode->SetData(selectedDataNode->GetData());
     m_OverlayNode->SetColor(0.0, 1.0, 0.0);
     m_OverlayNode->SetOpacity(.25);
     int layer = 0;
     selectedDataNode->GetIntProperty("layer", layer);
     m_OverlayNode->SetIntProperty("layer", layer + 1);
     m_OverlayNode->SetLevelWindow(mitk::LevelWindow(m_Controls->m_ThresholdSlider->value(), 1));
 
     this->GetDataStorage()->Add(m_OverlayNode);
   }
 }
 
 mitk::DataNode *QmitkVolumetryView::GetOverlayNode() const
 {
   return m_OverlayNode;
 }
 
 mitk::Image *QmitkVolumetryView::GetImage() const
 {
   return dynamic_cast<mitk::Image *>(m_SelectedDataNode.Lock()->GetData());
 }
 
 void QmitkVolumetryView::OnSaveCsvButtonClicked()
 {
   static QString lastSavePath = QDir::homePath();
 
   QString s = QFileDialog::getSaveFileName(this->m_ParentWidget, "Save as..", lastSavePath, "CSV Files (*.csv)");
   /*"Save file dialog"
   "Choose a filename to save under" );*/
 
   if (!s.isEmpty())
   {
     lastSavePath = s;
     QFile saveFile(s);
 
     if (saveFile.open(QIODevice::WriteOnly))
     {
       QTextStream stream(&saveFile);
       stream << m_Controls->m_TextEdit->toPlainText().replace('\t', ';');
       saveFile.close();
     }
     else
     {
       // QMessageBox::critical(nullptr,"Save Error!",QString("Saving of CSV failed! Couldn't open output file \"") +
       // saveFile + QString("\""),QMessageBox:Ok,QMessageBox::NoButton);
       // QMessageBox::critical(nullptr,"Save Error!","Saving of CSV failed! Couldn't open output file \"" + saveFile.name()
       // +"\"",QMessageBox::Ok,QMessageBox::NoButton);
     }
   }
 }
diff --git a/Modules/AppUtil/src/QmitkSafeNotify.h b/Modules/AppUtil/src/QmitkSafeNotify.h
index 3b742172ad..2f2228ffc4 100644
--- a/Modules/AppUtil/src/QmitkSafeNotify.h
+++ b/Modules/AppUtil/src/QmitkSafeNotify.h
@@ -1,69 +1,69 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkSafeNotify_h
 #define QmitkSafeNotify_h
 
 #include <mitkException.h>
 #include <mitkLog.h>
 
 #include <QMessageBox>
 
 template <class A>
 bool QmitkSafeNotify(A *app, QObject *receiver, QEvent *event)
 {
   QString msg;
   try
   {
     return app->A::notify(receiver, event);
   }
   catch (mitk::Exception &e)
   {
     msg = QString("MITK Exception:\n\n") + QString("Description: ") + QString(e.GetDescription()) + QString("\n\n") +
           QString("Filename: ") + QString(e.GetFile()) + QString("\n\n") + QString("Line: ") +
           QString::number(e.GetLine());
   }
   catch (std::exception &e)
   {
     msg = e.what();
   }
   catch (...)
   {
     msg = "Unknown exception";
   }
   MITK_ERROR << "An error occurred: " << msg.toStdString();
 
   QMessageBox msgBox;
   msgBox.setText("An error occurred. You should save all data and quit the program to prevent possible data loss.");
   msgBox.setDetailedText(msg);
   msgBox.setIcon(QMessageBox::Critical);
-  msgBox.addButton(app->trUtf8("Exit immediately"), QMessageBox::YesRole);
-  msgBox.addButton(app->trUtf8("Ignore"), QMessageBox::NoRole);
+  msgBox.addButton("Exit immediately", QMessageBox::YesRole);
+  msgBox.addButton("Ignore", QMessageBox::NoRole);
 
   int ret = msgBox.exec();
 
   switch (ret)
   {
     case 0:
       MITK_ERROR << "The program was closed.";
       app->closeAllWindows();
       break;
     case 1:
       MITK_ERROR
         << "The error was ignored by the user. The program may be in a corrupt state and don't behave like expected!";
       break;
   }
 
   return false;
 }
 
 #endif
diff --git a/Modules/QtWidgets/include/QmitkPropertyItemDelegate.h b/Modules/QtWidgets/include/QmitkPropertyItemDelegate.h
index cd18a319a8..c0d2ffa4f2 100644
--- a/Modules/QtWidgets/include/QmitkPropertyItemDelegate.h
+++ b/Modules/QtWidgets/include/QmitkPropertyItemDelegate.h
@@ -1,93 +1,93 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkPropertyItemDelegate_h
 #define QmitkPropertyItemDelegate_h
 
 #include <MitkQtWidgetsExports.h>
 #include <QListView>
 #include <QStyledItemDelegate>
 #include <mitkPropertyList.h>
 #include <mitkWeakPointer.h>
 
 class QComboBox;
 class QLineEdit;
 class QToolButton;
 class QResizeEvent;
 
 class QmitkColorWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   explicit QmitkColorWidget(QWidget *parent = nullptr);
   ~QmitkColorWidget() override;
 
   QColor GetColor() const;
   void SetColor(QColor color);
 
 signals:
   void ColorPicked();
 
 private slots:
   void OnButtonClicked();
   void OnLineEditEditingFinished();
 
 private:
   QColor m_Color;
   QLineEdit *m_LineEdit;
   QToolButton *m_Button;
 };
 
 class QmitkComboBoxListView : public QListView
 {
   Q_OBJECT
 
 public:
   explicit QmitkComboBoxListView(QComboBox *comboBox = nullptr);
   ~QmitkComboBoxListView() override;
 
 protected:
   void paintEvent(QPaintEvent *event) override;
   void resizeEvent(QResizeEvent *event) override;
-  QStyleOptionViewItem viewOptions() const override;
+  void initViewItemOption(QStyleOptionViewItem *option) const override;
 
 private:
   QComboBox *m_ComboBox;
 };
 
 class MITKQTWIDGETS_EXPORT QmitkPropertyItemDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
   explicit QmitkPropertyItemDelegate(QObject *parent = nullptr);
   ~QmitkPropertyItemDelegate() override;
 
   QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
   void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
   void setEditorData(QWidget *editor, const QModelIndex &index) const override;
   void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const override;
   void SetPropertyList(mitk::PropertyList *propertyList);
 
 private slots:
   void OnComboBoxCurrentIndexChanged(int index);
   void OnSpinBoxEditingFinished();
   void OnColorPicked();
 
 private:
   std::string GetPropertyName(const QModelIndex &index) const;
 
   mitk::WeakPointer<mitk::PropertyList> m_PropertyList;
 };
 
 #endif
diff --git a/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp b/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp
index 9eae1448e9..1ab8f63a4d 100644
--- a/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp
+++ b/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp
@@ -1,382 +1,380 @@
 /*============================================================================
 
 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 "QmitkPropertyItemDelegate.h"
 #include "QmitkPropertyItemModel.h"
 #include <QApplication>
 #include <QColorDialog>
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QLineEdit>
 #include <QPaintEvent>
 #include <QPainter>
 #include <QSpinBox>
 #include <QToolButton>
 #include <algorithm>
 #include <mitkBaseProperty.h>
 #include <mitkCoreServices.h>
 #include <mitkFloatPropertyExtension.h>
 #include <mitkIPropertyExtensions.h>
 #include <mitkIntPropertyExtension.h>
 
 QmitkColorWidget::QmitkColorWidget(QWidget *parent)
   : QWidget(parent), m_LineEdit(new QLineEdit), m_Button(new QToolButton)
 {
   m_LineEdit->setText(m_Color.name());
   m_Button->setText("...");
 
   QHBoxLayout *layout = new QHBoxLayout;
   layout->setContentsMargins(0, 0, 0, 0);
   layout->setSpacing(0);
 
   layout->addWidget(m_LineEdit);
   layout->addWidget(m_Button);
 
   this->setFocusProxy(m_LineEdit);
   this->setLayout(layout);
 
   connect(m_LineEdit, SIGNAL(editingFinished()), this, SLOT(OnLineEditEditingFinished()));
   connect(m_Button, SIGNAL(clicked()), this, SLOT(OnButtonClicked()));
 }
 
 QmitkColorWidget::~QmitkColorWidget()
 {
 }
 
 QColor QmitkColorWidget::GetColor() const
 {
   return m_Color;
 }
 
 void QmitkColorWidget::SetColor(QColor color)
 {
   m_Color = color;
   m_LineEdit->setText(color.name());
 }
 
 void QmitkColorWidget::OnLineEditEditingFinished()
 {
   if (!QColor::isValidColor(m_LineEdit->text()))
     m_LineEdit->setText("#000000");
 
   m_Color.setNamedColor(m_LineEdit->text());
 }
 
 void QmitkColorWidget::OnButtonClicked()
 {
   QColor color = QColorDialog::getColor(m_Color, QApplication::activeWindow());
 
   if (color.isValid())
   {
     this->SetColor(color);
     emit ColorPicked();
   }
 }
 
 QmitkComboBoxListView::QmitkComboBoxListView(QComboBox *comboBox) : m_ComboBox(comboBox)
 {
 }
 
 QmitkComboBoxListView::~QmitkComboBoxListView()
 {
 }
 
 void QmitkComboBoxListView::paintEvent(QPaintEvent *event)
 {
   if (m_ComboBox != nullptr)
   {
     QStyleOptionComboBox option;
 
     option.initFrom(m_ComboBox);
     option.editable = m_ComboBox->isEditable();
 
     if (m_ComboBox->style()->styleHint(QStyle::SH_ComboBox_Popup, &option, m_ComboBox))
     {
       QStyleOptionMenuItem menuOption;
       menuOption.initFrom(this);
       menuOption.palette = this->palette();
       menuOption.state = QStyle::State_None;
       menuOption.checkType = QStyleOptionMenuItem::NotCheckable;
       menuOption.menuRect = event->rect();
       menuOption.maxIconWidth = 0;
-      menuOption.tabWidth = 0;
 
       QPainter painter(this->viewport());
       m_ComboBox->style()->drawControl(QStyle::CE_MenuEmptyArea, &menuOption, &painter, this);
     }
   }
 
   QListView::paintEvent(event);
 }
 
 void QmitkComboBoxListView::resizeEvent(QResizeEvent *event)
 {
   int width = this->viewport()->width();
   int height = this->contentsSize().height();
 
   this->resizeContents(width, height);
 
   QListView::resizeEvent(event);
 }
 
-QStyleOptionViewItem QmitkComboBoxListView::viewOptions() const
+void QmitkComboBoxListView::initViewItemOption(QStyleOptionViewItem* option) const
 {
-  QStyleOptionViewItem option = QListView::viewOptions();
-  option.showDecorationSelected = true;
+  QListView::initViewItemOption(option);
 
-  if (m_ComboBox != nullptr)
-    option.font = m_ComboBox->font();
+  option->showDecorationSelected = true;
 
-  return option;
+  if (m_ComboBox != nullptr)
+    option->font = m_ComboBox->font();
 }
 
 class PropertyEqualTo
 {
 public:
   PropertyEqualTo(const mitk::BaseProperty *property) : m_Property(property) {}
   bool operator()(const mitk::PropertyList::PropertyMapElementType &pair) const
   {
     return pair.second.GetPointer() == m_Property;
   }
 
 private:
   const mitk::BaseProperty *m_Property;
 };
 
 QmitkPropertyItemDelegate::QmitkPropertyItemDelegate(QObject *parent) : QStyledItemDelegate(parent)
 {
 }
 
 QmitkPropertyItemDelegate::~QmitkPropertyItemDelegate()
 {
 }
 
 QWidget *QmitkPropertyItemDelegate::createEditor(QWidget *parent,
                                                  const QStyleOptionViewItem &option,
                                                  const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (data.isValid())
   {
     if (data.type() == QVariant::Int)
     {
       QSpinBox *spinBox = new QSpinBox(parent);
 
       mitk::CoreServicePointer<mitk::IPropertyExtensions> extensions(mitk::CoreServices::GetPropertyExtensions());
       std::string name = this->GetPropertyName(index);
 
       if (!name.empty() && extensions->HasExtension(name))
       {
         mitk::IntPropertyExtension::Pointer extension =
           dynamic_cast<mitk::IntPropertyExtension *>(extensions->GetExtension(name).GetPointer());
 
         if (extension.IsNotNull())
         {
           spinBox->setMinimum(extension->GetMinimum());
           spinBox->setMaximum(extension->GetMaximum());
           spinBox->setSingleStep(extension->GetSingleStep());
         }
       }
 
       connect(spinBox, SIGNAL(editingFinished()), this, SLOT(OnSpinBoxEditingFinished()));
 
       return spinBox;
     }
 
     if (data.type() == QVariant::Double || static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
     {
       QDoubleSpinBox *spinBox = new QDoubleSpinBox(parent);
 
       mitk::CoreServicePointer<mitk::IPropertyExtensions> extensions(mitk::CoreServices::GetPropertyExtensions());
       std::string name = this->GetPropertyName(index);
 
       if (!name.empty() && extensions->HasExtension(name))
       {
         mitk::FloatPropertyExtension::Pointer extension =
           dynamic_cast<mitk::FloatPropertyExtension *>(extensions->GetExtension(name).GetPointer());
 
         if (extension.IsNotNull())
         {
           spinBox->setMinimum(extension->GetMinimum());
           spinBox->setMaximum(extension->GetMaximum());
           spinBox->setSingleStep(extension->GetSingleStep());
           spinBox->setDecimals(extension->GetDecimals());
         }
       }
       else
       {
         spinBox->setSingleStep(0.1);
         spinBox->setDecimals(4);
       }
 
       if (name == "opacity") // TODO
       {
         spinBox->setMinimum(0.0);
         spinBox->setMaximum(1.0);
       }
 
       connect(spinBox, SIGNAL(editingFinished()), this, SLOT(OnSpinBoxEditingFinished()));
 
       return spinBox;
     }
 
     if (data.type() == QVariant::StringList)
     {
       QComboBox *comboBox = new QComboBox(parent);
       comboBox->setView(new QmitkComboBoxListView(comboBox));
 
       comboBox->addItems(data.toStringList());
 
       connect(comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnComboBoxCurrentIndexChanged(int)));
 
       return comboBox;
     }
 
     if (data.type() == QVariant::Color)
     {
       QmitkColorWidget *colorWidget = new QmitkColorWidget(parent);
 
       connect(colorWidget, SIGNAL(ColorPicked()), this, SLOT(OnColorPicked()));
 
       return colorWidget;
     }
   }
 
   return QStyledItemDelegate::createEditor(parent, option, index);
 }
 
 std::string QmitkPropertyItemDelegate::GetPropertyName(const QModelIndex &index) const
 {
   auto propertyList = m_PropertyList.Lock();
 
   if (propertyList.IsNotNull())
   {
     mitk::BaseProperty *property =
       reinterpret_cast<mitk::BaseProperty *>(index.data(mitk::PropertyRole).value<void *>());
     const mitk::PropertyList::PropertyMap *propertyMap = propertyList->GetMap();
 
     mitk::PropertyList::PropertyMap::const_iterator it =
       std::find_if(propertyMap->begin(), propertyMap->end(), PropertyEqualTo(property));
 
     if (it != propertyMap->end())
       return it->first;
   }
 
   return "";
 }
 
 void QmitkPropertyItemDelegate::OnComboBoxCurrentIndexChanged(int)
 {
   QComboBox *comboBox = qobject_cast<QComboBox *>(sender());
 
   emit commitData(comboBox);
   emit closeEditor(comboBox);
 }
 
 void QmitkPropertyItemDelegate::OnSpinBoxEditingFinished()
 {
   QAbstractSpinBox *spinBox = qobject_cast<QAbstractSpinBox *>(sender());
 
   emit commitData(spinBox);
   emit closeEditor(spinBox);
 }
 
 void QmitkPropertyItemDelegate::OnColorPicked()
 {
   QmitkColorWidget *colorWidget = qobject_cast<QmitkColorWidget *>(sender());
 
   emit commitData(colorWidget);
   emit closeEditor(colorWidget);
 }
 
 void QmitkPropertyItemDelegate::paint(QPainter *painter,
                                       const QStyleOptionViewItem &option,
                                       const QModelIndex &index) const
 {
   QVariant data = index.data();
 
   if (index.column() == 1 && data.type() == QVariant::Color)
   {
     painter->fillRect(option.rect, data.value<QColor>());
     return;
   }
 
   QStyledItemDelegate::paint(painter, option, index);
 }
 
 void QmitkPropertyItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (!data.isValid())
     return;
 
   if (data.type() == QVariant::StringList)
   {
     QComboBox *comboBox = qobject_cast<QComboBox *>(editor);
     comboBox->setCurrentIndex(comboBox->findText(index.data().toString()));
   }
   if (data.type() == QVariant::Color)
   {
     QmitkColorWidget *colorWidget = qobject_cast<QmitkColorWidget *>(editor);
     colorWidget->SetColor(data.value<QColor>());
   }
   else
   {
     QStyledItemDelegate::setEditorData(editor, index);
   }
 }
 
 void QmitkPropertyItemDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (!data.isValid())
     return;
 
   if (data.type() == QVariant::Int)
   {
     QSpinBox *spinBox = qobject_cast<QSpinBox *>(editor);
     model->setData(index, spinBox->value());
   }
   else if (data.type() == QVariant::Double)
   {
     QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(editor);
     model->setData(index, spinBox->value());
   }
   else if (static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
   {
     QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(editor);
     model->setData(index, static_cast<float>(spinBox->value()));
   }
   else if (data.type() == QVariant::StringList)
   {
     QComboBox *comboBox = qobject_cast<QComboBox *>(editor);
     model->setData(index, comboBox->currentText());
   }
   else if (data.type() == QVariant::Color)
   {
     QmitkColorWidget *colorWidget = qobject_cast<QmitkColorWidget *>(editor);
     model->setData(index, colorWidget->GetColor());
   }
   else
   {
     QStyledItemDelegate::setModelData(editor, model, index);
   }
 }
 
 void QmitkPropertyItemDelegate::SetPropertyList(mitk::PropertyList *propertyList)
 {
   if (m_PropertyList != propertyList)
     m_PropertyList = propertyList;
 }
diff --git a/Modules/QtWidgetsExt/src/QmitkColorTransferFunctionCanvas.cpp b/Modules/QtWidgetsExt/src/QmitkColorTransferFunctionCanvas.cpp
index f0b9626bba..8c60514684 100755
--- a/Modules/QtWidgetsExt/src/QmitkColorTransferFunctionCanvas.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkColorTransferFunctionCanvas.cpp
@@ -1,152 +1,152 @@
 /*============================================================================
 
 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 "QmitkColorTransferFunctionCanvas.h"
 
 #include <QColorDialog>
 #include <QLineEdit>
 #include <QPainter>
 
 QmitkColorTransferFunctionCanvas::QmitkColorTransferFunctionCanvas(QWidget *parent, Qt::WindowFlags f)
   : QmitkTransferFunctionCanvas(parent, f), m_ColorTransferFunction(nullptr)
 {
   // used for drawing a border
   setContentsMargins(1, 1, 1, 1);
 }
 
 void QmitkColorTransferFunctionCanvas::SetTitle(const QString &title)
 {
   m_Title = title;
 }
 
 void QmitkColorTransferFunctionCanvas::paintEvent(QPaintEvent *)
 {
   QPainter painter(this);
 
   // Render gray background
   QRect contentsRect = this->contentsRect();
   painter.setPen(Qt::gray);
   painter.drawRect(0, 0, contentsRect.width() + 1, contentsRect.height() + 1);
 
   if (!this->isEnabled())
     return;
 
   if (m_ColorTransferFunction)
   {
     for (int x = contentsRect.x(); x < contentsRect.x() + contentsRect.width(); x++)
     {
       double xVal = m_Min + ((float)x) / contentsRect.width() * (m_Max - m_Min);
       QColor col((int)(m_ColorTransferFunction->GetRedValue(xVal) * 255),
                  (int)(m_ColorTransferFunction->GetGreenValue(xVal) * 255),
                  (int)(m_ColorTransferFunction->GetBlueValue(xVal) * 255));
       painter.setPen(col);
       painter.drawLine(x, 1, x, contentsRect.height());
     }
   }
 
   // paint title
   if (m_Title.size() > 0)
   {
     painter.setPen(Qt::black);
     painter.drawText(QPoint(11, 21), m_Title);
     painter.setPen(Qt::white);
     painter.drawText(QPoint(10, 20), m_Title);
   }
 
   // paint min and max
   QString qs_min = QString::number(m_Min);
   QString qs_max = QString::number(m_Max);
 
   QRect qr_min = painter.fontMetrics().boundingRect(qs_min);
   QRect qr_max = painter.fontMetrics().boundingRect(qs_max);
 
   int y, x;
 
   y = this->contentsRect().height() - qr_min.height() + 5;
   x = 10;
 
   painter.setPen(Qt::black);
   painter.drawText(QPoint(x + 1, y + 1), qs_min);
   painter.setPen(Qt::white);
   painter.drawText(QPoint(x, y), qs_min);
 
   y = this->contentsRect().height() - qr_max.height() + 5;
   x = this->contentsRect().width() - qr_max.width() - 6;
 
   painter.setPen(Qt::black);
   painter.drawText(QPoint(x, y + 1), qs_max);
   painter.setPen(Qt::white);
   painter.drawText(QPoint(x, y), qs_max);
 
   if (m_ColorTransferFunction)
   {
     // now paint the handles
     painter.setBrush(Qt::black);
     painter.setPen(Qt::black);
     for (int i = 0; i < this->GetFunctionSize(); i++)
     {
       int handleHeight = (i == m_GrabbedHandle) ? (int)(contentsRect.height() / 1.5) : contentsRect.height() / 2;
       int handleWidth = (i == m_GrabbedHandle) ? 6 : 4;
       std::pair<int, int> point = this->FunctionToCanvas(std::make_pair(GetFunctionX(i), 0.0f));
       int y = height() / 2;
-      painter.drawRoundRect(point.first - handleWidth / 2, y - handleHeight / 2, handleWidth, handleHeight, 50, 50);
+      painter.drawRoundedRect(point.first - handleWidth / 2, y - handleHeight / 2, handleWidth, handleHeight, 50, 50);
 
       if (i == m_GrabbedHandle && m_LineEditAvailable)
       {
         int xCursor = m_XEdit->cursorPosition();
         m_XEdit->setText(QString::number(GetFunctionX(m_GrabbedHandle), 'g', 4));
         m_XEdit->setCursorPosition(xCursor);
       }
     }
   }
 }
 
 int QmitkColorTransferFunctionCanvas::GetNearHandle(int x, int, unsigned int maxSquaredDistance)
 {
   for (int i = 0; i < this->GetFunctionSize(); i++)
   {
     std::pair<int, int> point = this->FunctionToCanvas(std::make_pair(GetFunctionX(i), (double)0.0));
     if ((unsigned int)((point.first - x) * (point.first - x)) < maxSquaredDistance)
     {
       return i;
     }
   }
   return -1;
 }
 
 void QmitkColorTransferFunctionCanvas::DoubleClickOnHandle(int handle)
 {
   double xVal = GetFunctionX(handle);
   QColor col((int)(m_ColorTransferFunction->GetRedValue(xVal) * 255),
              (int)(m_ColorTransferFunction->GetGreenValue(xVal) * 255),
              (int)(m_ColorTransferFunction->GetBlueValue(xVal) * 255));
   QColor result = QColorDialog::getColor(col);
   if (result.isValid())
   {
     m_ColorTransferFunction->AddRGBPoint(xVal, result.red() / 255.0, result.green() / 255.0, result.blue() / 255.0);
     this->update();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkColorTransferFunctionCanvas::MoveFunctionPoint(int index, std::pair<double, double> pos)
 {
   double color[3];
   m_ColorTransferFunction->GetColor(GetFunctionX(index), color);
   RemoveFunctionPoint(GetFunctionX(index));
   m_ColorTransferFunction->AddRGBPoint(pos.first, color[0], color[1], color[2]);
 }
 
 void QmitkColorTransferFunctionCanvas::AddRGB(double x, double r, double g, double b)
 {
   m_ColorTransferFunction->AddRGBPoint(x, r, g, b);
 }
diff --git a/Modules/QtWidgetsExt/src/QmitkGnuplotWidget.cpp b/Modules/QtWidgetsExt/src/QmitkGnuplotWidget.cpp
index 76527b197d..d7dce8f540 100644
--- a/Modules/QtWidgetsExt/src/QmitkGnuplotWidget.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkGnuplotWidget.cpp
@@ -1,217 +1,217 @@
 /*============================================================================
 
 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 "QmitkGnuplotWidget.h"
 #include <QClipboard>
 #include <QContextMenuEvent>
 #include <QMenu>
 #include <ui_QmitkGnuplotWidget.h>
 
 QmitkGnuplotWidget::QmitkGnuplotWidget(QWidget *parent)
   : QWidget(parent),
     m_Ui(new Ui::QmitkGnuplotWidget),
     m_ContextMenu(nullptr),
     m_CopyPlotAction(nullptr),
     m_CopyScriptAction(nullptr),
     m_Process(new QProcess(this))
 {
   m_Ui->setupUi(this);
 
   connect(
     m_Process, SIGNAL(stateChanged(QProcess::ProcessState)), this, SLOT(OnProcessStateChanged(QProcess::ProcessState)));
   connect(m_Process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(OnProcessError(QProcess::ProcessError)));
   connect(
     m_Process, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(OnProcessFinished(int, QProcess::ExitStatus)));
 
   this->CreateContextMenu();
 }
 
 QmitkGnuplotWidget::~QmitkGnuplotWidget()
 {
 }
 
 void QmitkGnuplotWidget::CreateContextMenu()
 {
   m_CopyPlotAction = new QAction("Copy &Plot", this);
   connect(m_CopyPlotAction, SIGNAL(triggered()), this, SLOT(OnCopyPlot()));
 
   m_CopyScriptAction = new QAction("Copy &Script", this);
   connect(m_CopyScriptAction, SIGNAL(triggered()), this, SLOT(OnCopyScript()));
 
   m_ContextMenu = new QMenu(this);
 
   m_ContextMenu->addActions(QList<QAction *>() << m_CopyPlotAction << m_CopyScriptAction);
 }
 
 void QmitkGnuplotWidget::contextMenuEvent(QContextMenuEvent *event)
 {
-  const QPixmap *plot = m_Ui->label->pixmap();
+  auto plot = m_Ui->label->pixmap();
 
-  m_CopyPlotAction->setEnabled(plot != nullptr && !plot->isNull());
+  m_CopyPlotAction->setEnabled(!plot.isNull());
   m_CopyScriptAction->setEnabled(!m_Commands.empty());
 
   m_ContextMenu->popup(event->globalPos());
 
   event->accept();
 }
 
 void QmitkGnuplotWidget::OnCopyPlot()
 {
-  const QPixmap *plot = m_Ui->label->pixmap();
+  auto plot = m_Ui->label->pixmap();
 
-  if (plot != nullptr && !plot->isNull())
-    QApplication::clipboard()->setPixmap(*plot);
+  if (!plot.isNull())
+    QApplication::clipboard()->setPixmap(plot);
 }
 
 void QmitkGnuplotWidget::OnCopyScript()
 {
   if (m_Commands.empty())
     return;
 
   QString script = this->CreateSetTermCommand();
 
   Q_FOREACH (const QString &command, m_Commands)
   {
     script += command + "\n";
   }
 
   QApplication::clipboard()->setText(script);
 }
 
 void QmitkGnuplotWidget::resizeEvent(QResizeEvent *)
 {
   m_ModifiedTime.Modified();
 
   if (m_Process->isOpen() || m_Commands.isEmpty() || m_GnuplotPath.isEmpty())
     return;
 
   this->Update();
 }
 
 QString QmitkGnuplotWidget::GetGnuplotPath() const
 {
   return m_GnuplotPath;
 }
 
 void QmitkGnuplotWidget::SetGnuplotPath(const QString &path)
 {
   m_GnuplotPath = path;
   m_ModifiedTime.Modified();
 }
 
 QStringList QmitkGnuplotWidget::GetCommands() const
 {
   return m_Commands;
 }
 
 void QmitkGnuplotWidget::SetCommands(const QStringList &commands)
 {
   m_Commands = commands;
   m_ModifiedTime.Modified();
 }
 
 void QmitkGnuplotWidget::Update()
 {
   if (m_UpdateTime < m_ModifiedTime)
     m_Process->start(m_GnuplotPath, QStringList() << "-");
 }
 
 QSize QmitkGnuplotWidget::sizeHint() const
 {
   return QSize(400, 300);
 }
 
 QString QmitkGnuplotWidget::CreateSetTermCommand() const
 {
   return QString("set term pngcairo size %1,%2 enhanced font '%3,%4'\n")
     .arg(this->width())
     .arg(this->height())
     .arg(this->font().family())
     .arg(this->font().pointSize());
 }
 
 void QmitkGnuplotWidget::OnProcessStateChanged(QProcess::ProcessState state)
 {
   if (state == QProcess::Running)
   {
     m_UpdateTime = m_ModifiedTime;
 
     m_Process->write(this->CreateSetTermCommand().toLatin1());
 
     Q_FOREACH (const QString &command, m_Commands)
     {
       m_Process->write(QString("%1\n").arg(command).toLatin1());
     }
 
     m_Process->write("exit\n");
     m_Process->closeWriteChannel();
   }
 }
 
 void QmitkGnuplotWidget::OnProcessError(QProcess::ProcessError error)
 {
   switch (error)
   {
     case QProcess::FailedToStart:
       m_Ui->label->setText("Gnuplot failed to start!");
       break;
 
     case QProcess::Crashed:
       m_Ui->label->setText("Gnuplot crashed!");
       break;
 
     case QProcess::Timedout:
       m_Ui->label->setText("Gnuplot timed out!");
       break;
 
     case QProcess::WriteError:
       m_Ui->label->setText("Could not write to gnuplot!");
       break;
 
     case QProcess::ReadError:
       m_Ui->label->setText("Could not read from gnuplot!");
       break;
 
     default:
       m_Ui->label->setText("An unknown error occurred!");
       break;
   }
 }
 
 void QmitkGnuplotWidget::OnProcessFinished(int exitCode, QProcess::ExitStatus exitStatus)
 {
   bool needUpdate = false;
 
   if (exitStatus != QProcess::CrashExit)
   {
     if (exitCode == 0)
     {
       if (m_UpdateTime < m_ModifiedTime)
       {
         needUpdate = true;
       }
       else
       {
         m_Ui->label->setPixmap(QPixmap::fromImage(QImage::fromData(m_Process->readAllStandardOutput(), "PNG")));
       }
     }
     else
     {
       m_Ui->label->setText(QString("Gnuplot exit code: %1!").arg(exitCode));
     }
   }
 
   m_Process->close();
 
   if (needUpdate)
     this->Update();
 }
diff --git a/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.cpp b/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.cpp
index 8161333a64..ec38c48b6b 100644
--- a/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.cpp
+++ b/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.cpp
@@ -1,320 +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 "berryHelpEditor.h"
 
 #include "berryHelpEditorInput.h"
 #include "berryHelpPluginActivator.h"
 #include "berryHelpPerspective.h"
 #include "berryHelpWebView.h"
 #include "berryQHelpEngineWrapper.h"
 #include "berryHelpEditorFindWidget.h"
 #include "berryHelpPluginActivator.h"
 #include "berryQHelpEngineWrapper.h"
 
 #include <berryUIException.h>
 #include <berryPlatformUI.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIWorkbenchPartConstants.h>
 
 #include <QToolBar>
 #include <QHelpEngine>
 #include <QVBoxLayout>
+#include <QWebEngineFindTextResult>
 
 namespace berry {
 
 const QString HelpEditor::EDITOR_ID = "org.blueberry.editors.help";
 
 HelpEditor::HelpEditor()
   : m_ToolBar(nullptr)
   , m_WebEngineView(nullptr)
 {
 
 }
 
 HelpEditor::~HelpEditor()
 {
   this->GetSite()->GetPage()->RemovePartListener(this);
   this->GetSite()->GetPage()->GetWorkbenchWindow()->RemovePerspectiveListener(this);
 }
 
 void HelpEditor::Init(berry::IEditorSite::Pointer site, berry::IEditorInput::Pointer input)
 {
   if (input.Cast<HelpEditorInput>().IsNull())
      throw PartInitException("Invalid Input: Must be berry::HelpEditorInput");
 
   this->SetSite(site);
   site->GetPage()->AddPartListener(this);
   site->GetPage()->GetWorkbenchWindow()->AddPerspectiveListener(this);
 
   m_WebEngineView = new HelpWebView(site, nullptr);
 
   connect(m_WebEngineView, SIGNAL(loadFinished(bool)), this, SLOT(InitializeTitle()));
 
   this->DoSetInput(input);
 }
 
 void HelpEditor::CreateQtPartControl(QWidget* parent)
 {
   auto   verticalLayout = new QVBoxLayout(parent);
   verticalLayout->setSpacing(0);
   verticalLayout->setContentsMargins(0, 0, 0, 0);
 
   m_ToolBar = new QToolBar(parent);
   m_ToolBar->setMaximumHeight(32);
   verticalLayout->addWidget(m_ToolBar);
 
   m_WebEngineView->setParent(parent);
   m_WebEngineView->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   verticalLayout->addWidget(m_WebEngineView);
 
   m_FindWidget = new HelpEditorFindWidget(parent);
   m_FindWidget->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Maximum);
   verticalLayout->addWidget(m_FindWidget);
   m_FindWidget->hide();
 
   connect(m_FindWidget, SIGNAL(findNext()), this, SLOT(findNext()));
   connect(m_FindWidget, SIGNAL(findPrevious()), this, SLOT(findPrevious()));
   connect(m_FindWidget, SIGNAL(find(QString, bool)), this,
           SLOT(find(QString, bool)));
   connect(m_FindWidget, SIGNAL(escapePressed()), m_WebEngineView, SLOT(setFocus()));
 
   // Fill the editor toolbar
   m_BackAction = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/go-previous.png"), "Go back",
                                              m_WebEngineView, SLOT(backward()));
   m_ForwardAction = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/go-next.png"), "Go forward",
                                                 m_WebEngineView, SLOT(forward()));
   m_HomeAction = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/go-home.png"), "Go home",
                                       m_WebEngineView, SLOT(home()));
 
   m_ToolBar->addSeparator();
 
   m_FindAction = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/find.png"), "Find in text",
                                              this, SLOT(ShowTextSearch()));
 
   m_ToolBar->addSeparator();
 
   m_ZoomIn = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/zoom-in.png"), "Zoom in", m_WebEngineView, SLOT(scaleUp()));
   m_ZoomOut = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/zoom-out.png"), "Zoom out", m_WebEngineView, SLOT(scaleDown()));
 
   m_ToolBar->addSeparator();
 
   m_OpenHelpMode = m_ToolBar->addAction("Open Help Perspective", this, SLOT(OpenHelpPerspective()));
   m_CloseHelpMode = m_ToolBar->addAction("Close Help Perspective", this, SLOT(CloseHelpPerspective()));
   IPerspectiveDescriptor::Pointer currPersp = this->GetSite()->GetPage()->GetPerspective();
   m_OpenHelpMode->setVisible(!(currPersp.IsNotNull() && currPersp->GetId() == HelpPerspective::ID));
   m_CloseHelpMode->setVisible((currPersp.IsNotNull() && currPersp->GetId() == HelpPerspective::ID));
 
   connect(m_WebEngineView, SIGNAL(backwardAvailable(bool)), m_BackAction, SLOT(setEnabled(bool)));
   connect(m_WebEngineView, SIGNAL(forwardAvailable(bool)), m_ForwardAction, SLOT(setEnabled(bool)));
 
   m_BackAction->setEnabled(false);
   m_ForwardAction->setEnabled(false);
   m_HomeAction->setEnabled(!HelpPluginActivator::getInstance()->getQHelpEngine().homePage().isEmpty());
 
   connect(&HelpPluginActivator::getInstance()->getQHelpEngine(), SIGNAL(homePageChanged(QString)),
           this, SLOT(HomePageChanged(QString)));
 }
 
 void HelpEditor::DoSetInput(IEditorInput::Pointer input)
 {
   if (input.IsNull())
   {
     // close editor
     class CloseEditorRunnable : public Poco::Runnable
     {
     private:
       IEditorPart::Pointer editor;
 
     public:
       CloseEditorRunnable(IEditorPart::Pointer editor)
         : editor(editor)
       {}
 
       void run() override
       {
         editor->GetSite()->GetPage()->CloseEditor(editor, false);
         delete this;
       }
     };
 
     Display::GetDefault()->AsyncExec(new CloseEditorRunnable(IEditorPart::Pointer(this)));
   }
   else
   {
     // an empty url represents the home page
     HelpEditorInput::Pointer helpInput = input.Cast<HelpEditorInput>();
     QString currHomePage = HelpPluginActivator::getInstance()->getQHelpEngine().homePage();
     if (helpInput->GetUrl().isEmpty() && !currHomePage.isEmpty())
     {
       helpInput = HelpEditorInput::Pointer(new HelpEditorInput(currHomePage));
     }
     QtEditorPart::SetInput(helpInput);
     m_WebEngineView->setSource(helpInput->GetUrl());
   }
 }
 
 void HelpEditor::SetInputWithNotify(IEditorInput::Pointer input)
 {
   DoSetInput(input);
   FirePropertyChange(IWorkbenchPartConstants::PROP_INPUT);
 }
 
 void HelpEditor::SetInput(IEditorInput::Pointer input)
 {
   SetInputWithNotify(input);
 }
 
 void HelpEditor::HomePageChanged(const QString &page)
 {
   if (page.isEmpty())
   {
     m_HomeAction->setEnabled(false);
   }
 
   m_HomeAction->setEnabled(true);
   if (this->GetEditorInput().Cast<HelpEditorInput>()->GetUrl().isEmpty())
   {
     IEditorInput::Pointer newInput(new HelpEditorInput(page));
     DoSetInput(newInput);
   }
 }
 
 void HelpEditor::OpenHelpPerspective()
 {
   PlatformUI::GetWorkbench()->ShowPerspective(HelpPerspective::ID, this->GetSite()->GetPage()->GetWorkbenchWindow());
 }
 
 void HelpEditor::CloseHelpPerspective()
 {
   berry::IWorkbenchPage::Pointer
     page =
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
   page->ClosePerspective(page->GetPerspective(), true, true);
 }
 
 void HelpEditor::InitializeTitle()
 {
   QString title = m_WebEngineView->title();
   this->SetPartName(title);
 }
 
 void HelpEditor::ShowTextSearch()
 {
   m_FindWidget->show();
 }
 
 void HelpEditor::SetFocus()
 {
   m_WebEngineView->setFocus();
 
   enableShortcuts();
 }
 
 QWebEnginePage *HelpEditor::GetQWebPage() const
 {
   return m_WebEngineView->page();
 }
 
 IPartListener::Events::Types HelpEditor::GetPartEventTypes() const
 {
   return IPartListener::Events::DEACTIVATED;
 }
 
 void HelpEditor::PartDeactivated(const IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef == GetSite()->GetPage()->GetReference(IWorkbenchPart::Pointer(this)))
     disableShortcuts();
 }
 
 IPerspectiveListener::Events::Types HelpEditor::GetPerspectiveEventTypes() const
 {
   return IPerspectiveListener::Events::ACTIVATED | IPerspectiveListener::Events::DEACTIVATED;
 }
 
 void HelpEditor::PerspectiveActivated(const SmartPointer<IWorkbenchPage>& /*page*/,
                                       const IPerspectiveDescriptor::Pointer& perspective)
 {
   if (perspective->GetId() == HelpPerspective::ID)
   {
     m_OpenHelpMode->setVisible(false);
     m_CloseHelpMode->setVisible(true);
   }
 }
 
 void HelpEditor::PerspectiveDeactivated(const SmartPointer<IWorkbenchPage>& /*page*/,
                                         const IPerspectiveDescriptor::Pointer& perspective)
 {
   if (perspective->GetId() == HelpPerspective::ID)
   {
     m_OpenHelpMode->setVisible(true);
     m_CloseHelpMode->setVisible(false);
   }
 }
 
 void HelpEditor::findNext()
 {
   find(m_FindWidget->text(), true);
 }
 
 void HelpEditor::findPrevious()
 {
   find(m_FindWidget->text(), false);
 }
 
 void HelpEditor::find(const QString &ttf, bool forward)
 {
   this->findInWebPage(ttf, forward);
 
   if (!m_FindWidget->isVisible())
     m_FindWidget->show();
 }
 
 void HelpEditor::findInWebPage(const QString &ttf, bool forward)
 {
   if (ttf.isEmpty())
   {
     m_WebEngineView->findText(ttf);
     m_FindWidget->setPalette(true);
     return;
   }
 
   QWebEnginePage::FindFlags options;
 
   if (!forward)
     options |= QWebEnginePage::FindBackward;
 
   if (m_FindWidget->caseSensitive())
     options |= QWebEnginePage::FindCaseSensitively;
 
-  m_WebEngineView->findText(ttf, options, [this](bool found) { m_FindWidget->setPalette(found); });
+  m_WebEngineView->findText(ttf, options, [this](const QWebEngineFindTextResult& result) { m_FindWidget->setPalette(result.numberOfMatches() != 0); });
 }
 
 void HelpEditor::enableShortcuts()
 {
   m_BackAction->setShortcut(QKeySequence::Back);
   m_ForwardAction->setShortcut(QKeySequence::Forward);
   m_FindAction->setShortcut(QKeySequence::Find);
   m_ZoomIn->setShortcut(QKeySequence::ZoomIn);
   m_ZoomOut->setShortcut(QKeySequence::ZoomOut);
 }
 
 void HelpEditor::disableShortcuts()
 {
   m_BackAction->setShortcut(QKeySequence());
   m_ForwardAction->setShortcut(QKeySequence());
   m_FindAction->setShortcut(QKeySequence());
   m_ZoomIn->setShortcut(QKeySequence());
   m_ZoomOut->setShortcut(QKeySequence());
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpWebView.cpp b/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpWebView.cpp
index 55ebd3efc6..1e81da25a5 100644
--- a/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpWebView.cpp
+++ b/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpWebView.cpp
@@ -1,450 +1,450 @@
 /*============================================================================
 
 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 "berryHelpWebView.h"
 
 #include "berryHelpPluginActivator.h"
 #include "berryHelpEditor.h"
 #include "berryHelpEditorInput.h"
 #include "berryQHelpEngineWrapper.h"
 
 #include <berryIWorkbenchPage.h>
 
 #include <QCoreApplication>
 #include <QTimer>
 #include <QStringBuilder>
 #include <QTemporaryFile>
 #include <QDesktopServices>
 #include <QWheelEvent>
 
 #include <QWebEngineSettings>
 #include <QWebEngineUrlSchemeHandler>
 #include <QWebEngineUrlRequestJob>
 #include <QWebEngineProfile>
 
 namespace berry {
 
 struct ExtensionMap {
   const char *extension;
   const char *mimeType;
 } extensionMap[] = {
     { ".bmp", "image/bmp" },
     { ".css", "text/css" },
     { ".gif", "image/gif" },
     { ".html", "text/html" },
     { ".htm", "text/html" },
     { ".ico", "image/x-icon" },
     { ".jpeg", "image/jpeg" },
     { ".jpg", "image/jpeg" },
     { ".js", "application/x-javascript" },
     { ".mng", "video/x-mng" },
     { ".pbm", "image/x-portable-bitmap" },
     { ".pgm", "image/x-portable-graymap" },
     { ".pdf", "application/pdf" },
     { ".png", "image/png" },
     { ".ppm", "image/x-portable-pixmap" },
     { ".rss", "application/rss+xml" },
     { ".svg", "image/svg+xml" },
     { ".svgz", "image/svg+xml" },
     { ".text", "text/plain" },
     { ".tif", "image/tiff" },
     { ".tiff", "image/tiff" },
     { ".txt", "text/plain" },
     { ".xbm", "image/x-xbitmap" },
     { ".xml", "text/xml" },
     { ".xpm", "image/x-xpm" },
     { ".xsl", "text/xsl" },
     { ".xhtml", "application/xhtml+xml" },
     { ".wml", "text/vnd.wap.wml" },
     { ".wmlc", "application/vnd.wap.wmlc" },
     { "about:blank", nullptr },
     { nullptr, nullptr }
 };
 
 class HelpDeviceReply final : public QIODevice
 {
 public:
   HelpDeviceReply(const QUrl& request, const QByteArray& fileData);
   ~HelpDeviceReply() override;
 
   qint64 bytesAvailable() const override;
   void close() override;
 
 private:
   qint64 readData(char* data, qint64 maxlen) override;
   qint64 writeData(const char* data, qint64 maxlen) override;
 
   QByteArray m_Data;
   const qint64 m_OrigLen;
 };
 
 HelpDeviceReply::HelpDeviceReply(const QUrl&, const QByteArray& fileData)
   : m_Data(fileData),
     m_OrigLen(fileData.length())
 {
   this->setOpenMode(QIODevice::ReadOnly);
 
   QTimer::singleShot(0, this, &QIODevice::readyRead);
   QTimer::singleShot(0, this, &QIODevice::readChannelFinished);
 }
 
 HelpDeviceReply::~HelpDeviceReply()
 {
 }
 
 qint64 HelpDeviceReply::bytesAvailable() const
 {
   return m_Data.length() + QIODevice::bytesAvailable();
 }
 
 void HelpDeviceReply::close()
 {
   QIODevice::close();
   this->deleteLater();
 }
 
 qint64 HelpDeviceReply::readData(char* data, qint64 maxlen)
 {
   qint64 len = qMin(qint64(m_Data.length()), maxlen);
 
   if (len)
   {
     memcpy(data, m_Data.constData(), len);
     m_Data.remove(0, len);
   }
 
   return len;
 }
 
 qint64 HelpDeviceReply::writeData(const char*, qint64)
 {
   return 0;
 }
 
 
 class HelpUrlSchemeHandler final : public QWebEngineUrlSchemeHandler
 {
 public:
   explicit HelpUrlSchemeHandler(QObject* parent = nullptr);
   ~HelpUrlSchemeHandler() override;
 
   void requestStarted(QWebEngineUrlRequestJob* job) override;
 };
 
 HelpUrlSchemeHandler::HelpUrlSchemeHandler(QObject* parent)
   : QWebEngineUrlSchemeHandler(parent)
 {
 }
 
 HelpUrlSchemeHandler::~HelpUrlSchemeHandler()
 {
 }
 
 enum class ResolveUrlResult
 {
   Error,
   Redirect,
   Data
 };
 
 ResolveUrlResult ResolveUrl(const QUrl& url, QUrl& redirectedUrl, QByteArray& data)
 {
   auto& helpEngine = HelpPluginActivator::getInstance()->getQHelpEngine();
 
   const auto targetUrl = helpEngine.findFile(url);
 
   if (!targetUrl.isValid())
     return ResolveUrlResult::Error;
 
   if (targetUrl != url)
   {
     redirectedUrl = targetUrl;
     return ResolveUrlResult::Redirect;
   }
 
   data = helpEngine.fileData(targetUrl);
   return ResolveUrlResult::Data;
 }
 
 
 void HelpUrlSchemeHandler::requestStarted(QWebEngineUrlRequestJob* job)
 {
   QUrl url = job->requestUrl();
   QUrl redirectedUrl;
   QByteArray data;
 
   switch (ResolveUrl(url, redirectedUrl, data))
   {
   case ResolveUrlResult::Data:
     job->reply(
       HelpWebView::mimeFromUrl(url).toLatin1(),
       new HelpDeviceReply(url, data));
     break;
 
   case ResolveUrlResult::Redirect:
     job->redirect(redirectedUrl);
     break;
 
   case ResolveUrlResult::Error:
     job->reply(
       QByteArrayLiteral("text/html"),
       new HelpDeviceReply(url, HelpWebView::m_PageNotFoundMessage.arg(url.toString()).toUtf8()));
     break;
   }
 }
 
 const QString HelpWebView::m_PageNotFoundMessage =
     QCoreApplication::translate("org.blueberry.ui.qt.help", "<title>Context Help</title><div "
                                 "align=\"center\"><br><br><h1>No help page found for identifier</h1><br><h3>'%1'"
                                 "</h3></div>");
 
 const QString HelpWebView::m_MissingContextMessage =
     QCoreApplication::translate("org.blueberry.ui.qt.help", "<title>Context Help</title><div "
                                 "align=\"center\"><br><br><h1>Unknown context..</h1><h1>&nbsp;</h1><h1>Please click inside a view and hit F1 again!</h1></div>");
 
 class HelpPage final : public QWebEnginePage
 {
 public:
   explicit HelpPage(QObject* parent = nullptr);
   ~HelpPage() override;
 
 private:
   bool acceptNavigationRequest(const QUrl& url, NavigationType type, bool isMainFrame) override;
 };
 
 HelpPage::HelpPage(QObject* parent)
   : QWebEnginePage(parent)
 {
 }
 
 HelpPage::~HelpPage()
 {
 }
 
 bool HelpPage::acceptNavigationRequest(const QUrl& url, NavigationType, bool)
 {
   if (url.scheme().contains("http"))
   {
     QDesktopServices::openUrl(url);
     return false;
   }
 
   return true;
 }
 
 HelpWebView::HelpWebView(IEditorSite::Pointer, QWidget *parent, qreal zoom)
   : QWebEngineView(parent),
     m_LoadFinished(false),
     m_HelpEngine(HelpPluginActivator::getInstance()->getQHelpEngine()),
     m_HelpSchemeHandler(new HelpUrlSchemeHandler(this))
 {
   QWebEngineProfile::defaultProfile()->installUrlSchemeHandler("qthelp", m_HelpSchemeHandler);
 
   auto helpPage = new HelpPage(this);
   this->setPage(helpPage);
 
   this->setAcceptDrops(false);
 
   auto action = pageAction(QWebEnginePage::OpenLinkInNewWindow);
   action->setText("Open Link in New Tab");
 
   if (parent == nullptr)
     action->setVisible(false);
 
   this->pageAction(QWebEnginePage::DownloadLinkToDisk)->setVisible(false);
   this->pageAction(QWebEnginePage::DownloadImageToDisk)->setVisible(false);
 
   connect(pageAction(QWebEnginePage::Copy), SIGNAL(changed()), this, SLOT(actionChanged()));
   connect(pageAction(QWebEnginePage::Back), SIGNAL(changed()), this, SLOT(actionChanged()));
   connect(pageAction(QWebEnginePage::Forward), SIGNAL(changed()), this, SLOT(actionChanged()));
   connect(page(), SIGNAL(linkHovered(QString)), this, SIGNAL(highlighted(QString)));
   connect(this, SIGNAL(urlChanged(QUrl)), this, SIGNAL(sourceChanged(QUrl)));
   connect(this, SIGNAL(loadStarted()), this, SLOT(setLoadStarted()));
   connect(this, SIGNAL(loadFinished(bool)), this, SLOT(setLoadFinished(bool)));
 
   this->setFont(this->viewerFont());
   this->setZoomFactor(zoom == 0.0 ? 1.0 : zoom);
 }
 
 HelpWebView::~HelpWebView()
 {
 }
 
 QFont HelpWebView::viewerFont() const
 {
-  QWebEngineSettings *webSettings = QWebEngineSettings::globalSettings();
+  QWebEngineSettings* webSettings = settings();
   return QFont(webSettings->fontFamily(QWebEngineSettings::StandardFont),
                webSettings->fontSize(QWebEngineSettings::DefaultFontSize));
 }
 
 void HelpWebView::setViewerFont(const QFont &font)
 {
   QWebEngineSettings *webSettings = settings();
   webSettings->setFontFamily(QWebEngineSettings::StandardFont, font.family());
   webSettings->setFontSize(QWebEngineSettings::DefaultFontSize, font.pointSize());
 }
 
 void HelpWebView::scaleUp()
 {
   setZoomFactor(zoomFactor() + 0.1);
 }
 
 void HelpWebView::scaleDown()
 {
   setZoomFactor(qMax(0.0, zoomFactor() - 0.1));
 }
 
 void HelpWebView::resetScale()
 {
   setZoomFactor(1.0);
 }
 
 bool HelpWebView::handleForwardBackwardMouseButtons(QMouseEvent *e)
 {
   if (e->button() == Qt::XButton1)
   {
     triggerPageAction(QWebEnginePage::Back);
     return true;
   }
 
   if (e->button() == Qt::XButton2)
   {
     triggerPageAction(QWebEnginePage::Forward);
     return true;
   }
 
   return false;
 }
 
 void HelpWebView::setSource(const QUrl &url)
 {
   if (url.toString().trimmed().isEmpty()) {
     setHtml(m_MissingContextMessage);
   }
   else if (m_HelpEngine.findFile(url).isValid())
   {
     load(url);
   }
   else
   {
     setHtml(m_PageNotFoundMessage.arg(url.toString()));
   }
 }
 
 void HelpWebView::wheelEvent(QWheelEvent *e)
 {
   if (e->modifiers()& Qt::ControlModifier)
   {
     e->accept();
     e->angleDelta().y() > 0 ? scaleUp() : scaleDown();
   }
   else
   {
     QWebEngineView::wheelEvent(e);
   }
 }
 
 void HelpWebView::actionChanged()
 {
   QAction *a = qobject_cast<QAction *>(sender());
   if (a == pageAction(QWebEnginePage::Copy))
     emit copyAvailable(a->isEnabled());
   else if (a == pageAction(QWebEnginePage::Back))
     emit backwardAvailable(a->isEnabled());
   else if (a == pageAction(QWebEnginePage::Forward))
     emit forwardAvailable(a->isEnabled());
 }
 
 void HelpWebView::setLoadStarted()
 {
   m_LoadFinished = false;
 }
 
 void HelpWebView::setLoadFinished(bool ok)
 {
   m_LoadFinished = ok;
   emit sourceChanged(url());
 }
 
 QString HelpWebView::mimeFromUrl(const QUrl &url)
 {
   const QString &path = url.path();
   const int index = path.lastIndexOf(QLatin1Char('.'));
   const QByteArray &ext = path.mid(index).toUtf8().toLower();
 
   const ExtensionMap *e = extensionMap;
   while (e->extension)
   {
     if (ext == e->extension)
       return QLatin1String(e->mimeType);
     ++e;
   }
   return QLatin1String("");
 }
 
 bool HelpWebView::canOpenPage(const QString &url)
 {
   return !mimeFromUrl(url).isEmpty();
 }
 
 bool HelpWebView::isLocalUrl(const QUrl &url)
 {
   const QString &scheme = url.scheme();
   return scheme.isEmpty()
       || scheme == QLatin1String("file")
       || scheme == QLatin1String("qrc")
       || scheme == QLatin1String("data")
       || scheme == QLatin1String("qthelp")
       || scheme == QLatin1String("about");
 }
 
 bool HelpWebView::launchWithExternalApp(const QUrl &url)
 {
   if (isLocalUrl(url))
   {
     const QHelpEngine& helpEngine = HelpPluginActivator::getInstance()->getQHelpEngine();
     const QUrl &resolvedUrl = helpEngine.findFile(url);
     if (!resolvedUrl.isValid())
       return false;
 
     const QString& path = resolvedUrl.path();
     if (!canOpenPage(path))
     {
       QTemporaryFile tmpTmpFile;
       if (!tmpTmpFile.open())
         return false;
 
       const QString &extension = QFileInfo(path).completeSuffix();
       QFile actualTmpFile(tmpTmpFile.fileName() % QLatin1String(".")
                           % extension);
       if (!actualTmpFile.open(QIODevice::ReadWrite | QIODevice::Truncate))
         return false;
 
       actualTmpFile.write(helpEngine.fileData(resolvedUrl));
       actualTmpFile.close();
       return QDesktopServices::openUrl(QUrl(actualTmpFile.fileName()));
     }
   }
   else if (url.scheme() == QLatin1String("http"))
   {
     return QDesktopServices::openUrl(url);
   }
   return false;
 }
 
 void HelpWebView::home()
 {
   setSource(m_HelpEngine.homePage());
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryPerspective.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryPerspective.cpp
index ae868a8d1f..e058aaad62 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryPerspective.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryPerspective.cpp
@@ -1,1807 +1,1807 @@
 /*============================================================================
 
 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 "berryPerspective.h"
 
 #include "berryPerspectiveHelper.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryWorkbenchConstants.h"
 #include "berryPerspectiveExtensionReader.h"
 #include "berryEditorSashContainer.h"
 #include "berryPartSite.h"
 #include "berryViewSite.h"
 #include "berryEditorAreaHelper.h"
 #include "intro/berryIntroConstants.h"
 #include "berryWorkbenchWindow.h"
 #include "berryStatusUtil.h"
 #include "berryMultiStatus.h"
 #include "berryXMLMemento.h"
 
 #include "presentations/berryIStackPresentationSite.h"
 #include "berryIContextService.h"
 
 #include <QMessageBox>
 
 namespace berry
 {
 
 const QString Perspective::VERSION_STRING = "0.016";
 
 Perspective::Perspective(PerspectiveDescriptor::Pointer desc,
     WorkbenchPage::Pointer page)
  : descriptor(desc)
  {
   this->Register();
   this->Init(page);
   if (desc.IsNotNull())
   {
     this->CreatePresentation(desc);
   }
   this->UnRegister(false);
 }
 
 Perspective::Perspective(WorkbenchPage::Pointer page)
 {
   this->Init(page);
 }
 
 void Perspective::Init(WorkbenchPage::Pointer page)
 {
   editorHidden = false;
   editorAreaState = IStackPresentationSite::STATE_RESTORED;
   fixed = false;
   presentation = nullptr;
   shouldHideEditorsOnActivate = false;
   this->page = page.GetPointer();
   this->editorArea = page->GetEditorPresentation()->GetLayoutPart();
   this->viewFactory = page->GetViewFactory();
 }
 
 bool Perspective::BringToTop(IViewReference::Pointer ref)
 {
   return presentation->BringPartToTop(this->GetPane(ref));
 }
 
 bool Perspective::ContainsView(IViewPart::Pointer view)
 {
   IViewSite::Pointer site = view->GetViewSite();
   IViewReference::Pointer ref = this->FindView(site->GetId(), site->GetSecondaryId());
   if (ref.IsNull())
   {
     return false;
   }
   return (view.Cast<IWorkbenchPart>() == ref->GetPart(false));
 }
 
 bool Perspective::ContainsView(const QString& viewId) const
 {
   return mapIDtoViewLayoutRec.contains(viewId);
 }
 
 void Perspective::CreatePresentation(PerspectiveDescriptor::Pointer persp)
 {
   if (persp->HasCustomDefinition())
   {
     this->LoadCustomPersp(persp);
   }
   else
   {
     this->LoadPredefinedPersp(persp);
   }
 }
 
 Perspective::~Perspective()
 {
   // Get rid of presentation.
   if (presentation == nullptr)
   {
     DisposeViewRefs();
     return;
   }
 
   presentation->Deactivate();
 
   // Release each view.
   QList<IViewReference::Pointer> refs(this->GetViewReferences());
   for (auto & ref : refs)
   {
     this->GetViewFactory()->ReleaseView(ref);
   }
 
   mapIDtoViewLayoutRec.clear();
   delete presentation;
 }
 
 void Perspective::DisposeViewRefs()
 {
   if (!memento)
   {
     return;
   }
   QList<IMemento::Pointer> views(memento->GetChildren(WorkbenchConstants::TAG_VIEW));
   for (int x = 0; x < views.size(); x++)
   {
     // Get the view details.
     IMemento::Pointer childMem = views[x];
     QString id; childMem->GetString(WorkbenchConstants::TAG_ID, id);
     // skip creation of the intro reference - it's handled elsewhere.
     if (id == IntroConstants::INTRO_VIEW_ID)
     {
       continue;
     }
 
     QString secondaryId = ViewFactory::ExtractSecondaryId(id);
     if (!secondaryId.isEmpty())
     {
       id = ViewFactory::ExtractPrimaryId(id);
     }
 
     QString removed;
     childMem->GetString(WorkbenchConstants::TAG_REMOVED, removed);
     if (removed != "true")
     {
       IViewReference::Pointer ref = viewFactory->GetView(id, secondaryId);
       if (ref)
       {
         viewFactory->ReleaseView(ref);
       }
     }
   }
 }
 
 IViewReference::Pointer Perspective::FindView(const QString& viewId)
 {
   return this->FindView(viewId, "");
 }
 
 IViewReference::Pointer Perspective::FindView(const QString& id, const QString& secondaryId)
 {
   QList<IViewReference::Pointer> refs(this->GetViewReferences());
   for (int i = 0; i < refs.size(); i++)
   {
     IViewReference::Pointer ref = refs[i];
     if (id == ref->GetId()
         && (secondaryId  == ref->GetSecondaryId()))
     {
       return ref;
     }
   }
   return IViewReference::Pointer(nullptr);
 }
 
 QWidget* Perspective::GetClientComposite()
 {
   return page->GetClientComposite();
 }
 
 IPerspectiveDescriptor::Pointer Perspective::GetDesc()
 {
   return descriptor;
 }
 
 PartPane::Pointer Perspective::GetPane(IViewReference::Pointer ref)
 {
   return ref.Cast<WorkbenchPartReference>()->GetPane();
 }
 
 QList<QString> Perspective::GetPerspectiveShortcuts()
 {
   return perspectiveShortcuts;
 }
 
 PerspectiveHelper* Perspective::GetPresentation() const
 {
   return presentation;
 }
 
 QList<QString> Perspective::GetShowViewShortcuts()
 {
   return showViewShortcuts;
 }
 
 ViewFactory* Perspective::GetViewFactory()
 {
   return viewFactory;
 }
 
 QList<IViewReference::Pointer> Perspective::GetViewReferences()
 {
   // Get normal views.
   if (presentation == nullptr)
   {
     return QList<IViewReference::Pointer>();
   }
 
   QList<PartPane::Pointer> panes;
   presentation->CollectViewPanes(panes);
 
   QList<IViewReference::Pointer> result;
 //  List fastViews = (fastViewManager != 0) ?
 //  fastViewManager.getFastViews(0)
 //  : new ArrayList();
 //  IViewReference[] resultArray = new IViewReference[panes.size()
 //  + fastViews.size()];
 //
 //  // Copy fast views.
 //  int nView = 0;
 //  for (int i = 0; i < fastViews.size(); i++)
 //  {
 //    resultArray[nView] = (IViewReference) fastViews.get(i);
 //    ++nView;
 //  }
 
   // Copy normal views.
   for (QList<PartPane::Pointer>::iterator iter = panes.begin();
        iter != panes.end(); ++iter)
   {
     PartPane::Pointer pane = *iter;
     result.push_back(pane->GetPartReference().Cast<IViewReference>());
   }
 
   return result;
 }
 
 void Perspective::HideEditorArea()
 {
   if (!this->IsEditorAreaVisible())
   {
     return;
   }
 
   // Show the editor in the appropriate location
   if (this->UseNewMinMax(Perspective::Pointer(this)))
   {
     // If it's the currently maximized part we have to restore first
 //    if (this->GetPresentation().getMaximizedStack().Cast<EditorStack>() != 0)
 //    {
 //      getPresentation().getMaximizedStack().setState(IStackPresentationSite.STATE_RESTORED);
 //    }
 
     bool isMinimized = editorAreaState == IStackPresentationSite::STATE_MINIMIZED;
     if (!isMinimized)
       this->HideEditorAreaLocal();
     //else
     //  this->SetEditorAreaTrimVisibility(false);
   }
   else
   {
     this->HideEditorAreaLocal();
   }
 
   editorHidden = true;
 }
 
 void Perspective::HideEditorAreaLocal()
 {
   if (editorHolder != 0)
   {
     return;
   }
 
   // Replace the editor area with a placeholder so we
   // know where to put it back on show editor area request.
   editorHolder = new PartPlaceholder(editorArea->GetID());
   presentation->GetLayout()->Replace(editorArea, editorHolder);
 }
 
 bool Perspective::HideView(IViewReference::Pointer ref)
 {
   // If the view is locked just return.
   PartPane::Pointer pane = this->GetPane(ref);
 
   presentation->RemovePart(pane);
 
   // Dispose view if ref count == 0.
   this->GetViewFactory()->ReleaseView(ref);
   return true;
 }
 
 bool Perspective::IsEditorAreaVisible()
 {
   return !editorHidden;
 }
 
 ViewLayoutRec::Pointer Perspective::GetViewLayoutRec(IViewReference::Pointer ref, bool create)
 {
   ViewLayoutRec::Pointer result = this->GetViewLayoutRec(ViewFactory::GetKey(ref), create);
   if (result.IsNull() && create==false)
   {
     result = this->GetViewLayoutRec(ref->GetId(), false);
   }
   return result;
 }
 
 ViewLayoutRec::Pointer Perspective::GetViewLayoutRec(const QString& viewId, bool create)
 {
   ViewLayoutRec::Pointer rec = mapIDtoViewLayoutRec[viewId];
   if (rec.IsNull() && create)
   {
     rec = new ViewLayoutRec();
     mapIDtoViewLayoutRec[viewId] = rec;
   }
   return rec;
 }
 
 bool Perspective::IsFixedLayout()
 {
   //@issue is there a difference between a fixed
   //layout and a fixed perspective?? If not the API
   //may need some polish, WorkbenchPage, PageLayout
   //and Perspective all have isFixed methods.
   //PageLayout and Perspective have their own fixed
   //attribute, we are assuming they are always in sync.
   //WorkbenchPage delegates to the perspective.
   return fixed;
 }
 
 bool Perspective::IsStandaloneView(IViewReference::Pointer ref)
 {
   ViewLayoutRec::Pointer rec = this->GetViewLayoutRec(ref, false);
   return rec.IsNotNull() && rec->isStandalone;
 }
 
 bool Perspective::GetShowTitleView(IViewReference::Pointer ref)
 {
   ViewLayoutRec::Pointer rec = this->GetViewLayoutRec(ref, false);
   return rec.IsNotNull() && rec->showTitle;
 }
 
 void Perspective::LoadCustomPersp(PerspectiveDescriptor::Pointer persp)
 {
   //get the layout from the registry
   PerspectiveRegistry* perspRegistry = dynamic_cast<PerspectiveRegistry*>(WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry());
   try
   {
     IMemento::Pointer memento = perspRegistry->GetCustomPersp(persp->GetId());
     // Restore the layout state.
 //    MultiStatus status = new MultiStatus(
 //        PlatformUI.PLUGIN_ID,
 //        IStatus.OK,
 //        NLS.bind(WorkbenchMessages.Perspective_unableToRestorePerspective, persp.getLabel()),
 //        0);
 //    status.merge(restoreState(memento));
 //    status.merge(restoreState());
     bool okay = true;
     okay &= this->RestoreState(memento);
     okay &= this->RestoreState();
     if (!okay)
     {
       this->UnableToOpenPerspective(persp, "Unable to open perspective: " + persp->GetLabel());
     }
   }
   //catch (IOException e)
   //{
   //  unableToOpenPerspective(persp, 0);
   //}
   catch (const WorkbenchException& e)
   {
     this->UnableToOpenPerspective(persp, e.what());
   }
 }
 
 void Perspective::UnableToOpenPerspective(PerspectiveDescriptor::Pointer persp,
     const QString& status)
 {
   PerspectiveRegistry* perspRegistry = dynamic_cast<PerspectiveRegistry*>(WorkbenchPlugin
   ::GetDefault()->GetPerspectiveRegistry());
   perspRegistry->DeletePerspective(persp);
   // If this is a predefined perspective, we will not be able to delete
   // the perspective (we wouldn't want to).  But make sure to delete the
   // customized portion.
   persp->DeleteCustomDefinition();
   QString title = "Restoring problems";
   QString msg = "Unable to read workbench state.";
   if (status == "")
   {
     QMessageBox::critical(nullptr, title, msg);
   }
   else
   {
     //TODO error dialog
     //ErrorDialog.openError((Shell) 0, title, msg, status);
     QMessageBox::critical(nullptr, title, msg + "\n" + status);
   }
 }
 
 void Perspective::LoadPredefinedPersp(PerspectiveDescriptor::Pointer persp)
 {
   // Create layout engine.
   IPerspectiveFactory::Pointer factory;
   try
   {
     factory = persp->CreateFactory();
   }
   catch (CoreException& /*e*/)
   {
     throw WorkbenchException("Unable to load perspective: " + persp->GetId());
   }
 
   /*
    * IPerspectiveFactory#createFactory() can return 0
    */
   if (factory == 0)
   {
     throw WorkbenchException("Unable to load perspective: " + persp->GetId());
   }
 
   // Create layout factory.
   ViewSashContainer::Pointer container(new ViewSashContainer(page, this->GetClientComposite()));
   layout = new PageLayout(container, this->GetViewFactory(),
       editorArea, descriptor);
   layout->SetFixed(descriptor->GetFixed());
 
 //  // add the placeholders for the sticky folders and their contents
   IPlaceholderFolderLayout::Pointer stickyFolderRight, stickyFolderLeft, stickyFolderTop, stickyFolderBottom;
 
   QList<IStickyViewDescriptor::Pointer> descs(WorkbenchPlugin::GetDefault()
   ->GetViewRegistry()->GetStickyViews());
   for (int i = 0; i < descs.size(); i++)
   {
     IStickyViewDescriptor::Pointer stickyViewDescriptor = descs[i];
     QString id = stickyViewDescriptor->GetId();
     int location = stickyViewDescriptor->GetLocation();
     if (location == IPageLayout::RIGHT)
     {
       if (stickyFolderRight == 0)
       {
         stickyFolderRight = layout
         ->CreatePlaceholderFolder(
             StickyViewDescriptor::STICKY_FOLDER_RIGHT,
             IPageLayout::RIGHT, .75f,
             IPageLayout::ID_EDITOR_AREA);
       }
       stickyFolderRight->AddPlaceholder(id);
     }
     else if (location == IPageLayout::LEFT)
     {
       if (stickyFolderLeft == 0)
       {
         stickyFolderLeft = layout->CreatePlaceholderFolder(
             StickyViewDescriptor::STICKY_FOLDER_LEFT,
             IPageLayout::LEFT, .25f, IPageLayout::ID_EDITOR_AREA);
       }
       stickyFolderLeft->AddPlaceholder(id);
     }
     else if (location == IPageLayout::TOP)
     {
       if (stickyFolderTop == 0)
       {
         stickyFolderTop = layout->CreatePlaceholderFolder(
             StickyViewDescriptor::STICKY_FOLDER_TOP,
             IPageLayout::TOP, .25f, IPageLayout::ID_EDITOR_AREA);
       }
       stickyFolderTop->AddPlaceholder(id);
     }
     else if (location == IPageLayout::BOTTOM)
     {
       if (stickyFolderBottom == 0)
       {
         stickyFolderBottom = layout->CreatePlaceholderFolder(
             StickyViewDescriptor::STICKY_FOLDER_BOTTOM,
             IPageLayout::BOTTOM, .75f,
             IPageLayout::ID_EDITOR_AREA);
       }
       stickyFolderBottom->AddPlaceholder(id);
     }
 
     //should never be 0 as we've just added the view above
     IViewLayout::Pointer viewLayout = layout->GetViewLayout(id);
     viewLayout->SetCloseable(stickyViewDescriptor->IsCloseable());
     viewLayout->SetMoveable(stickyViewDescriptor->IsMoveable());
   }
 
   // Run layout engine.
   factory->CreateInitialLayout(layout);
   PerspectiveExtensionReader extender;
   extender.ExtendLayout(page->GetExtensionTracker(), descriptor->GetId(), layout);
 
   // Retrieve view layout info stored in the page layout.
   QHash<QString, ViewLayoutRec::Pointer> layoutInfo = layout->GetIDtoViewLayoutRecMap();
-  mapIDtoViewLayoutRec.unite(layoutInfo);
+  mapIDtoViewLayoutRec.insert(layoutInfo);
 
   //TODO Perspective action sets
   // Create action sets.
   //List temp = new ArrayList();
   //this->CreateInitialActionSets(temp, layout.getActionSets());
 
 //  IContextService* service = 0;
 //  if (page != 0)
 //  {
 //    service = page->GetWorkbenchWindow()->GetService<IContextService>();
 //  }
 //  try
 //  {
 //    if (service != 0)
 //    {
 //      service->DeferUpdates(true);
 //    }
 //    for (Iterator iter = temp.iterator(); iter.hasNext();)
 //    {
 //      IActionSetDescriptor descriptor = (IActionSetDescriptor) iter
 //      .next();
 //      addAlwaysOn(descriptor);
 //    }
 //  }finally
 //  {
 //    if (service!=0)
 //    {
 //      service.activateContext(ContextAuthority.SEND_EVENTS);
 //    }
 //  }
 
 //  newWizardShortcuts = layout.getNewWizardShortcuts();
     showViewShortcuts = layout->GetShowViewShortcuts();
     perspectiveShortcuts = layout->GetPerspectiveShortcuts();
     showInPartIds = layout->GetShowInPartIds();
 
 //  // Retrieve fast views
 //  if (fastViewManager != 0)
 //  {
 //    ArrayList fastViews = layout.getFastViews();
 //    for (Iterator fvIter = fastViews.iterator(); fvIter.hasNext();)
 //    {
 //      IViewReference ref = (IViewReference) fvIter.next();
 //      fastViewManager.addViewReference(FastViewBar.FASTVIEWBAR_ID, -1, ref,
 //          !fvIter.hasNext());
 //    }
 //  }
 
   // Is the layout fixed
   fixed = layout->IsFixed();
   showViewShortcuts = layout->GetShowViewShortcuts();
 
   // Create presentation.
   presentation = new PerspectiveHelper(page, container, this);
 
   // Hide editor area if requested by factory
   if (!layout->IsEditorAreaVisible())
   {
     this->HideEditorArea();
   }
 
 }
 
 void Perspective::OnActivate()
 {
   // Update editor area state.
   if (editorArea->GetControl() != nullptr)
   {
     bool visible = this->IsEditorAreaVisible();
     bool inTrim = editorAreaState == IStackPresentationSite::STATE_MINIMIZED;
 
     editorArea->SetVisible(visible && !inTrim);
   }
 
 //  // Update fast views.
 //  // Make sure the control for the fastviews are created so they can
 //  // be activated.
 //  if (fastViewManager != 0)
 //  {
 //    List fastViews = fastViewManager.getFastViews(0);
 //    for (int i = 0; i < fastViews.size(); i++)
 //    {
 //      ViewPane pane = getPane((IViewReference) fastViews.get(i));
 //      if (pane != 0)
 //      {
 //        Control ctrl = pane.getControl();
 //        if (ctrl == 0)
 //        {
 //          pane.createControl(getClientComposite());
 //          ctrl = pane.getControl();
 //        }
 //        ctrl.setEnabled(false); // Remove focus support.
 //      }
 //    }
 //  }
 
 //  // Set the visibility of all fast view pins
 //  setAllPinsVisible(true);
 
   // Trim Stack Support
   bool useNewMinMax = Perspective::UseNewMinMax(Perspective::Pointer(this));
   bool hideEditorArea = shouldHideEditorsOnActivate || (editorHidden && editorHolder == 0);
 
   // We have to set the editor area's stack state -before-
   // activating the presentation since it's used there to determine
   // size of the resulting stack
   if (useNewMinMax && !hideEditorArea)
   {
     this->RefreshEditorAreaVisibility();
   }
 
   // Show the layout
   presentation->Activate(this->GetClientComposite());
 
 //  if (useNewMinMax)
 //  {
 //    fastViewManager.activate();
 //
 //    // Move any minimized extension stacks to the trim
 //    if (layout != 0)
 //    {
 //      // Turn aimations off
 //      IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
 //      bool useAnimations = preferenceStore
 //      .getbool(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS);
 //      preferenceStore.setValue(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS, false);
 //
 //      List minStacks = layout.getMinimizedStacks();
 //      for (Iterator msIter = minStacks.iterator(); msIter.hasNext();)
 //      {
 //        ViewStack vs = (ViewStack) msIter.next();
 //        vs.setMinimized(true);
 //      }
 //
 //      // Restore the animation pref
 //      preferenceStore.setValue(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS, useAnimations);
 //
 //      // this is a one-off deal...set during the extension reading
 //      minStacks.clear();
 //      layout = 0;
 //    }
 //  }
 //  else
 //  {
 //    // Update the FVB only if not using the new min/max
 //
 //    //    WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
 ////    if (wbw != 0)
 ////    {
 ////      ITrimManager tbm = wbw.getTrimManager();
 ////      if (tbm != 0)
 ////      {
 ////        IWindowTrim fvb = tbm.getTrim(FastViewBar.FASTVIEWBAR_ID);
 ////        if (fvb instanceof FastViewBar)
 ////        {
 ////          ((FastViewBar)fvb).update(true);
 ////        }
 ////      }
 ////    }
 //  }
 
 //  // If we are -not- using the new min/max then ensure that there
 //  // are no stacks in the trim. This can happen when a user switches
 //  // back to the 3.0 presentation...
 //  if (!Perspective.useNewMinMax(this) && fastViewManager != 0)
 //  {
 //    bool stacksWereRestored = fastViewManager.restoreAllTrimStacks();
 //    setEditorAreaTrimVisibility(false);
 //
 //    // Restore any 'maximized' view stack since we've restored
 //    // the minimized stacks
 //    if (stacksWereRestored && presentation.getMaximizedStack().Cast<ViewStack>() != 0)
 //    {
 //      ViewStack vs = (ViewStack) presentation.getMaximizedStack();
 //      vs.setPresentationState(IStackPresentationSite.STATE_RESTORED);
 //      presentation.setMaximizedStack(0);
 //    }
 //  }
 
   // We hide the editor area -after- the presentation activates
   if (hideEditorArea)
   {
     // We do this here to ensure that createPartControl is called on the
     // top editor
     // before it is hidden. See bug 20166.
     this->HideEditorArea();
     shouldHideEditorsOnActivate = false;
 
 //    // this is an override so it should handle both states
 //    if (useNewMinMax)
 //    setEditorAreaTrimVisibility(editorAreaState == IStackPresentationSite.STATE_MINIMIZED);
   }
 
   // Fix perspectives whose contributing bundle has gone away
   FixOrphan();
 }
 
 void Perspective::FixOrphan()
 {
   PerspectiveRegistry* reg = static_cast<PerspectiveRegistry*>(PlatformUI::GetWorkbench()->GetPerspectiveRegistry());
   IPerspectiveDescriptor::Pointer regDesc = reg->FindPerspectiveWithId(descriptor->GetId());
   if (regDesc.IsNull())
   {
     QString msg = "Perspective " + descriptor->GetLabel() + " has been made into a local copy";
     IStatus::Pointer status = StatusUtil::NewStatus(IStatus::WARNING_TYPE, msg, BERRY_STATUS_LOC);
     //StatusManager.getManager().handle(status, StatusManager.LOG);
     WorkbenchPlugin::Log(status);
 
     QString localCopyLabel("<%1>");
     QString newDescId = localCopyLabel.arg(descriptor->GetLabel());
     while (reg->FindPerspectiveWithId(newDescId).IsNotNull())
     {
       newDescId = localCopyLabel.arg(newDescId);
     }
     IPerspectiveDescriptor::Pointer newDesc = reg->CreatePerspective(newDescId, descriptor);
     page->SavePerspectiveAs(newDesc);
   }
 }
 
 void Perspective::OnDeactivate()
 {
   presentation->Deactivate();
   //setActiveFastView(0);
   //setAllPinsVisible(false);
 
 //  // Update fast views.
 //  if (fastViewManager != 0)
 //  {
 //    List fastViews = fastViewManager.getFastViews(0);
 //    for (int i = 0; i < fastViews.size(); i++)
 //    {
 //      ViewPane pane = getPane((IViewReference) fastViews.get(i));
 //      if (pane != 0)
 //      {
 //        Control ctrl = pane.getControl();
 //        if (ctrl != 0)
 //        {
 //          ctrl.setEnabled(true); // Add focus support.
 //        }
 //      }
 //    }
 //
 //    fastViewManager.deActivate();
 //  }
 //
 //  // Ensure that the editor area trim is hidden as well
 //  setEditorAreaTrimVisibility(false);
 }
 
 void Perspective::PartActivated(IWorkbenchPart::Pointer  /*activePart*/)
 {
 //  // If a fastview is open close it.
 //  if (activeFastView != 0
 //      && activeFastView.getPart(false) != activePart)
 //  {
 //    setActiveFastView(0);
 //  }
 }
 
 void Perspective::PerformedShowIn(const QString&  /*partId*/)
 {
   //showInTimes.insert(std::make_pair(partId, new Long(System.currentTimeMillis())));
 }
 
 bool Perspective::RestoreState(IMemento::Pointer memento)
 {
 
 //  MultiStatus result = new MultiStatus(
 //      PlatformUI.PLUGIN_ID,
 //      IStatus.OK,
 //      WorkbenchMessages.Perspective_problemsRestoringPerspective, 0);
   bool result = true;
 
   // Create persp descriptor.
   descriptor = new PerspectiveDescriptor("", "", PerspectiveDescriptor::Pointer(nullptr));
   //result.add(descriptor.restoreState(memento));
   result &= descriptor->RestoreState(memento);
   PerspectiveDescriptor::Pointer desc = WorkbenchPlugin::GetDefault()->
       GetPerspectiveRegistry()->FindPerspectiveWithId(descriptor->GetId()).Cast<PerspectiveDescriptor>();
   if (desc)
   {
     descriptor = desc;
   }
 
   this->memento = memento;
   // Add the visible views.
   QList<IMemento::Pointer> views(memento->GetChildren(WorkbenchConstants::TAG_VIEW));
   //result.merge(createReferences(views));
   result &= this->CreateReferences(views);
 
   memento = memento->GetChild(WorkbenchConstants::TAG_FAST_VIEWS);
   if (memento)
   {
     views = memento->GetChildren(WorkbenchConstants::TAG_VIEW);
     //result.merge(createReferences(views));
     result &= this->CreateReferences(views);
   }
   return result;
 }
 
 bool Perspective::CreateReferences(const QList<IMemento::Pointer>& views)
 {
 //  MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK,
 //      WorkbenchMessages.Perspective_problemsRestoringViews, 0);
   bool result = true;
 
   for (int x = 0; x < views.size(); x++)
   {
     // Get the view details.
     IMemento::Pointer childMem = views[x];
     QString id; childMem->GetString(WorkbenchConstants::TAG_ID, id);
     // skip creation of the intro reference -  it's handled elsewhere.
     if (id == IntroConstants::INTRO_VIEW_ID)
     {
       continue;
     }
 
     QString secondaryId(ViewFactory::ExtractSecondaryId(id));
     if (!secondaryId.isEmpty())
     {
       id = ViewFactory::ExtractPrimaryId(id);
     }
     // Create and open the view.
     try
     {
       QString rm; childMem->GetString(WorkbenchConstants::TAG_REMOVED, rm);
       if (rm != "true")
       {
         viewFactory->CreateView(id, secondaryId);
       }
     }
     catch (const PartInitException& e)
     {
       childMem->PutString(WorkbenchConstants::TAG_REMOVED, "true");
 //      result.add(StatusUtil.newStatus(IStatus.ERR,
 //              e.getMessage() == 0 ? "" : e.getMessage(), //$NON-NLS-1$
 //              e));
       WorkbenchPlugin::Log(e.what(), e);
       result &= true;
     }
   }
   return result;
 }
 
 bool Perspective::RestoreState()
 {
   if (this->memento == 0)
   {
     //return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, 0, "", 0); //$NON-NLS-1$
     return true;
   }
 
 //  MultiStatus result = new MultiStatus(
 //      PlatformUI.PLUGIN_ID,
 //      IStatus.OK,
 //      WorkbenchMessages.Perspective_problemsRestoringPerspective, 0);
 
   IMemento::Pointer memento = this->memento;
   this->memento = nullptr;
 
   const IMemento::Pointer boundsMem(memento->GetChild(WorkbenchConstants::TAG_WINDOW));
   if (boundsMem)
   {
     int x, y, w, h;
     boundsMem->GetInteger(WorkbenchConstants::TAG_X, x);
     boundsMem->GetInteger(WorkbenchConstants::TAG_Y, y);
     boundsMem->GetInteger(WorkbenchConstants::TAG_HEIGHT, h);
     boundsMem->GetInteger(WorkbenchConstants::TAG_WIDTH, w);
     QRect r(x, y, w, h);
     //StartupThreading.runWithoutExceptions(new StartupRunnable()
     //    {
 
     //      void runWithException() throws Throwable
     //      {
             if (page->GetWorkbenchWindow()->GetActivePage() == 0)
             {
               page->GetWorkbenchWindow()->GetShell()->SetBounds(r);
             }
     //      }
     //    });
 
   }
 
   // Create an empty presentation..
   PerspectiveHelper* pres;
   //StartupThreading.runWithoutExceptions(new StartupRunnable()
   //    {
 
   //      void runWithException() throws Throwable
   //      {
           ViewSashContainer::Pointer mainLayout(new ViewSashContainer(page, this->GetClientComposite()));
           pres = new PerspectiveHelper(page, mainLayout, this);
   //      }});
 
 
   // Read the layout.
 //  result.merge(pres.restoreState(memento
 //          .getChild(IWorkbenchConstants.TAG_LAYOUT)));
           pres->RestoreState(memento->GetChild(WorkbenchConstants::TAG_LAYOUT));
   //StartupThreading.runWithoutExceptions(new StartupRunnable()
   //    {
 
   //      void runWithException() throws Throwable
   //      {
           // Add the editor workbook. Do not hide it now.
           pres->ReplacePlaceholderWithPart(editorArea);
   //      }});
 
   // Add the visible views.
   QList<IMemento::Pointer> views(memento->GetChildren(WorkbenchConstants::TAG_VIEW));
 
   for (int x = 0; x < views.size(); x++)
   {
     // Get the view details.
     IMemento::Pointer childMem = views[x];
     QString id; childMem->GetString(WorkbenchConstants::TAG_ID, id);
     QString secondaryId(ViewFactory::ExtractSecondaryId(id));
     if (!secondaryId.isEmpty())
     {
       id = ViewFactory::ExtractPrimaryId(id);
     }
 
     // skip the intro as it is restored higher up in workbench.
     if (id == IntroConstants::INTRO_VIEW_ID)
     {
       continue;
     }
 
     // Create and open the view.
     IViewReference::Pointer viewRef = viewFactory->GetView(id, secondaryId);
     WorkbenchPartReference::Pointer ref = viewRef.Cast<WorkbenchPartReference>();
 
     // report error
     if (ref == 0)
     {
       QString key = ViewFactory::GetKey(id, secondaryId);
 //      result.add(new Status(IStatus.ERR, PlatformUI.PLUGIN_ID, 0,
 //              NLS.bind(WorkbenchMessages.Perspective_couldNotFind, key ), 0));
       WorkbenchPlugin::Log("Could not find view: " + key);
       continue;
     }
     bool willPartBeVisible = pres->WillPartBeVisible(ref->GetId(), secondaryId);
     if (willPartBeVisible)
     {
       IViewPart::Pointer view = ref->GetPart(true).Cast<IViewPart>();
       if (view)
       {
         ViewSite::Pointer site = view->GetSite().Cast<ViewSite>();
         pres->ReplacePlaceholderWithPart(site->GetPane().Cast<LayoutPart>());
       }
     }
     else
     {
       pres->ReplacePlaceholderWithPart(ref->GetPane());
     }
   }
 
 //  // Load the fast views
 //  if (fastViewManager != 0)
 //  fastViewManager.restoreState(memento, result);
 
   // Load the view layout recs
   QList<IMemento::Pointer> recMementos(memento
   ->GetChildren(WorkbenchConstants::TAG_VIEW_LAYOUT_REC));
   for (int i = 0; i < recMementos.size(); i++)
   {
     IMemento::Pointer recMemento = recMementos[i];
     QString compoundId;
     if (recMemento->GetString(WorkbenchConstants::TAG_ID, compoundId))
     {
       ViewLayoutRec::Pointer rec = GetViewLayoutRec(compoundId, true);
       QString closeablestr; recMemento->GetString(WorkbenchConstants::TAG_CLOSEABLE, closeablestr);
       if (WorkbenchConstants::FALSE_VAL == closeablestr)
       {
         rec->isCloseable = false;
       }
       QString moveablestr; recMemento->GetString(WorkbenchConstants::TAG_MOVEABLE, moveablestr);
       if (WorkbenchConstants::FALSE_VAL == moveablestr)
       {
         rec->isMoveable = false;
       }
       QString standalonestr; recMemento->GetString(WorkbenchConstants::TAG_STANDALONE, standalonestr);
       if (WorkbenchConstants::TRUE_VAL == standalonestr)
       {
         rec->isStandalone = true;
         QString showstr; recMemento->GetString(WorkbenchConstants::TAG_SHOW_TITLE, showstr);
         rec->showTitle = WorkbenchConstants::FALSE_VAL != showstr;
       }
     }
   }
 
   //final IContextService service = (IContextService)page.getWorkbenchWindow().getService(IContextService.class);
   try
   { // one big try block, don't kill me here
 //    // defer context events
 //    if (service != 0)
 //    {
 //      service.activateContext(ContextAuthority.DEFER_EVENTS);
 //    }
 //
 //    HashSet knownActionSetIds = new HashSet();
 //
 //    // Load the always on action sets.
     QList<IMemento::Pointer> actions; // = memento
 //    .getChildren(IWorkbenchConstants.TAG_ALWAYS_ON_ACTION_SET);
 //    for (int x = 0; x < actions.length; x++)
 //    {
 //      String actionSetID = actions[x]
 //      .getString(IWorkbenchConstants.TAG_ID);
 //      final IActionSetDescriptor d = WorkbenchPlugin.getDefault()
 //      .getActionSetRegistry().findActionSet(actionSetID);
 //      if (d != 0)
 //      {
 //        StartupThreading
 //        .runWithoutExceptions(new StartupRunnable()
 //            {
 //              void runWithException() throws Throwable
 //              {
 //                addAlwaysOn(d);
 //              }
 //            });
 //
 //        knownActionSetIds.add(actionSetID);
 //      }
 //    }
 //
 //    // Load the always off action sets.
 //    actions = memento
 //    .getChildren(IWorkbenchConstants.TAG_ALWAYS_OFF_ACTION_SET);
 //    for (int x = 0; x < actions.length; x++)
 //    {
 //      String actionSetID = actions[x]
 //      .getString(IWorkbenchConstants.TAG_ID);
 //      final IActionSetDescriptor d = WorkbenchPlugin.getDefault()
 //      .getActionSetRegistry().findActionSet(actionSetID);
 //      if (d != 0)
 //      {
 //        StartupThreading
 //        .runWithoutExceptions(new StartupRunnable()
 //            {
 //              void runWithException() throws Throwable
 //              {
 //                addAlwaysOff(d);
 //              }
 //            });
 //        knownActionSetIds.add(actionSetID);
 //      }
 //    }
 
     // Load "show view actions".
     actions = memento->GetChildren(WorkbenchConstants::TAG_SHOW_VIEW_ACTION);
     for (int x = 0; x < actions.size(); x++)
     {
       QString id; actions[x]->GetString(WorkbenchConstants::TAG_ID, id);
       showViewShortcuts.push_back(id);
     }
 
 //    // Load "show in times".
 //    actions = memento.getChildren(IWorkbenchConstants.TAG_SHOW_IN_TIME);
 //    for (int x = 0; x < actions.length; x++)
 //    {
 //      String id = actions[x].getString(IWorkbenchConstants.TAG_ID);
 //      String timeStr = actions[x]
 //      .getString(IWorkbenchConstants.TAG_TIME);
 //      if (id != 0 && timeStr != 0)
 //      {
 //        try
 //        {
 //          long time = Long.parseLong(timeStr);
 //          showInTimes.put(id, new Long(time));
 //        }
 //        catch (NumberFormatException e)
 //        {
 //          // skip this one
 //        }
 //      }
 //    }
 
     // Load "show in parts" from registry, not memento
     showInPartIds = this->GetShowInIdsFromRegistry();
 
 //    // Load "new wizard actions".
 //    actions = memento
 //    .getChildren(IWorkbenchConstants.TAG_NEW_WIZARD_ACTION);
 //    newWizardShortcuts = new ArrayList(actions.length);
 //    for (int x = 0; x < actions.length; x++)
 //    {
 //      String id = actions[x].getString(IWorkbenchConstants.TAG_ID);
 //      newWizardShortcuts.add(id);
 //    }
 
     // Load "perspective actions".
     actions = memento->GetChildren(WorkbenchConstants::TAG_PERSPECTIVE_ACTION);
     for (int x = 0; x < actions.size(); x++)
     {
       QString id; actions[x]->GetString(WorkbenchConstants::TAG_ID, id);
       perspectiveShortcuts.push_back(id);
     }
 
 //    ArrayList extActionSets = getPerspectiveExtensionActionSets();
 //    for (int i = 0; i < extActionSets.size(); i++)
 //    {
 //      String actionSetID = (String) extActionSets.get(i);
 //      if (knownActionSetIds.contains(actionSetID))
 //      {
 //        continue;
 //      }
 //      final IActionSetDescriptor d = WorkbenchPlugin.getDefault()
 //      .getActionSetRegistry().findActionSet(actionSetID);
 //      if (d != 0)
 //      {
 //        StartupThreading
 //        .runWithoutExceptions(new StartupRunnable()
 //            {
 //              void runWithException() throws Throwable
 //              {
 //                addAlwaysOn(d);
 //              }
 //            });
 //        knownActionSetIds.add(d.getId());
 //      }
 //    }
 
 //    // Add the visible set of action sets to our knownActionSetIds
 //    // Now go through the registry to ensure we pick up any new action
 //    // sets
 //    // that have been added but not yet considered by this perspective.
 //    ActionSetRegistry reg = WorkbenchPlugin.getDefault()
 //    .getActionSetRegistry();
 //    IActionSetDescriptor[] array = reg.getActionSets();
 //    int count = array.length;
 //    for (int i = 0; i < count; i++)
 //    {
 //      IActionSetDescriptor desc = array[i];
 //      if ((!knownActionSetIds.contains(desc.getId()))
 //          && (desc.isInitiallyVisible()))
 //      {
 //        addActionSet(desc);
 //      }
 //    }
   }
   catch (...)
   {
 //    // restart context changes
 //    if (service != 0)
 //    {
 //      StartupThreading.runWithoutExceptions(new StartupRunnable()
 //          {
 //            void runWithException() throws Throwable
 //            {
 //              service.activateContext(ContextAuthority.SEND_EVENTS);
 //            }
 //          });
 //    }
   }
 
   // Save presentation.
   presentation = pres;
 
   // Hide the editor area if needed. Need to wait for the
   // presentation to be fully setup first.
   int areaVisible = 0;
   bool areaVisibleExists = memento->GetInteger(WorkbenchConstants::TAG_AREA_VISIBLE, areaVisible);
   // Rather than hiding the editors now we must wait until after their
   // controls
   // are created. This ensures that if an editor is instantiated,
   // createPartControl
   // is also called. See bug 20166.
   shouldHideEditorsOnActivate = (areaVisibleExists && areaVisible == 0);
 
 //  // Restore the trim state of the editor area
 //  IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
 //  bool useNewMinMax = preferenceStore.getbool(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
 //  if (useNewMinMax)
 //  {
 //    Integer trimStateInt = memento.getInteger(IWorkbenchConstants.TAG_AREA_TRIM_STATE);
 //    if (trimStateInt != 0)
 //    {
 //      editorAreaState = trimStateInt.intValue() & 0x3; // low order two bits contain the state
 //      editorAreaRestoreOnUnzoom = (trimStateInt.intValue() & 4) != 0;
 //    }
 //  }
 
   // restore the fixed state
   int isFixed = 0;
   fixed = (memento->GetInteger(WorkbenchConstants::TAG_FIXED, isFixed) && isFixed == 1);
 
   return true;
 }
 
 QList<QString> Perspective::GetShowInIdsFromRegistry()
 {
   PerspectiveExtensionReader reader;
   QList<QString> tags;
   tags.push_back(WorkbenchRegistryConstants::TAG_SHOW_IN_PART);
   reader.SetIncludeOnlyTags(tags);
   PageLayout::Pointer layout(new PageLayout());
   reader.ExtendLayout(nullptr, descriptor->GetOriginalId(), layout);
   return layout->GetShowInPartIds();
 }
 
 void Perspective::SaveDesc()
 {
   this->SaveDescAs(descriptor);
 }
 
 void Perspective::SaveDescAs(IPerspectiveDescriptor::Pointer desc)
 {
   PerspectiveDescriptor::Pointer realDesc = desc.Cast<PerspectiveDescriptor>();
   //get the layout from the registry
   PerspectiveRegistry* perspRegistry = dynamic_cast<PerspectiveRegistry*>(
                                          WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry());
   // Capture the layout state.
   XMLMemento::Pointer memento = XMLMemento::CreateWriteRoot("perspective");
   //IStatus::Pointer status = SaveState(memento, realDesc, false);
 //  if (status->GetSeverity() == IStatus::ERROR_TYPE)
 //  {
 //    ErrorDialog.openError((Shell) 0, "Saving Problems",
 //        "Unable to store layout state.",
 //        status);
 //    return;
 //  }
   bool status = SaveState(memento, realDesc, false);
   if (!status)
   {
     QMessageBox::critical(nullptr, "Saving Problems", "Unable to store layout state.");
     return;
   }
 
   //save it to the preference store
   try
   {
     perspRegistry->SaveCustomPersp(realDesc, memento.GetPointer());
     descriptor = realDesc;
   }
   catch (const std::exception& /*e*/)
   {
     perspRegistry->DeletePerspective(realDesc);
     QMessageBox::critical(nullptr, "Saving Problems", "Unable to store layout state.");
   }
 }
 
 bool Perspective::SaveState(IMemento::Pointer memento)
 {
 //  MultiStatus::Pointer result(new MultiStatus(
 //                                PlatformUI::PLUGIN_ID(),
 //                                IStatus::OK_TYPE,
 //                                "Problems occurred saving perspective.",
 //                                BERRY_STATUS_LOC));
 //  result->Merge(SaveState(memento, descriptor, true));
 
   bool result = true;
   result &= this->SaveState(memento, descriptor, true);
 
   return result;
 }
 
 bool Perspective::SaveState(IMemento::Pointer memento, PerspectiveDescriptor::Pointer p,
     bool saveInnerViewState)
 {
 
 //  MultiStatus::Pointer result(new MultiStatus(
 //                                PlatformUI::PLUGIN_ID(),
 //                                IStatus::OK_TYPE,
 //                                "Problems occurred saving perspective.",
 //                                BERRY_STATUS_LOC));
   bool result = true;
 
   if (this->memento)
   {
     memento->PutMemento(this->memento);
     return result;
   }
 
   // Save the version number.
   memento->PutString(WorkbenchConstants::TAG_VERSION, VERSION_STRING);
   //result.add(p.saveState(memento));
   result &= p->SaveState(memento);
   if (!saveInnerViewState)
   {
     QRect bounds(page->GetWorkbenchWindow()->GetShell()->GetBounds());
     IMemento::Pointer boundsMem = memento
     ->CreateChild(WorkbenchConstants::TAG_WINDOW);
     boundsMem->PutInteger(WorkbenchConstants::TAG_X, bounds.x());
     boundsMem->PutInteger(WorkbenchConstants::TAG_Y, bounds.y());
     boundsMem->PutInteger(WorkbenchConstants::TAG_HEIGHT, bounds.height());
     boundsMem->PutInteger(WorkbenchConstants::TAG_WIDTH, bounds.width());
   }
 
 //  // Save the "always on" action sets.
 //  Iterator itr = alwaysOnActionSets.iterator();
 //  while (itr.hasNext())
 //  {
 //    IActionSetDescriptor desc = (IActionSetDescriptor) itr.next();
 //    IMemento child = memento
 //    .createChild(IWorkbenchConstants.TAG_ALWAYS_ON_ACTION_SET);
 //    child.putString(IWorkbenchConstants.TAG_ID, desc.getId());
 //  }
 
 //  // Save the "always off" action sets.
 //  itr = alwaysOffActionSets.iterator();
 //  while (itr.hasNext())
 //  {
 //    IActionSetDescriptor desc = (IActionSetDescriptor) itr.next();
 //    IMemento child = memento
 //    .createChild(IWorkbenchConstants.TAG_ALWAYS_OFF_ACTION_SET);
 //    child.putString(IWorkbenchConstants.TAG_ID, desc.getId());
 //  }
 
   // Save "show view actions"
   for (QList<QString>::iterator itr = showViewShortcuts.begin();
       itr != showViewShortcuts.end(); ++itr)
   {
     IMemento::Pointer child = memento
     ->CreateChild(WorkbenchConstants::TAG_SHOW_VIEW_ACTION);
     child->PutString(WorkbenchConstants::TAG_ID, *itr);
   }
 
 //  // Save "show in times"
 //  itr = showInTimes.keySet().iterator();
 //  while (itr.hasNext())
 //  {
 //    String id = (String) itr.next();
 //    Long time = (Long) showInTimes.get(id);
 //    IMemento child = memento
 //    .createChild(IWorkbenchConstants.TAG_SHOW_IN_TIME);
 //    child.putString(IWorkbenchConstants.TAG_ID, id);
 //    child.putString(IWorkbenchConstants.TAG_TIME, time.toString());
 //  }
 
 //  // Save "new wizard actions".
 //  itr = newWizardShortcuts.iterator();
 //  while (itr.hasNext())
 //  {
 //    String str = (String) itr.next();
 //    IMemento child = memento
 //    .createChild(IWorkbenchConstants.TAG_NEW_WIZARD_ACTION);
 //    child.putString(IWorkbenchConstants.TAG_ID, str);
 //  }
 
   // Save "perspective actions".
   for (QList<QString>::iterator itr = perspectiveShortcuts.begin();
       itr != perspectiveShortcuts.end(); ++itr)
   {
     IMemento::Pointer child = memento
     ->CreateChild(WorkbenchConstants::TAG_PERSPECTIVE_ACTION);
     child->PutString(WorkbenchConstants::TAG_ID, *itr);
   }
 
   // Get visible views.
   QList<PartPane::Pointer> viewPanes;
   presentation->CollectViewPanes(viewPanes);
 
   // Save the views.
   for (QList<PartPane::Pointer>::iterator itr = viewPanes.begin();
       itr != viewPanes.end(); ++itr)
   {
     IWorkbenchPartReference::Pointer ref((*itr)->GetPartReference());
     IViewDescriptor::Pointer desc = page->GetViewFactory()->GetViewRegistry()
           ->Find(ref->GetId());
     if(desc && desc->IsRestorable())
     {
       IMemento::Pointer viewMemento = memento
       ->CreateChild(WorkbenchConstants::TAG_VIEW);
       viewMemento->PutString(WorkbenchConstants::TAG_ID, ViewFactory::GetKey(ref.Cast<IViewReference>()));
     }
   }
 
 //  // save all fastview state
 //  if (fastViewManager != 0)
 //  fastViewManager.saveState(memento);
 
   // Save the view layout recs.
   for (QHash<QString, ViewLayoutRec::Pointer>::iterator i = mapIDtoViewLayoutRec.begin();
       i != mapIDtoViewLayoutRec.end(); ++i)
   {
     QString compoundId(i.key());
     ViewLayoutRec::Pointer rec(i.value());
     if (rec && (!rec->isCloseable || !rec->isMoveable || rec->isStandalone))
     {
       IMemento::Pointer layoutMemento(memento
       ->CreateChild(WorkbenchConstants::TAG_VIEW_LAYOUT_REC));
       layoutMemento->PutString(WorkbenchConstants::TAG_ID, compoundId);
       if (!rec->isCloseable)
       {
         layoutMemento->PutString(WorkbenchConstants::TAG_CLOSEABLE,
             WorkbenchConstants::FALSE_VAL);
       }
       if (!rec->isMoveable)
       {
         layoutMemento->PutString(WorkbenchConstants::TAG_MOVEABLE,
             WorkbenchConstants::FALSE_VAL);
       }
       if (rec->isStandalone)
       {
         layoutMemento->PutString(WorkbenchConstants::TAG_STANDALONE,
             WorkbenchConstants::TRUE_VAL);
         layoutMemento->PutString(WorkbenchConstants::TAG_SHOW_TITLE,
             rec->showTitle ? WorkbenchConstants::TRUE_VAL : WorkbenchConstants::FALSE_VAL);
       }
     }
   }
 
   // Save the layout.
   IMemento::Pointer childMem(memento->CreateChild(WorkbenchConstants::TAG_LAYOUT));
   //result->Add(presentation->SaveState(childMem));
   result &= presentation->SaveState(childMem);
 
   // Save the editor visibility state
   if (this->IsEditorAreaVisible())
   {
     memento->PutInteger(WorkbenchConstants::TAG_AREA_VISIBLE, 1);
   }
   else
   {
     memento->PutInteger(WorkbenchConstants::TAG_AREA_VISIBLE, 0);
   }
 
 //  // Save the trim state of the editor area if using the new min/max
 //  IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
 //  bool useNewMinMax = preferenceStore.getbool(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
 //  if (useNewMinMax)
 //  {
 //    int trimState = editorAreaState;
 //    trimState |= editorAreaRestoreOnUnzoom ? 4 : 0;
 //    memento.putInteger(IWorkbenchConstants.TAG_AREA_TRIM_STATE, trimState);
 //  }
 
   // Save the fixed state
   if (fixed)
   {
     memento->PutInteger(WorkbenchConstants::TAG_FIXED, 1);
   }
   else
   {
     memento->PutInteger(WorkbenchConstants::TAG_FIXED, 0);
   }
 
   return result;
 }
 
 void Perspective::SetPerspectiveActionIds(const QList<QString>& list)
 {
   perspectiveShortcuts = list;
 }
 
 void Perspective::SetShowInPartIds(const QList<QString>& list)
 {
   showInPartIds = list;
 }
 
 void Perspective::SetShowViewActionIds(const QList<QString>& list)
 {
   showViewShortcuts = list;
 }
 
 void Perspective::ShowEditorArea()
 {
   if (this->IsEditorAreaVisible())
   {
     return;
   }
 
   editorHidden = false;
 
   // Show the editor in the appropriate location
   if (this->UseNewMinMax(Perspective::Pointer(this)))
   {
     bool isMinimized = editorAreaState == IStackPresentationSite::STATE_MINIMIZED;
     if (!isMinimized)
     {
       // If the editor area is going to show then we have to restore
 //      if (getPresentation().getMaximizedStack() != 0)
 //      getPresentation().getMaximizedStack().setState(IStackPresentationSite.STATE_RESTORED);
 
       this->ShowEditorAreaLocal();
     }
 //    else
 //    setEditorAreaTrimVisibility(true);
   }
   else
   {
     this->ShowEditorAreaLocal();
   }
 }
 
 void Perspective::ShowEditorAreaLocal()
 {
   if (editorHolder == 0 || editorHidden)
   {
     return;
   }
 
   // Replace the part holder with the editor area.
   presentation->GetLayout()->Replace(editorHolder, editorArea);
   editorHolder = nullptr;
 }
 
 void Perspective::SetEditorAreaState(int newState)
 {
   if (newState == editorAreaState)
   return;
 
   editorAreaState = newState;
 
 //  // reset the restore flag if we're not minimized
 //  if (newState != IStackPresentationSite::STATE_MINIMIZED)
 //  editorAreaRestoreOnUnzoom = false;
 
   this->RefreshEditorAreaVisibility();
 }
 
 int Perspective::GetEditorAreaState()
 {
   return editorAreaState;
 }
 
 void Perspective::RefreshEditorAreaVisibility()
 {
   // Nothing shows up if the editor area isn't visible at all
   if (editorHidden)
   {
     this->HideEditorAreaLocal();
     //setEditorAreaTrimVisibility(false);
     return;
   }
 
   PartStack::Pointer editorStack = editorArea.Cast<EditorSashContainer>()->GetUpperRightEditorStack();
   if (editorStack == 0)
   return;
 
   // Whatever we're doing, make the current editor stack match it
   //editorStack->SetStateLocal(editorAreaState);
 
   // If it's minimized then it's in the trim
   if (editorAreaState == IStackPresentationSite::STATE_MINIMIZED)
   {
     // Hide the editor area and show its trim
     this->HideEditorAreaLocal();
     //setEditorAreaTrimVisibility(true);
   }
   else
   {
     // Show the editor area and hide its trim
     //setEditorAreaTrimVisibility(false);
     this->ShowEditorAreaLocal();
 
 //    if (editorAreaState == IStackPresentationSite::STATE_MAXIMIZED)
 //    getPresentation().setMaximizedStack(editorStack);
   }
 }
 
 IViewReference::Pointer Perspective::GetViewReference(const QString& viewId, const QString& secondaryId)
 {
   IViewReference::Pointer ref = page->FindViewReference(viewId, secondaryId);
   if (ref == 0)
   {
     ViewFactory* factory = this->GetViewFactory();
     try
     {
       ref = factory->CreateView(viewId, secondaryId);
     }
     catch (PartInitException& /*e*/)
     {
 //      IStatus status = StatusUtil.newStatus(IStatus.ERR,
 //          e.getMessage() == 0 ? "" : e.getMessage(), //$NON-NLS-1$
 //          e);
 //      StatusUtil.handleStatus(status, "Failed to create view: id=" + viewId, //$NON-NLS-1$
 //          StatusManager.LOG);
       //TODO Perspective status message
       WorkbenchPlugin::Log("Failed to create view: id=" + viewId);
     }
   }
   return ref;
 }
 
 IViewPart::Pointer Perspective::ShowView(const QString& viewId, const QString& secondaryId)
 {
   ViewFactory* factory = this->GetViewFactory();
   IViewReference::Pointer ref = factory->CreateView(viewId, secondaryId);
   IViewPart::Pointer part = ref->GetPart(true).Cast<IViewPart>();
   if (part == 0)
   {
     throw PartInitException("Could not create view: " + ref->GetId());
   }
   PartSite::Pointer site = part->GetSite().Cast<PartSite>();
   PartPane::Pointer pane = site->GetPane();
 
   //TODO Perspective preference store
 //  IPreferenceStore store = WorkbenchPlugin.getDefault()
 //  .getPreferenceStore();
 //  int openViewMode = store.getInt(IPreferenceConstants.OPEN_VIEW_MODE);
 //
 //  if (openViewMode == IPreferenceConstants.OVM_FAST &&
 //      fastViewManager != 0)
 //  {
 //    fastViewManager.addViewReference(FastViewBar.FASTVIEWBAR_ID, -1, ref, true);
 //    setActiveFastView(ref);
 //  }
 //  else if (openViewMode == IPreferenceConstants.OVM_FLOAT
 //      && presentation.canDetach())
 //  {
 //    presentation.addDetachedPart(pane);
 //  }
 //  else
 //  {
     if (this->UseNewMinMax(Perspective::Pointer(this)))
     {
       // Is this view going to show in the trim?
  //     LayoutPart vPart = presentation.findPart(viewId, secondaryId);
 
       // Determine if there is a trim stack that should get the view
       QString trimId;
 
 //      // If we can locate the correct trim stack then do so
 //      if (vPart != 0)
 //      {
 //        String id = 0;
 //        ILayoutContainer container = vPart.getContainer();
 //        if (container.Cast<ContainerPlaceholder>() != 0)
 //        id = ((ContainerPlaceholder)container).getID();
 //        else if (container.Cast<ViewStack>() != 0)
 //        id = ((ViewStack)container).getID();
 //
 //        // Is this place-holder in the trim?
 //        if (id != 0 && fastViewManager.getFastViews(id).size()> 0)
 //        {
 //          trimId = id;
 //        }
 //      }
 //
 //      // No explicit trim found; If we're maximized then we either have to find an
 //      // arbitrary stack...
 //      if (trimId == 0 && presentation.getMaximizedStack() != 0)
 //      {
 //        if (vPart == 0)
 //        {
 //          ViewStackTrimToolBar blTrimStack = fastViewManager.getBottomRightTrimStack();
 //          if (blTrimStack != 0)
 //          {
 //            // OK, we've found a trim stack to add it to...
 //            trimId = blTrimStack.getId();
 //
 //            // Since there was no placeholder we have to add one
 //            LayoutPart blPart = presentation.findPart(trimId, 0);
 //            if (blPart.Cast<ContainerPlaceholder>() != 0)
 //            {
 //              ContainerPlaceholder cph = (ContainerPlaceholder) blPart;
 //              if (cph.getRealContainer().Cast<ViewStack>() != 0)
 //              {
 //                ViewStack vs = (ViewStack) cph.getRealContainer();
 //
 //                // Create a 'compound' id if this is a multi-instance part
 //                String compoundId = ref.getId();
 //                if (ref.getSecondaryId() != 0)
 //                compoundId = compoundId + ':' + ref.getSecondaryId();
 //
 //                // Add the new placeholder
 //                vs.add(new PartPlaceholder(compoundId));
 //              }
 //            }
 //          }
 //        }
 //      }
 //
 //      // If we have a trim stack located then add the view to it
 //      if (trimId != "")
 //      {
 //        fastViewManager.addViewReference(trimId, -1, ref, true);
 //      }
 //      else
 //      {
 //        bool inMaximizedStack = vPart != 0 && vPart.getContainer() == presentation.getMaximizedStack();
 
         // Do the default behavior
         presentation->AddPart(pane);
 
 //        // Now, if we're maximized then we have to minimize the new stack
 //        if (presentation.getMaximizedStack() != 0 && !inMaximizedStack)
 //        {
 //          vPart = presentation.findPart(viewId, secondaryId);
 //          if (vPart != 0 && vPart.getContainer().Cast<ViewStack>() != 0)
 //          {
 //            ViewStack vs = (ViewStack)vPart.getContainer();
 //            vs.setState(IStackPresentationSite.STATE_MINIMIZED);
 //
 //            // setting the state to minimized will create the trim toolbar
 //            // so we don't need a 0 pointer check here...
 //            fastViewManager.getViewStackTrimToolbar(vs.getID()).setRestoreOnUnzoom(true);
 //          }
 //        }
   //    }
     }
     else
     {
       presentation->AddPart(pane);
     }
   //}
 
   // Ensure that the newly showing part is enabled
   if (pane != 0 && pane->GetControl() != nullptr)
   Tweaklets::Get(GuiWidgetsTweaklet::KEY)->SetEnabled(pane->GetControl(), true);
 
   return part;
 }
 
 IWorkbenchPartReference::Pointer Perspective::GetOldPartRef()
 {
   return oldPartRef;
 }
 
 void Perspective::SetOldPartRef(IWorkbenchPartReference::Pointer oldPartRef)
 {
   this->oldPartRef = oldPartRef;
 }
 
 bool Perspective::IsCloseable(IViewReference::Pointer reference)
 {
   ViewLayoutRec::Pointer rec = this->GetViewLayoutRec(reference, false);
   if (rec != 0)
   {
     return rec->isCloseable;
   }
   return true;
 }
 
 bool Perspective::IsMoveable(IViewReference::Pointer reference)
 {
   ViewLayoutRec::Pointer rec = this->GetViewLayoutRec(reference, false);
   if (rec != 0)
   {
     return rec->isMoveable;
   }
   return true;
 }
 
 void Perspective::DescribeLayout(QString& buf) const
 {
 //  QList<IViewReference::Pointer> fastViews = getFastViews();
 //
 //  if (fastViews.length != 0)
 //  {
 //    buf.append("fastviews ("); //$NON-NLS-1$
 //    for (int idx = 0; idx < fastViews.length; idx++)
 //    {
 //      IViewReference ref = fastViews[idx];
 //
 //      if (idx> 0)
 //      {
 //        buf.append(", "); //$NON-NLS-1$
 //      }
 //
 //      buf.append(ref.getPartName());
 //    }
 //    buf.append("), "); //$NON-NLS-1$
 //  }
 
   this->GetPresentation()->DescribeLayout(buf);
 }
 
 void Perspective::TestInvariants()
 {
   this->GetPresentation()->GetLayout()->TestInvariants();
 }
 
 bool Perspective::UseNewMinMax(Perspective::Pointer activePerspective)
 {
   // We need to have an active perspective
   if (activePerspective == 0)
   return false;
 
   // We need to have a trim manager (if we don't then we
   // don't create a FastViewManager because it'd be useless)
  // if (activePerspective->GetFastViewManager() == 0)
  // return false;
 
   // Make sure we don't NPE anyplace
   WorkbenchWindow::Pointer wbw = activePerspective->page->GetWorkbenchWindow().Cast<WorkbenchWindow>();
   if (wbw == 0)
   return false;
 
 //  WorkbenchWindowConfigurer* configurer = wbw->GetWindowConfigurer();
 //  if (configurer == 0)
 //  return false;
 
   IPresentationFactory* factory = WorkbenchPlugin::GetDefault()->GetPresentationFactory();
   if (factory == nullptr)
   return false;
 
   // Ok, we should be good to go, return the pref
   //IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
   //bool useNewMinMax = preferenceStore.getbool(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
   return true;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryQtSash.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryQtSash.cpp
index d1761d3122..637c6084e3 100755
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryQtSash.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryQtSash.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 "berryLog.h"
 
 #include "berryQtSash.h"
 
 #include <berryConstants.h>
 
 #include <QMouseEvent>
 #include <QStyleOption>
 #include <QPainter>
 
 namespace berry
 {
 
 /*!
  Creates a QtSash with the given orientation, parent, and smoothness.
  */
 QtSash::QtSash(Qt::Orientation orientation, QWidget *parent, bool smooth) :
   QWidget(parent), smooth(smooth), orientation(orientation), rubberBand(nullptr),
       lastX(0), lastY(0)
 {
   if (orientation == Qt::Horizontal)
     this->setCursor(Qt::SplitVCursor);
   else
     this->setCursor(Qt::SplitHCursor);
 }
 
 QtSash::~QtSash()
 {
 }
 
 void QtSash::AddSelectionListener(GuiTk::ISelectionListener::Pointer listener)
 {
   selectionEvents.AddListener(listener);
 }
 
 void QtSash::RemoveSelectionListener(
     GuiTk::ISelectionListener::Pointer listener)
 {
   selectionEvents.AddListener(listener);
 }
 
 /*!
  Returns the sash's orientation.
  */
 Qt::Orientation QtSash::GetOrientation() const
 {
   return orientation;
 }
 
 /*!
  Returns true if widgets are resized dynamically (smoothly), otherwise
  returns false.
  */
 bool QtSash::SmoothResize() const
 {
   return smooth;
 }
 
 /*!
  Tells the splitter to move this handle to position \a pos, which is
  the distance from the left or top edge of the widget.
 
  Note that \a pos is also measured from the left (or top) for
  right-to-left languages. This function will map \a pos to the
  appropriate position before calling QSplitter::moveSplitter().
 
  \sa QSplitter::moveSplitter() closestLegalPosition()
  */
 //void QtSash::moveSplitter(int pos)
 //{
 //    Q_D(QSplitterHandle);
 //    if (d->s->isRightToLeft() && d->orient == Qt::Horizontal)
 //        pos = d->s->contentsRect().width() - pos;
 //    d->s->moveSplitter(pos, d->s->indexOf(this));
 //}
 
 
 /*!
  \reimp
  */
 //QSize QtSash::sizeHint() const
 //{
 //    Q_D(const QSplitterHandle);
 //    int hw = d->s->handleWidth();
 //    QStyleOption opt(0);
 //    opt.init(d->s);
 //    opt.state = QStyle::State_None;
 //    return parentWidget()->style()->sizeFromContents(QStyle::CT_Splitter, &opt, QSize(hw, hw), d->s)
 //        .expandedTo(QApplication::globalStrut());
 //}
 
 /*!
  \reimp
  */
 bool QtSash::event(QEvent *event)
 {
   //    switch(event->type()) {
   //    case QEvent::HoverEnter:
   //        d->hover = true;
   //        update();
   //        break;
   //    case QEvent::HoverLeave:
   //        d->hover = false;
   //        update();
   //        break;
   //    default:
   //        break;
   //    }
   return QWidget::event(event);
 }
 
 /*!
  \reimp
  */
 void QtSash::mouseMoveEvent(QMouseEvent *e)
 {
   if (!dragging && !(e->buttons() & Qt::LeftButton))
     return;
 
   QPoint eventPoint(e->globalX(), e->globalY());
   eventPoint = this->parentWidget()->mapFromGlobal(eventPoint);
   int eventX = eventPoint.x();
   int eventY = eventPoint.y();
 //  int eventX = e->globalX();
 //  int eventY = e->globalY();
 
   //int x = OS.GTK_WIDGET_X (handle);
   //int y = OS.GTK_WIDGET_Y (handle);
   int width = this->geometry().width();
   int height = this->geometry().height();
   //int parentBorder = 0;
   //int parentWidth = OS.GTK_WIDGET_WIDTH (parent.handle);
   //int parentHeight = OS.GTK_WIDGET_HEIGHT (parent.handle);
 
   int newX = lastX;
   int newY = lastY;
 
   if ((orientation & Qt::Vertical) != 0)
   {
     //newX = std::min(std::max (0, eventX + x - startX - parentBorder), parentWidth - width);
     newX = eventX;
   }
   else
   {
     // newY = Math.min (Math.max (0, eventY + y - startY - parentBorder), parentHeight - height);
     newY = eventY;
   }
   if (newX == lastX && newY == lastY)
     return;
   drawRubberBand(lastX, lastY, width, height);
 
   GuiTk::SelectionEvent::Pointer event(new GuiTk::SelectionEvent(this));
   event->x = newX;
   event->y = newY;
   event->width = width;
   event->height = height;
   if (!smooth)
   {
     event->detail = Constants::DRAG;
   }
   selectionEvents.selected(event);
   if (event->doit)
   {
     lastX = event->x;
     lastY = event->y;
   }
 
   //parent.update (true, (style & SWT.SMOOTH) == 0);
   drawRubberBand(lastX, lastY, width, height);
   if (smooth)
   {
     setGeometry(lastX, lastY, width, height);
     // widget could be disposed at this point
   }
 }
 
 /*!
  \reimp
  */
 void QtSash::mousePressEvent(QMouseEvent *e)
 {
   if (e->button() == Qt::LeftButton)
   {
 //    const QRect& rect = this->geometry();
 //    QPoint p1(this->mapToGlobal(rect.topLeft()));
 //    QPoint p2(this->mapToGlobal(rect.bottomRight()));
 //    startRect = QRect(p1, p2);
 
     startRect = this->geometry();
 
     lastX = startRect.x();
     lastY = startRect.y();
     GuiTk::SelectionEvent::Pointer event(new GuiTk::SelectionEvent(this));
     event->x = lastX;
     event->y = lastY;
     event->width = startRect.width();
     event->height = startRect.height();
     if (!smooth)
     {
       event->detail = Constants::DRAG;
     }
     selectionEvents.selected(event);
 
     if (event->doit)
     {
       dragging = true;
       lastX = event->x;
       lastY = event->y;
       //parent.update (true, (style & SWT.SMOOTH) == 0);
       drawRubberBand(lastX, lastY, startRect.width(), startRect.height());
       if (smooth)
       {
         this->setGeometry(lastX, lastY, startRect.width(), startRect.height());
         // widget could be disposed at this point
       }
     }
   }
 
 }
 
 /*!
  \reimp
  */
 void QtSash::mouseReleaseEvent(QMouseEvent *e)
 {
   if (dragging && e->button() == Qt::LeftButton)
   {
 
     this->drawRubberBand(-1, -1, -1, -1);
 
     dragging = false;
     const QRect& rect = this->geometry();
     int width = rect.width();
     int height = rect.height();
     GuiTk::SelectionEvent::Pointer event(new GuiTk::SelectionEvent(this));
     event->x = lastX;
     event->y = lastY;
     event->width = width;
     event->height = height;
     //drawBand (lastX, lastY, width, height);
     selectionEvents.selected(event);
     if (event->doit)
     {
       if (smooth)
       {
         this->setGeometry(event->x, event->y, width, height);
         // widget could be disposed at this point
       }
     }
   }
 }
 
 void QtSash::drawRubberBand(int x, int y, int width, int height)
 {
   if (smooth)
     return;
 
   if (x < 0 || y < 0)
   {
     if (this->rubberBand)
       this->rubberBand->hide();
     return;
   }
 
   if (!this->rubberBand)
   {
     this->rubberBand = new QRubberBand(QRubberBand::Line, this->parentWidget());
     // For accessibility to identify this special widget.
     this->rubberBand->setObjectName(QLatin1String("qt_rubberband"));
   }
   this->rubberBand->setGeometry(x, y, width, height);
   if (!this->rubberBand->isVisible())
     this->rubberBand->show();
 }
 
 void QtSash::paintEvent(QPaintEvent*)
 {
   QStyleOption opt;
-  opt.init(this);
+  opt.initFrom(this);
   QPainter p(this);
   style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp
index 04a00c6a33..7c22f943da 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();
+      this->invalidateFilter();
     }
   }
 
 protected:
 
   bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const override
   {
     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.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp
index 9126eb59e3..0f9778493c 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp
@@ -1,300 +1,300 @@
 /*============================================================================
 
 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 "berryReopenEditorMenu.h"
 
 #include <berryIWorkbench.h>
 #include <berryIWorkbenchPage.h>
 
 #include <berryMenuManager.h>
 #include <berrySafeRunner.h>
 
 #include "berryEditorHistory.h"
 #include "berryEditorHistoryItem.h"
 #include "berryWorkbench.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryPreferenceConstants.h"
 
 #include <QAction>
 #include <QMenu>
 #include <QMessageBox>
 
 #include <mitkIPreferences.h>
 
 namespace berry {
 
 ReopenEditorMenu::ReopenEditorMenu(IWorkbenchWindow* window, const QString& id, bool showSeparator)
   : ContributionItem(id)
   , window(window)
   , history(nullptr)
   , showSeparator(showSeparator)
   , dirty(true)
 {
   IWorkbench* workbench = window->GetWorkbench();
   if (Workbench* w = dynamic_cast<Workbench*>(workbench))
   {
     history = w->GetEditorHistory();
   }
 }
 
 QString ReopenEditorMenu::CalcText(int index, const QString& name, const QString& toolTip, bool rtl)
 {
   QString sb;
 
   int mnemonic = index + 1;
   QString nm = QString::number(mnemonic);
   if (mnemonic <= MAX_MNEMONIC_SIZE)
   {
     nm.prepend('&');
   }
 
   QString fileName = name;
   QString pathName = toolTip;
   if (pathName == fileName)
   {
     // tool tip text isn't necessarily a path;
     // sometimes it's the same as name, so it shouldn't be treated as a path then
     pathName.clear();
   }
   QFileInfo path(pathName);
   // if last segment in path is the fileName, remove it
   if (path.fileName() == fileName)
   {
     path.setFile(path.path());
     pathName = path.absoluteFilePath();
   }
 
   if ((fileName.size() + pathName.size()) <= (MAX_TEXT_LENGTH - 4))
   {
     // entire item name fits within maximum length
     sb += fileName;
     if (!pathName.isEmpty())
     {
       sb += "  [" + pathName + "]";
     }
   }
   else
   {
     // need to shorten the item name
     int length = fileName.size();
     if (length > MAX_TEXT_LENGTH)
     {
       // file name does not fit within length, truncate it
       sb += QStringView(fileName).left(MAX_TEXT_LENGTH - 3);
       sb += "...";
     }
     else if (length > MAX_TEXT_LENGTH - 7)
     {
       sb += fileName;
     }
     else
     {
       sb += fileName;
       QStringList pathSegments = path.absoluteFilePath().split('/', Qt::SkipEmptyParts);
       int segmentCount = pathSegments.size();
       if (segmentCount > 0)
       {
         length += 7; // 7 chars are taken for "  [...]"
 
         sb += "  [";
 
         // Add first n segments that fit
         int i = 0;
         while (i < segmentCount && length < MAX_TEXT_LENGTH)
         {
           const QString& segment = pathSegments[i];
           if (length + segment.size() < MAX_TEXT_LENGTH)
           {
             sb += segment + QDir::separator();
             length += segment.size() + 1;
             i++;
           }
           else if (i == 0)
           {
             // append at least part of the first segment
             sb += QStringView(segment).left(MAX_TEXT_LENGTH - length);
             length = MAX_TEXT_LENGTH;
             break;
           }
           else
           {
             break;
           }
         }
 
         sb += "...";
 
         i = segmentCount - 1;
         // Add last n segments that fit
         while (i > 0 && length < MAX_TEXT_LENGTH)
         {
           const QString& segment = pathSegments[i];
           if (length + segment.size() < MAX_TEXT_LENGTH)
           {
             sb += QDir::separator();
             sb += segment;
             length += segment.size() + 1;
             i--;
           }
           else
           {
             break;
           }
         }
 
         sb.append("]");
       }
     }
   }
   QString process;
   if (rtl)
   {
     process = sb + " " + nm;
   }
   else
   {
     process = nm + " " + sb;
   }
   //return TextProcessor.process(process, TextProcessor.getDefaultDelimiters() + "[]");
   return process;
 }
 
 void ReopenEditorMenu::Fill(QMenu* menu, QAction* before)
 {
   if (window->GetActivePage() == nullptr
       || window->GetActivePage()->GetPerspective().IsNull())
   {
     return;
   }
 
   if (MenuManager* mm = dynamic_cast<MenuManager*>(this->GetParent()))
   {
     mm->connect(mm, SIGNAL(AboutToShow(IMenuManager*)), this, SLOT(MenuAboutToShow(IMenuManager*)));
   }
 
   int itemsToShow = WorkbenchPlugin::GetDefault()->GetPreferences()->GetInt(PreferenceConstants::RECENT_FILES, 6);
   if (itemsToShow == 0 || history == nullptr)
   {
     return;
   }
 
   // Get items.
   QList<EditorHistoryItem::Pointer> historyItems = history->GetItems();
 
-  int n = std::min(itemsToShow, historyItems.size());
+  int n = std::min(itemsToShow, static_cast<int>(historyItems.size()));
   if (n <= 0)
   {
     return;
   }
 
   if (showSeparator)
   {
     menu->addSeparator();
   }
 
   struct _SafeRunnable : public ISafeRunnable
   {
     QMenu* menu;
     QAction* before;
     EditorHistoryItem::Pointer item;
     const int historyIndex;
 
     _SafeRunnable(QMenu* menu, QAction* before, EditorHistoryItem::Pointer item, int index)
       : menu(menu), before(before), item(item), historyIndex(index) {}
 
     void Run() override
     {
       QString text = ReopenEditorMenu::CalcText(historyIndex, item);
       auto   mi = new QAction(text, nullptr);
       menu->insertAction(before, mi);
       mi->setData(QVariant::fromValue(item));
     }
 
     void HandleException(const ctkException& e) override
     {
       // just skip the item if there's an error,
       // e.g. in the calculation of the shortened name
       WorkbenchPlugin::Log(this->GetClassName(), "Fill", e);
     }
   };
 
   for (int i = 0; i < n; i++)
   {
     EditorHistoryItem::Pointer item = historyItems[i];
     ISafeRunnable::Pointer runnable(new _SafeRunnable(menu, before, item, i));
     SafeRunner::Run(runnable);
   }
   dirty = false;
 }
 
 bool ReopenEditorMenu::IsDirty() const
 {
   return dirty;
 }
 
 bool ReopenEditorMenu::IsDynamic() const
 {
   return true;
 }
 
 void ReopenEditorMenu::Open(const EditorHistoryItem::Pointer& item)
 {
   IWorkbenchPage::Pointer page = window->GetActivePage();
   if (page.IsNotNull())
   {
     try
     {
       QString itemName = item->GetName();
       if (!item->IsRestored())
       {
         item->RestoreState();
       }
       IEditorInput::Pointer input = item->GetInput();
       IEditorDescriptor::Pointer desc = item->GetDescriptor();
       if (!input || !desc)
       {
         QString title = "Problems opening editor";
         QString msg = QString("Unable to open %1.").arg(itemName);
         QMessageBox::warning(window->GetShell()->GetControl(), title, msg);
         history->Remove(item);
       }
       else
       {
         page->OpenEditor(input, desc->GetId());
       }
     }
     catch (const PartInitException& e2)
     {
       QString title = "Problems opening editor";
       QMessageBox::warning(window->GetShell()->GetControl(), title, e2.what());
       history->Remove(item);
     }
   }
 }
 
 QString ReopenEditorMenu::CalcText(int index, const EditorHistoryItem::Pointer& item)
 {
   // IMPORTANT: avoid accessing the item's input since
   // this can require activating plugins.
   // Instead, ask the item for the info, which can
   // consult its memento if it is not restored yet.
   return CalcText(index, item->GetName(), item->GetToolTipText(), false);
                   // Window::GetDefaultOrientation() == SWT.RIGHT_TO_LEFT);
 }
 
 void ReopenEditorMenu::MenuAboutToShow(IMenuManager* manager)
 {
   manager->MarkDirty();
   dirty = true;
 }
 
 }