diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp
index ed9001b401..9126eb59e3 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 += fileName.leftRef(MAX_TEXT_LENGTH - 3);
+      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 += segment.leftRef(MAX_TEXT_LENGTH - length);
+            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());
   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;
 }
 
 }
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berrySwitchToWindowMenu.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berrySwitchToWindowMenu.cpp
index 88de2a2fa0..c92f6dad15 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berrySwitchToWindowMenu.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berrySwitchToWindowMenu.cpp
@@ -1,155 +1,155 @@
 /*============================================================================
 
 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 "berrySwitchToWindowMenu.h"
 
 #include <berryMenuManager.h>
 #include <berryShell.h>
 
 #include <berryIWorkbench.h>
 #include <berryIWorkbenchWindow.h>
 
 #include <QAction>
 #include <QActionGroup>
 #include <QMenu>
 #include <QSignalMapper>
 
 namespace berry {
 
 void SwitchToWindowMenu::AboutToShow(IMenuManager* manager)
 {
   manager->MarkDirty();
   dirty = true;
 }
 
 void SwitchToWindowMenu::MenuItemTriggered(int index)
 {
   if (index < 0 || index >= windows.size()) return;
 
   IWorkbenchWindow* window = windows[index];
   Shell::Pointer windowShell = window->GetShell();
   if (windowShell->GetMinimized())
   {
     windowShell->SetMinimized(false);
   }
   windowShell->SetActive();
   windowShell->GetControl()->raise();
 
 }
 
 QString SwitchToWindowMenu::CalcText(int number, IWorkbenchWindow* window)
 {
   QString suffix = window->GetShell()->GetText();
   if (suffix.isEmpty())
   {
     return QString();
   }
 
   QString sb;
   if (number < 10)
   {
     sb.append('&');
   }
   sb.append(QString::number(number));
   sb.append(' ');
   if (suffix.size() <= MAX_TEXT_LENGTH)
   {
     sb.append(suffix);
   }
   else
   {
-    sb.append(suffix.leftRef(MAX_TEXT_LENGTH));
+    sb.append(QStringView(suffix).left(MAX_TEXT_LENGTH));
     sb.append("...");
   }
   return sb;
 }
 
 SwitchToWindowMenu::SwitchToWindowMenu(IWorkbenchWindow* window, const QString& id, bool showSeparator)
   : ContributionItem(id)
   , workbenchWindow(window)
   , showSeparator(showSeparator)
   , dirty(true)
 {
 }
 
 void SwitchToWindowMenu::Fill(QMenu* menu, QAction* before)
 {
 
   // Get workbench windows.
   IWorkbench* workbench = workbenchWindow->GetWorkbench();
   windows.clear();
   for (const auto &window : workbench->GetWorkbenchWindows())
   {
     windows.push_back(window.GetPointer());
   }
 
   // avoid showing the separator and list for 0 or 1 items
   if (windows.size() < 2)
   {
     return;
   }
 
   if (MenuManager* mm = dynamic_cast<MenuManager*>(GetParent()))
   {
     this->connect(mm, SIGNAL(AboutToShow(IMenuManager*)), SLOT(AboutToShow(IMenuManager*)));
   }
 
   if (!dirty)
   {
     return;
   }
 
   // Add separator.
   if (showSeparator)
   {
     menu->insertSeparator(before);
   }
 
   // Add one item for each window.
   auto   actionGroup = new QActionGroup(menu);
   actionGroup->setExclusive(true);
   auto   signalMapper = new QSignalMapper(menu);
   connect(signalMapper, SIGNAL(mapped(int)), SLOT(MenuItemTriggered(int)));
   int count = 0;
   for (auto window : qAsConst(windows))
   {
     // can encounter disposed shells if this update is in response to a shell closing
     //if (!window->GetShell()->IsDisposed())
     //{
       QString name = CalcText(count, window);
       if (!name.isEmpty())
       {
         auto   mi = new QAction(name, menu);
         mi->setCheckable(true);
         mi->setChecked(window == workbenchWindow);
         actionGroup->addAction(mi);
         menu->insertAction(before, mi);
         signalMapper->setMapping(mi, count);
         connect(mi, SIGNAL(triggered()), signalMapper, SLOT(map()));
       }
       ++count;
     }
   //}
   dirty = false;
 }
 
 bool SwitchToWindowMenu::IsDirty() const
 {
   return dirty;
 }
 
 bool SwitchToWindowMenu::IsDynamic() const
 {
   return true;
 }
 
 }