diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
index e33eefbf..c8fa2976 100644
--- a/src/MainWindow.cpp
+++ b/src/MainWindow.cpp
@@ -1,929 +1,934 @@
 /*
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "MainWindow.h"
 
 // Qt
 #include <QMouseEvent>
 
 // KDE
 #include <KAcceleratorManager>
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KShortcutsDialog>
 #include <KLocalizedString>
 #include <KWindowEffects>
 
 #include <QMenu>
 #include <QMenuBar>
 #include <KMessageBox>
 #include <KStandardAction>
 #include <KStandardGuiItem>
 #include <KWindowSystem>
 #include <KXMLGUIFactory>
 #include <KNotifyConfigWidget>
 #include <KIconLoader>
 
 // Konsole
 #include "BookmarkHandler.h"
 #include "SessionController.h"
 #include "ProfileList.h"
 #include "Session.h"
 #include "ViewContainer.h"
 #include "ViewManager.h"
 #include "SessionManager.h"
 #include "ProfileManager.h"
 #include "KonsoleSettings.h"
 #include "WindowSystemInfo.h"
 #include "TerminalDisplay.h"
 #include "settings/ConfigurationDialog.h"
 #include "settings/TemporaryFilesSettings.h"
 #include "settings/GeneralSettings.h"
 #include "settings/ProfileSettings.h"
 #include "settings/TabBarSettings.h"
 
 using namespace Konsole;
 
 MainWindow::MainWindow() :
     KXmlGuiWindow(),
     _viewManager(nullptr),
     _bookmarkHandler(nullptr),
     _toggleMenuBarAction(nullptr),
     _newTabMenuAction(nullptr),
     _pluggedController(nullptr),
     _menuBarInitialVisibility(true),
     _menuBarInitialVisibilityApplied(false)
 {
     if (!KonsoleSettings::saveGeometryOnExit()) {
         // If we are not using the global Konsole save geometry on exit,
         // remove all Height and Width from [MainWindow] from konsolerc
         // Each screen resolution will have entries (Width 1280=619)
         KSharedConfigPtr konsoleConfig = KSharedConfig::openConfig(QStringLiteral("konsolerc"));
         KConfigGroup group = konsoleConfig->group("MainWindow");
         QMap<QString, QString> configEntries = group.entryMap();
         QMapIterator<QString, QString> i(configEntries);
         while (i.hasNext()) {
             i.next();
             if (i.key().startsWith(QLatin1String("Width"))
                 || i.key().startsWith(QLatin1String("Height"))) {
                 group.deleteEntry(i.key());
             }
         }
     }
 
     updateUseTransparency();
 
     // create actions for menus
     setupActions();
 
     // create view manager
     _viewManager = new ViewManager(this, actionCollection());
     connect(_viewManager, &Konsole::ViewManager::empty, this, &Konsole::MainWindow::close);
     connect(_viewManager, &Konsole::ViewManager::activeViewChanged, this,
             &Konsole::MainWindow::activeViewChanged);
     connect(_viewManager, &Konsole::ViewManager::unplugController, this,
             &Konsole::MainWindow::disconnectController);
     connect(_viewManager, &Konsole::ViewManager::viewPropertiesChanged,
             bookmarkHandler(), &Konsole::BookmarkHandler::setViews);
     connect(_viewManager, &Konsole::ViewManager::blurSettingChanged,
             this, &Konsole::MainWindow::setBlur);
 
     connect(_viewManager, &Konsole::ViewManager::updateWindowIcon, this,
             &Konsole::MainWindow::updateWindowIcon);
     connect(_viewManager, &Konsole::ViewManager::newViewWithProfileRequest,
             this, &Konsole::MainWindow::newFromProfile);
     connect(_viewManager, &Konsole::ViewManager::newViewRequest,
             this, &Konsole::MainWindow::newTab);
     connect(_viewManager, &Konsole::ViewManager::terminalsDetached, this,
             &Konsole::MainWindow::terminalsDetached);
 
     setCentralWidget(_viewManager->widget());
 
     // disable automatically generated accelerators in top-level
     // menu items - to avoid conflicting with Alt+[Letter] shortcuts
     // in terminal applications
     KAcceleratorManager::setNoAccel(menuBar());
 
     // create menus
     createGUI();
 
     // remember the original menu accelerators for later use
     rememberMenuAccelerators();
 
     // replace standard shortcuts which cannot be used in a terminal
     // emulator (as they are reserved for use by terminal applications)
     correctStandardShortcuts();
 
     setProfileList(new ProfileList(true, this));
 
     // this must come at the end
     applyKonsoleSettings();
     connect(KonsoleSettings::self(), &Konsole::KonsoleSettings::configChanged, this,
             &Konsole::MainWindow::applyKonsoleSettings);
 }
 
 void MainWindow::updateUseTransparency()
 {
     if (!WindowSystemInfo::HAVE_TRANSPARENCY) {
         return;
     }
 
     bool useTranslucency = KWindowSystem::compositingActive();
 
     setAttribute(Qt::WA_TranslucentBackground, useTranslucency);
     setAttribute(Qt::WA_NoSystemBackground, false);
     WindowSystemInfo::HAVE_TRANSPARENCY = useTranslucency;
 }
 
 void MainWindow::rememberMenuAccelerators()
 {
     const QList<QAction *> actions = menuBar()->actions();
     for (QAction *menuItem : actions) {
         QString itemText = menuItem->text();
         menuItem->setData(itemText);
     }
 }
 
 // remove accelerators for standard menu items (eg. &File, &View, &Edit)
 // etc. which are defined in kdelibs/kdeui/xmlgui/ui_standards.rc, again,
 // to avoid conflicting with Alt+[Letter] terminal shortcuts
 //
 // TODO - Modify XMLGUI so that it allows the text for standard actions
 // defined in ui_standards.rc to be re-defined in the local application
 // XMLGUI file (konsoleui.rc in this case) - the text for standard items
 // can then be redefined there to exclude the standard accelerators
 void MainWindow::removeMenuAccelerators()
 {
     const QList<QAction *> actions = menuBar()->actions();
     for (QAction *menuItem : actions) {
         menuItem->setText(menuItem->text().replace(QLatin1Char('&'), QString()));
     }
 }
 
 void MainWindow::restoreMenuAccelerators()
 {
     const QList<QAction *> actions = menuBar()->actions();
     for (QAction *menuItem : actions) {
         QString itemText = menuItem->data().toString();
         menuItem->setText(itemText);
     }
 }
 
 void MainWindow::correctStandardShortcuts()
 {
     // replace F1 shortcut for help contents
     QAction *helpAction = actionCollection()->action(QStringLiteral("help_contents"));
     if (helpAction != nullptr) {
         actionCollection()->setDefaultShortcut(helpAction, QKeySequence());
     }
 
     // replace Ctrl+B shortcut for bookmarks only if user hasn't already
     // changed the shortcut; however, if the user changed it to Ctrl+B
     // this will still get changed to Ctrl+Shift+B
     QAction *bookmarkAction = actionCollection()->action(QStringLiteral("add_bookmark"));
     if ((bookmarkAction != nullptr)
         && bookmarkAction->shortcut() == QKeySequence(Konsole::ACCEL + Qt::Key_B)) {
         actionCollection()->setDefaultShortcut(bookmarkAction,
                                                Konsole::ACCEL + Qt::SHIFT + Qt::Key_B);
     }
 }
 
 ViewManager *MainWindow::viewManager() const
 {
     return _viewManager;
 }
 
 void MainWindow::disconnectController(SessionController *controller)
 {
     disconnect(controller, &Konsole::SessionController::titleChanged,
                this, &Konsole::MainWindow::activeViewTitleChanged);
     disconnect(controller, &Konsole::SessionController::rawTitleChanged,
                this, &Konsole::MainWindow::updateWindowCaption);
     disconnect(controller, &Konsole::SessionController::iconChanged,
                this, &Konsole::MainWindow::updateWindowIcon);
 
     if (auto view = controller->view()) {
         view->removeEventFilter(this);
     }
 
     // KXmlGuiFactory::removeClient() will try to access actions associated
     // with the controller internally, which may not be valid after the controller
     // itself is no longer valid (after the associated session and or view have
     // been destroyed)
     if (controller->isValid()) {
         guiFactory()->removeClient(controller);
     }
 
     if (_pluggedController == controller) {
         _pluggedController = nullptr;
     }
 }
 
 void MainWindow::activeViewChanged(SessionController *controller)
 {
     if (!SessionManager::instance()->sessionProfile(controller->session())) {
         return;
     }
     // associate bookmark menu with current session
     bookmarkHandler()->setActiveView(controller);
     disconnect(bookmarkHandler(), &Konsole::BookmarkHandler::openUrl, nullptr, nullptr);
     connect(bookmarkHandler(), &Konsole::BookmarkHandler::openUrl, controller,
             &Konsole::SessionController::openUrl);
 
     if (!_pluggedController.isNull()) {
         disconnectController(_pluggedController);
     }
 
     Q_ASSERT(controller);
     _pluggedController = controller;
     _pluggedController->view()->installEventFilter(this);
 
     setBlur(ViewManager::profileHasBlurEnabled(SessionManager::instance()->sessionProfile(_pluggedController->session())));
 
     // listen for title changes from the current session
     connect(controller, &Konsole::SessionController::titleChanged, this,
             &Konsole::MainWindow::activeViewTitleChanged);
     connect(controller, &Konsole::SessionController::rawTitleChanged, this,
             &Konsole::MainWindow::updateWindowCaption);
     connect(controller, &Konsole::SessionController::iconChanged, this,
             &Konsole::MainWindow::updateWindowIcon);
 
     controller->setShowMenuAction(_toggleMenuBarAction);
     guiFactory()->addClient(controller);
 
     // update session title to match newly activated session
     activeViewTitleChanged(controller);
 
     // Update window icon to newly activated session's icon
     updateWindowIcon();
 }
 
 void MainWindow::activeViewTitleChanged(ViewProperties *properties)
 {
     Q_UNUSED(properties)
     updateWindowCaption();
 }
 
 void MainWindow::updateWindowCaption()
 {
     if (_pluggedController.isNull()) {
         return;
     }
 
     const QString &title = _pluggedController->title();
     const QString &userTitle = _pluggedController->userTitle();
 
     // use tab title as caption by default
     QString caption = title;
 
     // use window title as caption when this setting is enabled
     // if the userTitle is empty, use a blank space (using an empty string
     // removes the dash — before the application name; leaving the dash
     // looks better)
     if (KonsoleSettings::showWindowTitleOnTitleBar()) {
         !userTitle.isEmpty() ? caption = userTitle : caption = QStringLiteral(" ");
     }
 
     setCaption(caption);
 }
 
 void MainWindow::updateWindowIcon()
 {
     if ((!_pluggedController.isNull()) && !_pluggedController->icon().isNull()) {
         setWindowIcon(_pluggedController->icon());
     }
 }
 
 void MainWindow::setupActions()
 {
     KActionCollection *collection = actionCollection();
 
     // File Menu
     _newTabMenuAction = new KActionMenu(QIcon::fromTheme(QStringLiteral("tab-new")),
                                         i18nc("@action:inmenu", "&New Tab"), collection);
     collection->setDefaultShortcut(_newTabMenuAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_T);
     collection->setShortcutsConfigurable(_newTabMenuAction, true);
     _newTabMenuAction->setAutoRepeat(false);
     connect(_newTabMenuAction, &KActionMenu::triggered, this, &MainWindow::newTab);
     collection->addAction(QStringLiteral("new-tab"), _newTabMenuAction);
     collection->setShortcutsConfigurable(_newTabMenuAction, true);
 
     QAction* menuAction = collection->addAction(QStringLiteral("clone-tab"));
     menuAction->setIcon(QIcon::fromTheme(QStringLiteral("tab-duplicate")));
     menuAction->setText(i18nc("@action:inmenu", "&Clone Tab"));
     collection->setDefaultShortcut(menuAction, QKeySequence());
     menuAction->setAutoRepeat(false);
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::cloneTab);
 
     menuAction = collection->addAction(QStringLiteral("new-window"));
     menuAction->setIcon(QIcon::fromTheme(QStringLiteral("window-new")));
     menuAction->setText(i18nc("@action:inmenu", "New &Window"));
     collection->setDefaultShortcut(menuAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_N);
     menuAction->setAutoRepeat(false);
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::newWindow);
 
     menuAction = collection->addAction(QStringLiteral("close-window"));
     menuAction->setIcon(QIcon::fromTheme(QStringLiteral("window-close")));
     menuAction->setText(i18nc("@action:inmenu", "Close Window"));
     collection->setDefaultShortcut(menuAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_Q);
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::close);
 
     // Bookmark Menu
     KActionMenu *bookmarkMenu = new KActionMenu(i18nc("@title:menu", "&Bookmarks"), collection);
     _bookmarkHandler = new BookmarkHandler(collection, bookmarkMenu->menu(), true, this);
     collection->addAction(QStringLiteral("bookmark"), bookmarkMenu);
     connect(_bookmarkHandler, &Konsole::BookmarkHandler::openUrls, this,
             &Konsole::MainWindow::openUrls);
 
     // Settings Menu
     _toggleMenuBarAction = KStandardAction::showMenubar(menuBar(), SLOT(setVisible(bool)), collection);
     collection->setDefaultShortcut(_toggleMenuBarAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_M);
 
     // Full Screen
     menuAction = KStandardAction::fullScreen(this, SLOT(viewFullScreen(bool)), this, collection);
     collection->setDefaultShortcut(menuAction, Qt::Key_F11);
 
     KStandardAction::configureNotifications(this, SLOT(configureNotifications()), collection);
     KStandardAction::keyBindings(this, SLOT(showShortcutsDialog()), collection);
     KStandardAction::preferences(this, SLOT(showSettingsDialog()), collection);
 
     menuAction = collection->addAction(QStringLiteral("manage-profiles"));
     menuAction->setText(i18nc("@action:inmenu", "Manage Profiles..."));
     menuAction->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::showManageProfilesDialog);
 
     // Set up an shortcut-only action for activating menu bar.
     menuAction = collection->addAction(QStringLiteral("activate-menu"));
     menuAction->setText(i18nc("@item", "Activate Menu"));
     collection->setDefaultShortcut(menuAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_F10);
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::activateMenuBar);
 }
 
 void MainWindow::viewFullScreen(bool fullScreen)
 {
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);
     }
 }
 
 BookmarkHandler *MainWindow::bookmarkHandler() const
 {
     return _bookmarkHandler;
 }
 
 void MainWindow::setProfileList(ProfileList *list)
 {
     profileListChanged(list->actions());
 
     connect(list, &Konsole::ProfileList::profileSelected, this, &MainWindow::newFromProfile);
     connect(list, &Konsole::ProfileList::actionsChanged, this, &Konsole::MainWindow::profileListChanged);
 }
 
 void MainWindow::profileListChanged(const QList<QAction *> &sessionActions)
 {
     // If only 1 profile is to be shown in the menu, only display
     // it if it is the non-default profile.
     if (sessionActions.size() > 2) {
         // Update the 'New Tab' KActionMenu
         if (_newTabMenuAction->menu() != nullptr) {
             _newTabMenuAction->menu()->clear();
         } else {
             _newTabMenuAction->setMenu(new QMenu());
         }
         for (QAction *sessionAction : sessionActions) {
             _newTabMenuAction->menu()->addAction(sessionAction);
 
             // NOTE: defaultProfile seems to not work here, sigh.
             Profile::Ptr profile = ProfileManager::instance()->defaultProfile();
             if (profile && profile->name() == sessionAction->text().remove(QLatin1Char('&'))) {
                 QIcon icon(KIconLoader::global()->loadIcon(profile->icon(), KIconLoader::Small, 0, KIconLoader::DefaultState, QStringList(QStringLiteral("emblem-favorite"))));
                 sessionAction->setIcon(icon);
                 _newTabMenuAction->menu()->setDefaultAction(sessionAction);
                 QFont actionFont = sessionAction->font();
                 actionFont.setBold(true);
                 sessionAction->setFont(actionFont);
             }
         }
     } else {
         if (_newTabMenuAction->menu() != nullptr) {
             _newTabMenuAction->menu()->clear();
         } else {
             _newTabMenuAction->setMenu(new QMenu());
         }
         Profile::Ptr profile = ProfileManager::instance()->defaultProfile();
 
         // NOTE: Compare names w/o any '&'
         if (sessionActions.size() == 2
             && sessionActions[1]->text().remove(QLatin1Char('&')) != profile->name()) {
             _newTabMenuAction->menu()->addAction(sessionActions[1]);
         } else {
             _newTabMenuAction->menu()->deleteLater();
         }
     }
 }
 
 QString MainWindow::activeSessionDir() const
 {
     if (!_pluggedController.isNull()) {
         if (Session *session = _pluggedController->session()) {
             // For new tabs to get the correct working directory,
             // force the updating of the currentWorkingDirectory.
             session->getDynamicTitle();
         }
         return _pluggedController->currentDir();
     } else {
         return QString();
     }
 }
 
 void MainWindow::openUrls(const QList<QUrl> &urls)
 {
     Profile::Ptr defaultProfile = ProfileManager::instance()->defaultProfile();
 
     for (const auto &url : urls) {
         if (url.isLocalFile()) {
             createSession(defaultProfile, url.path());
         } else if (url.scheme() == QLatin1String("ssh")) {
             createSSHSession(defaultProfile, url);
         }
     }
 }
 
 void MainWindow::newTab()
 {
     Profile::Ptr defaultProfile = ProfileManager::instance()->defaultProfile();
     createSession(defaultProfile, activeSessionDir());
 }
 
 void MainWindow::cloneTab()
 {
     Q_ASSERT(_pluggedController);
 
     Session *session = _pluggedController->session();
     Profile::Ptr profile = SessionManager::instance()->sessionProfile(session);
     if (profile) {
         createSession(profile, activeSessionDir());
     } else {
         // something must be wrong: every session should be associated with profile
         Q_ASSERT(false);
         newTab();
     }
 }
 
 Session *MainWindow::createSession(Profile::Ptr profile, const QString &directory)
 {
     if (!profile) {
         profile = ProfileManager::instance()->defaultProfile();
     }
 
     const QString newSessionDirectory = profile->startInCurrentSessionDir() ? directory : QString();
     Session *session = _viewManager->createSession(profile, newSessionDirectory);
 
     // create view before starting the session process so that the session
     // doesn't suffer a change in terminal size right after the session
     // starts.  Some applications such as GNU Screen and Midnight Commander
     // don't like this happening
     auto newView = _viewManager->createView(session);
     _viewManager->activeContainer()->addView(newView);
     return session;
 }
 
 Session *MainWindow::createSSHSession(Profile::Ptr profile, const QUrl &url)
 {
     if (!profile) {
         profile = ProfileManager::instance()->defaultProfile();
     }
 
     Session *session = SessionManager::instance()->createSession(profile);
 
     QString sshCommand = QStringLiteral("ssh ");
     if (url.port() > -1) {
         sshCommand += QStringLiteral("-p %1 ").arg(url.port());
     }
     if (!url.userName().isEmpty()) {
         sshCommand += (url.userName() + QLatin1Char('@'));
     }
     if (!url.host().isEmpty()) {
         sshCommand += url.host();
     }
 
     session->sendTextToTerminal(sshCommand, QLatin1Char('\r'));
 
     // create view before starting the session process so that the session
     // doesn't suffer a change in terminal size right after the session
     // starts.  some applications such as GNU Screen and Midnight Commander
     // don't like this happening
     auto newView = _viewManager->createView(session);
     _viewManager->activeContainer()->addView(newView);
     return session;
 }
 
 void MainWindow::setFocus()
 {
     _viewManager->activeView()->setFocus();
 }
 
 void MainWindow::newWindow()
 {
     Profile::Ptr defaultProfile = ProfileManager::instance()->defaultProfile();
     emit newWindowRequest(defaultProfile, activeSessionDir());
 }
 
 bool MainWindow::queryClose()
 {
     // Do not ask for confirmation during log out and power off
     // TODO: rework the dealing of this case to make it has its own confirmation
     // dialog.
     if (qApp->isSavingSession()) {
         return true;
     }
 
     // Check what processes are running, excluding the shell
     QStringList processesRunning;
-    // Once Qt5.14+ is the mininum, change to use range constructors
-    const auto uniqueSessions = QSet<Session*>::fromList(_viewManager->sessions());
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
+    // Need to make a local copy so the begin() and end() point to the same QList
+    const QList<Session*> sessionList = _viewManager->sessions();
+    const QSet<Session*> uniqueSessions(sessionList.end(), sessionList.end());
+#else
+    const QSet<Session*> uniqueSessions = QSet<Session*>::fromList(_viewManager->sessions());
+#endif
 
     for (Session *session : uniqueSessions) {
         if ((session == nullptr) || !session->isForegroundProcessActive()) {
             continue;
         }
 
         const QString defaultProc = session->program().split(QLatin1Char('/')).last();
         const QString currentProc = session->foregroundProcessName().split(QLatin1Char('/')).last();
 
         if (currentProc.isEmpty()) {
             continue;
         }
 
         if (defaultProc != currentProc) {
             processesRunning.append(currentProc);
         }
     }
 
     // Get number of open tabs
     const int openTabs = _viewManager->viewProperties().count();
 
     // If no processes running (except the shell) and no extra tabs, just close
     if (processesRunning.count() == 0 && openTabs < 2) {
         return true;
     }
 
     // NOTE: Some, if not all, of the below KWindowSystem calls are only
     //       implemented under x11 (KDE4.8 kdelibs/kdeui/windowmanagement).
 
     // make sure the window is shown on current desktop and is not minimized
     KWindowSystem::setOnDesktop(winId(), KWindowSystem::currentDesktop());
     if (isMinimized()) {
         KWindowSystem::unminimizeWindow(winId());
     }
     int result;
 
     if (!processesRunning.isEmpty()) {
         if (openTabs == 1) {
             result = KMessageBox::warningYesNoList(this,
                                                          i18ncp("@info",
                                                                 "There is a process running in this window. "
                                                                 "Do you still want to quit?",
                                                                 "There are %1 processes running in this window. "
                                                                 "Do you still want to quit?",
                                                                 processesRunning.count()),
                                                          processesRunning,
                                                          i18nc("@title", "Confirm Close"),
                                                          KGuiItem(i18nc("@action:button",
                                                                         "Close &Window"),
                                                                   QStringLiteral("window-close")),
                                                          KStandardGuiItem::cancel(),
                                                          // don't ask again name is wrong but I can't update.
                                                          // this is not about tabs anymore. it's about empty tabs *or* splits.
                                                          QStringLiteral("CloseAllTabs"));
             if (result == KMessageBox::No) // No is equal to cancel closing
                 result = KMessageBox::Cancel;
         } else {
             result = KMessageBox::warningYesNoCancelList(this,
                                                          i18ncp("@info",
                                                                 "There is a process running in this window. "
                                                                 "Do you still want to quit?",
                                                                 "There are %1 processes running in this window. "
                                                                 "Do you still want to quit?",
                                                                 processesRunning.count()),
                                                          processesRunning,
                                                          i18nc("@title", "Confirm Close"),
                                                          KGuiItem(i18nc("@action:button",
                                                                         "Close &Window"),
                                                                   QStringLiteral("window-close")),
                                                          KGuiItem(i18nc("@action:button",
                                                                         "Close Current &Tab"),
                                                                   QStringLiteral("tab-close")),
                                                          KStandardGuiItem::cancel(),
                                                          // don't ask again name is wrong but I can't update.
                                                          // this is not about tabs anymore. it's about empty tabs *or* splits.
                                                          QStringLiteral("CloseAllTabs"));
         }
     } else {
         result = KMessageBox::warningYesNoCancel(this,
                                                  i18nc("@info",
                                                        "There are %1 open terminals in this window. "
                                                        "Do you still want to quit?",
                                                        openTabs),
                                                  i18nc("@title", "Confirm Close"),
                                                  KGuiItem(i18nc("@action:button", "Close &Window"),
                                                           QStringLiteral("window-close")),
                                                  KGuiItem(i18nc("@action:button",
                                                                 "Close Current &Tab"),
                                                           QStringLiteral("tab-close")),
                                                  KStandardGuiItem::cancel(),
                                                  // don't ask again name is wrong but I can't update.
                                                  // this is not about tabs anymore. it's about empty tabs *or* splits.
                                                  QStringLiteral("CloseAllEmptyTabs"));
     }
 
     switch (result) {
     case KMessageBox::Yes:
         return true;
     case KMessageBox::No:
         if ((!_pluggedController.isNull()) && (!_pluggedController->session().isNull())) {
             if (!(_pluggedController->session()->closeInNormalWay())) {
                 if (_pluggedController->confirmForceClose()) {
                     _pluggedController->session()->closeInForceWay();
                 }
             }
         }
         return false;
     case KMessageBox::Cancel:
         return false;
     }
 
     return true;
 }
 
 void MainWindow::saveProperties(KConfigGroup &group)
 {
     _viewManager->saveSessions(group);
 }
 
 void MainWindow::readProperties(const KConfigGroup &group)
 {
     _viewManager->restoreSessions(group);
 }
 
 void MainWindow::saveGlobalProperties(KConfig *config)
 {
     SessionManager::instance()->saveSessions(config);
 }
 
 void MainWindow::readGlobalProperties(KConfig *config)
 {
     SessionManager::instance()->restoreSessions(config);
 }
 
 void MainWindow::syncActiveShortcuts(KActionCollection *dest, const KActionCollection *source)
 {
     const QList<QAction *> actionsList = source->actions();
     for (QAction *qAction : actionsList) {
         if (QAction *destQAction = dest->action(qAction->objectName())) {
             destQAction->setShortcut(qAction->shortcut());
         }
     }
 }
 
 void MainWindow::showShortcutsDialog()
 {
     KShortcutsDialog dialog(KShortcutsEditor::AllActions,
                             KShortcutsEditor::LetterShortcutsDisallowed, this);
 
     // add actions from this window and the current session controller
     const QList<KXMLGUIClient *> clientsList = guiFactory()->clients();
     for (KXMLGUIClient *client : clientsList) {
         dialog.addCollection(client->actionCollection());
     }
 
     if (dialog.configure()) {
         // sync shortcuts for non-session actions (defined in "konsoleui.rc") in other main windows
         const QList<QWidget *> widgets = QApplication::topLevelWidgets();
         for (QWidget *mainWindowWidget : widgets) {
             auto *mainWindow = qobject_cast<MainWindow *>(mainWindowWidget);
             if ((mainWindow != nullptr) && mainWindow != this) {
                 syncActiveShortcuts(mainWindow->actionCollection(), actionCollection());
             }
         }
         // sync shortcuts for session actions (defined in "sessionui.rc") in other session controllers.
         // Controllers which are currently plugged in (ie. their actions are part of the current menu)
         // must be updated immediately via syncActiveShortcuts().  Other controllers will be updated
         // when they are plugged into a main window.
         const QSet<SessionController *> allControllers = SessionController::allControllers();
         for (SessionController *controller : allControllers) {
             controller->reloadXML();
             if ((controller->factory() != nullptr) && controller != _pluggedController) {
                 syncActiveShortcuts(controller->actionCollection(), _pluggedController->actionCollection());
             }
         }
     }
 }
 
 void MainWindow::newFromProfile(const Profile::Ptr &profile)
 {
     createSession(profile, activeSessionDir());
 }
 
 void MainWindow::showManageProfilesDialog()
 {
     showSettingsDialog(true);
 }
 
 void MainWindow::showSettingsDialog(const bool showProfilePage)
 {
     static ConfigurationDialog *confDialog = nullptr;
     if (confDialog != nullptr) {
         confDialog->show();
         return;
     }
 
     confDialog = new ConfigurationDialog(this, KonsoleSettings::self());
 
     const QString generalPageName = i18nc("@title Preferences page name", "General");
     auto *generalPage = new KPageWidgetItem(new GeneralSettings(confDialog), generalPageName);
     generalPage->setIcon(QIcon::fromTheme(QStringLiteral("utilities-terminal")));
     confDialog->addPage(generalPage, true);
 
     const QString profilePageName = i18nc("@title Preferences page name", "Profiles");
     auto profilePage = new KPageWidgetItem(new ProfileSettings(confDialog), profilePageName);
     profilePage->setIcon(QIcon::fromTheme(QStringLiteral("preferences-system-profiles")));
     confDialog->addPage(profilePage, true);
 
     const QString tabBarPageName = i18nc("@title Preferences page name", "Tab Bar");
     auto tabBarPage = new KPageWidgetItem(new TabBarSettings(confDialog), tabBarPageName);
     tabBarPage->setIcon(QIcon::fromTheme(QStringLiteral("system-run")));
     confDialog->addPage(tabBarPage, true);
 
     const QString temporaryFilesPageName = i18nc("@title Preferences page name", "Temporary Files");
     auto temporaryFilesPage = new KPageWidgetItem(new TemporaryFilesSettings(confDialog), temporaryFilesPageName);
     temporaryFilesPage->setIcon(QIcon::fromTheme(QStringLiteral("folder-temp")));
     confDialog->addPage(temporaryFilesPage, true);
 
     if (showProfilePage) {
         confDialog->setCurrentPage(profilePage);
     }
 
     confDialog->show();
 }
 
 void MainWindow::applyKonsoleSettings()
 {
     setMenuBarInitialVisibility(KonsoleSettings::showMenuBarByDefault());
     setRemoveWindowTitleBarAndFrame(KonsoleSettings::removeWindowTitleBarAndFrame());
     if (KonsoleSettings::allowMenuAccelerators()) {
         restoreMenuAccelerators();
     } else {
         removeMenuAccelerators();
     }
 
     _viewManager->activeContainer()->setNavigationBehavior(KonsoleSettings::newTabBehavior());
     setAutoSaveSettings(QStringLiteral("MainWindow"), KonsoleSettings::saveGeometryOnExit());
     updateWindowCaption();
 }
 
 void MainWindow::activateMenuBar()
 {
     const QList<QAction *> menuActions = menuBar()->actions();
 
     if (menuActions.isEmpty()) {
         return;
     }
 
     // Show menubar if it is hidden at the moment
     if (menuBar()->isHidden()) {
         menuBar()->setVisible(true);
         _toggleMenuBarAction->setChecked(true);
     }
 
     // First menu action should be 'File'
     QAction *menuAction = menuActions.first();
 
     // TODO: Handle when menubar is top level (MacOS)
     menuBar()->setActiveAction(menuAction);
 }
 
 void MainWindow::configureNotifications()
 {
     KNotifyConfigWidget::configure(this);
 }
 
 void MainWindow::setBlur(bool blur)
 {
     if (_pluggedController.isNull()) {
         return;
     }
 
     if (!_pluggedController->isKonsolePart()) {
         KWindowEffects::enableBlurBehind(winId(), blur);
     }
 }
 
 void MainWindow::setMenuBarInitialVisibility(bool visible)
 {
     _menuBarInitialVisibility = visible;
 }
 
 void MainWindow::setRemoveWindowTitleBarAndFrame(bool frameless)
 {
     Qt::WindowFlags newFlags = frameless ? Qt::FramelessWindowHint : Qt::Window;
 
     // The window is not yet visible
     if (!isVisible()) {
         setWindowFlags(newFlags);
 
     // The window is visible and the setting changed
     } else if (windowFlags().testFlag(Qt::FramelessWindowHint) != frameless) {
         const auto oldGeometry = saveGeometry();
         // This happens for every Konsole window. It depends on
         // the fact that every window is processed in single thread
         const auto oldActiveWindow = KWindowSystem::activeWindow();
 
         setWindowFlags(newFlags);
 
         // The setWindowFlags() has hidden the window. Show it again
         // with previous geometry
         restoreGeometry(oldGeometry);
         setVisible(true);
         KWindowSystem::activateWindow(oldActiveWindow);
     }
 }
 
 void MainWindow::showEvent(QShowEvent *event)
 {
     // Make sure the 'initial' visibility is applied only once.
     if (!_menuBarInitialVisibilityApplied) {
         // the initial visibility of menubar should be applied at this last
         // moment. Otherwise, the initial visibility will be determined by
         // what KMainWindow has automatically stored in konsolerc, but not by
         // what users has explicitly configured .
         menuBar()->setVisible(_menuBarInitialVisibility);
         _toggleMenuBarAction->setChecked(_menuBarInitialVisibility);
         _menuBarInitialVisibilityApplied = true;
         if (!KonsoleSettings::saveGeometryOnExit()) {
             resize(sizeHint());
         }
     }
 
     // Call parent method
     KXmlGuiWindow::showEvent(event);
 }
 
 void MainWindow::triggerAction(const QString &name) const
 {
     if (auto action = actionCollection()->action(name)) {
         if (action->isEnabled()) {
             action->trigger();
         }
     }
 }
 
 bool MainWindow::eventFilter(QObject *obj, QEvent *event)
 {
     if (!_pluggedController.isNull() && obj == _pluggedController->view()) {
         switch(event->type()) {
             case QEvent::MouseButtonPress:
             case QEvent::MouseButtonDblClick:
             switch(static_cast<QMouseEvent*>(event)->button()) {
                 case Qt::ForwardButton:
                     triggerAction(QStringLiteral("next-view"));
                     break;
                 case Qt::BackButton:
                     triggerAction(QStringLiteral("previous-view"));
                     break;
                 default: ;
             }
             default: ;
         }
     }
 
     return KXmlGuiWindow::eventFilter(obj, event);
 }
 
 bool MainWindow::focusNextPrevChild(bool)
 {
     // In stand-alone konsole, always disable implicit focus switching
     // through 'Tab' and 'Shift+Tab'
     //
     // Kpart is another different story
     return false;
 }
diff --git a/src/ProcessInfo.cpp b/src/ProcessInfo.cpp
index 7196dc1f..aa61a41f 100644
--- a/src/ProcessInfo.cpp
+++ b/src/ProcessInfo.cpp
@@ -1,1196 +1,1201 @@
 /*
     Copyright 2007-2008 by Robert Knight <robertknight@gmail.countm>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Config
 #include "config-konsole.h"
 
 // Own
 #include "ProcessInfo.h"
 
 // Unix
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <unistd.h>
 #include <pwd.h>
 #include <sys/param.h>
 #include <cerrno>
 
 // Qt
 #include <QDir>
 #include <QFileInfo>
 #include <QTextStream>
 #include <QStringList>
 #include <QHostInfo>
 
 // KDE
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KUser>
 
 #if defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD) || defined(Q_OS_MACOS)
 #include <sys/sysctl.h>
 #endif
 
 #if defined(Q_OS_MACOS)
 #include <libproc.h>
 #include <qplatformdefs.h>
 #endif
 
 #if defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
 #include <sys/types.h>
 #include <sys/user.h>
 #include <sys/syslimits.h>
 #   if defined(Q_OS_FREEBSD)
 #   include <libutil.h>
 #   include <sys/param.h>
 #   include <sys/queue.h>
 #   endif
 #endif
 
 using namespace Konsole;
 
 ProcessInfo::ProcessInfo(int pid) :
     _fields(ARGUMENTS)     // arguments
     // are currently always valid,
     // they just return an empty
     // vector / map respectively
     // if no arguments
     // have been explicitly set
     ,
     _pid(pid),
     _parentPid(0),
     _foregroundPid(0),
     _userId(0),
     _lastError(NoError),
     _name(QString()),
     _userName(QString()),
     _userHomeDir(QString()),
     _currentDir(QString()),
     _userNameRequired(true),
     _arguments(QVector<QString>())
 {
 }
 
 ProcessInfo::Error ProcessInfo::error() const
 {
     return _lastError;
 }
 
 void ProcessInfo::setError(Error error)
 {
     _lastError = error;
 }
 
 void ProcessInfo::update()
 {
     readCurrentDir(_pid);
 }
 
 QString ProcessInfo::validCurrentDir() const
 {
     bool ok = false;
 
     // read current dir, if an error occurs try the parent as the next
     // best option
     int currentPid = parentPid(&ok);
     QString dir = currentDir(&ok);
     while (!ok && currentPid != 0) {
         ProcessInfo *current = ProcessInfo::newInstance(currentPid);
         current->update();
         currentPid = current->parentPid(&ok);
         dir = current->currentDir(&ok);
         delete current;
     }
 
     return dir;
 }
 
 QSet<QString> ProcessInfo::_commonDirNames;
 
 QSet<QString> ProcessInfo::commonDirNames()
 {
     static bool forTheFirstTime = true;
 
     if (forTheFirstTime) {
         const KSharedConfigPtr &config = KSharedConfig::openConfig();
         const KConfigGroup &configGroup = config->group("ProcessInfo");
-        // Once Qt5.14+ is the mininum, change to use range constructors
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
+        // Need to make a local copy so the begin() and end() point to the same QList
+        const QStringList commonDirsList = configGroup.readEntry("CommonDirNames", QStringList());
+        _commonDirNames = QSet<QString>(commonDirsList.begin(), commonDirsList.end());
+#else
         _commonDirNames = QSet<QString>::fromList(configGroup.readEntry("CommonDirNames", QStringList()));
+#endif
 
         forTheFirstTime = false;
     }
 
     return _commonDirNames;
 }
 
 QString ProcessInfo::formatShortDir(const QString &input) const
 {
     if(input == QStringLiteral("/")) {
         return QStringLiteral("/");
     }
 
     QString result;
 
     const QStringList &parts = input.split(QDir::separator());
 
     QSet<QString> dirNamesToShorten = commonDirNames();
 
     QListIterator<QString> iter(parts);
     iter.toBack();
 
     // go backwards through the list of the path's parts
     // adding abbreviations of common directory names
     // and stopping when we reach a dir name which is not
     // in the commonDirNames set
     while (iter.hasPrevious()) {
         const QString &part = iter.previous();
 
         if (dirNamesToShorten.contains(part)) {
             result.prepend(QDir::separator() + part[0]);
         } else {
             result.prepend(part);
             break;
         }
     }
 
     return result;
 }
 
 QVector<QString> ProcessInfo::arguments(bool *ok) const
 {
     *ok = _fields.testFlag(ARGUMENTS);
 
     return _arguments;
 }
 
 bool ProcessInfo::isValid() const
 {
     return _fields.testFlag(PROCESS_ID);
 }
 
 int ProcessInfo::pid(bool *ok) const
 {
     *ok = _fields.testFlag(PROCESS_ID);
 
     return _pid;
 }
 
 int ProcessInfo::parentPid(bool *ok) const
 {
     *ok = _fields.testFlag(PARENT_PID);
 
     return _parentPid;
 }
 
 int ProcessInfo::foregroundPid(bool *ok) const
 {
     *ok = _fields.testFlag(FOREGROUND_PID);
 
     return _foregroundPid;
 }
 
 QString ProcessInfo::name(bool *ok) const
 {
     *ok = _fields.testFlag(NAME);
 
     return _name;
 }
 
 int ProcessInfo::userId(bool *ok) const
 {
     *ok = _fields.testFlag(UID);
 
     return _userId;
 }
 
 QString ProcessInfo::userName() const
 {
     return _userName;
 }
 
 QString ProcessInfo::userHomeDir() const
 {
     return _userHomeDir;
 }
 
 QString ProcessInfo::localHost()
 {
     return QHostInfo::localHostName();
 }
 
 void ProcessInfo::setPid(int pid)
 {
     _pid = pid;
     _fields |= PROCESS_ID;
 }
 
 void ProcessInfo::setUserId(int uid)
 {
     _userId = uid;
     _fields |= UID;
 }
 
 void ProcessInfo::setUserName(const QString &name)
 {
     _userName = name;
     setUserHomeDir();
 }
 
 void ProcessInfo::setUserHomeDir()
 {
     const QString &usersName = userName();
     if (!usersName.isEmpty()) {
         _userHomeDir = KUser(usersName).homeDir();
     } else {
         _userHomeDir = QDir::homePath();
     }
 }
 
 void ProcessInfo::setParentPid(int pid)
 {
     _parentPid = pid;
     _fields |= PARENT_PID;
 }
 
 void ProcessInfo::setForegroundPid(int pid)
 {
     _foregroundPid = pid;
     _fields |= FOREGROUND_PID;
 }
 
 void ProcessInfo::setUserNameRequired(bool need)
 {
     _userNameRequired = need;
 }
 
 bool ProcessInfo::userNameRequired() const
 {
     return _userNameRequired;
 }
 
 QString ProcessInfo::currentDir(bool *ok) const
 {
     if (ok != nullptr) {
         *ok = (_fields & CURRENT_DIR) != 0;
     }
 
     return _currentDir;
 }
 
 void ProcessInfo::setCurrentDir(const QString &dir)
 {
     _fields |= CURRENT_DIR;
     _currentDir = dir;
 }
 
 void ProcessInfo::setName(const QString &name)
 {
     _name = name;
     _fields |= NAME;
 }
 
 void ProcessInfo::addArgument(const QString &argument)
 {
     _arguments << argument;
 }
 
 void ProcessInfo::clearArguments()
 {
     _arguments.clear();
 }
 
 void ProcessInfo::setFileError(QFile::FileError error)
 {
     switch (error) {
     case QFile::PermissionsError:
         setError(ProcessInfo::PermissionsError);
         break;
     case QFile::NoError:
         setError(ProcessInfo::NoError);
         break;
     default:
         setError(ProcessInfo::UnknownError);
     }
 }
 
 //
 // ProcessInfo::newInstance() is way at the bottom so it can see all of the
 // implementations of the UnixProcessInfo abstract class.
 //
 
 NullProcessInfo::NullProcessInfo(int pid) :
     ProcessInfo(pid)
 {
 }
 
 void NullProcessInfo::readProcessInfo(int /*pid*/)
 {
 }
 
 bool NullProcessInfo::readCurrentDir(int /*pid*/)
 {
     return false;
 }
 
 void NullProcessInfo::readUserName()
 {
 }
 
 #if !defined(Q_OS_WIN)
 UnixProcessInfo::UnixProcessInfo(int pid) :
     ProcessInfo(pid)
 {
     setUserNameRequired(true);
 }
 
 void UnixProcessInfo::readProcessInfo(int pid)
 {
     // prevent _arguments from growing longer and longer each time this
     // method is called.
     clearArguments();
 
     if (readProcInfo(pid)) {
         readArguments(pid);
         readCurrentDir(pid);
 
         bool ok = false;
         const QString &processNameString = name(&ok);
 
         if (ok && processNameString == QLatin1String("sudo")) {
             //Append process name along with sudo
             const QVector<QString> &args = arguments(&ok);
 
             if (ok && args.size() > 1) {
                 setName(processNameString + QStringLiteral(" ") + args[1]);
             }
         }
     }
 }
 
 void UnixProcessInfo::readUserName()
 {
     bool ok = false;
     const int uid = userId(&ok);
     if (!ok) {
         return;
     }
 
     struct passwd passwdStruct;
     struct passwd *getpwResult;
     char *getpwBuffer;
     long getpwBufferSize;
     int getpwStatus;
 
     getpwBufferSize = sysconf(_SC_GETPW_R_SIZE_MAX);
     if (getpwBufferSize == -1) {
         getpwBufferSize = 16384;
     }
 
     getpwBuffer = new char[getpwBufferSize];
     if (getpwBuffer == nullptr) {
         return;
     }
     getpwStatus = getpwuid_r(uid, &passwdStruct, getpwBuffer, getpwBufferSize, &getpwResult);
     if ((getpwStatus == 0) && (getpwResult != nullptr)) {
         setUserName(QLatin1String(passwdStruct.pw_name));
     } else {
         setUserName(QString());
         qWarning() << "getpwuid_r returned error : " << getpwStatus;
     }
     delete [] getpwBuffer;
 }
 
 #endif
 
 #if defined(Q_OS_LINUX)
 class LinuxProcessInfo : public UnixProcessInfo
 {
 public:
     LinuxProcessInfo(int pid) :
         UnixProcessInfo(pid)
     {
     }
 
 protected:
     bool readCurrentDir(int pid) override
     {
         char path_buffer[MAXPATHLEN + 1];
         path_buffer[MAXPATHLEN] = 0;
         QByteArray procCwd = QFile::encodeName(QStringLiteral("/proc/%1/cwd").arg(pid));
         const auto length = static_cast<int>(readlink(procCwd.constData(), path_buffer, MAXPATHLEN));
         if (length == -1) {
             setError(UnknownError);
             return false;
         }
 
         path_buffer[length] = '\0';
         QString path = QFile::decodeName(path_buffer);
 
         setCurrentDir(path);
         return true;
     }
 
 private:
     bool readProcInfo(int pid) override
     {
         // indicies of various fields within the process status file which
         // contain various information about the process
         const int PARENT_PID_FIELD = 3;
         const int PROCESS_NAME_FIELD = 1;
         const int GROUP_PROCESS_FIELD = 7;
 
         QString parentPidString;
         QString processNameString;
         QString foregroundPidString;
         QString uidLine;
         QString uidString;
         QStringList uidStrings;
 
         // For user id read process status file ( /proc/<pid>/status )
         //  Can not use getuid() due to it does not work for 'su'
         QFile statusInfo(QStringLiteral("/proc/%1/status").arg(pid));
         if (statusInfo.open(QIODevice::ReadOnly)) {
             QTextStream stream(&statusInfo);
             QString statusLine;
             do {
                 statusLine = stream.readLine();
                 if (statusLine.startsWith(QLatin1String("Uid:"))) {
                     uidLine = statusLine;
                 }
             } while (!statusLine.isNull() && uidLine.isNull());
 
             uidStrings << uidLine.split(QLatin1Char('\t'), QString::SkipEmptyParts);
             // Must be 5 entries: 'Uid: %d %d %d %d' and
             // uid string must be less than 5 chars (uint)
             if (uidStrings.size() == 5) {
                 uidString = uidStrings[1];
             }
             if (uidString.size() > 5) {
                 uidString.clear();
             }
 
             bool ok = false;
             const int uid = uidString.toInt(&ok);
             if (ok) {
                 setUserId(uid);
             }
             // This will cause constant opening of /etc/passwd
             if (userNameRequired()) {
                 readUserName();
                 setUserNameRequired(false);
             }
         } else {
             setFileError(statusInfo.error());
             return false;
         }
 
         // read process status file ( /proc/<pid/stat )
         //
         // the expected file format is a list of fields separated by spaces, using
         // parentheses to escape fields such as the process name which may itself contain
         // spaces:
         //
         // FIELD FIELD (FIELD WITH SPACES) FIELD FIELD
         //
         QFile processInfo(QStringLiteral("/proc/%1/stat").arg(pid));
         if (processInfo.open(QIODevice::ReadOnly)) {
             QTextStream stream(&processInfo);
             const QString &data = stream.readAll();
 
             int stack = 0;
             int field = 0;
             int pos = 0;
 
             while (pos < data.count()) {
                 QChar c = data[pos];
 
                 if (c == QLatin1Char('(')) {
                     stack++;
                 } else if (c == QLatin1Char(')')) {
                     stack--;
                 } else if (stack == 0 && c == QLatin1Char(' ')) {
                     field++;
                 } else {
                     switch (field) {
                     case PARENT_PID_FIELD:
                         parentPidString.append(c);
                         break;
                     case PROCESS_NAME_FIELD:
                         processNameString.append(c);
                         break;
                     case GROUP_PROCESS_FIELD:
                         foregroundPidString.append(c);
                         break;
                     }
                 }
 
                 pos++;
             }
         } else {
             setFileError(processInfo.error());
             return false;
         }
 
         // check that data was read successfully
         bool ok = false;
         const int foregroundPid = foregroundPidString.toInt(&ok);
         if (ok) {
             setForegroundPid(foregroundPid);
         }
 
         const int parentPid = parentPidString.toInt(&ok);
         if (ok) {
             setParentPid(parentPid);
         }
 
         if (!processNameString.isEmpty()) {
             setName(processNameString);
         }
 
         // update object state
         setPid(pid);
 
         return ok;
     }
 
     bool readArguments(int pid) override
     {
         // read command-line arguments file found at /proc/<pid>/cmdline
         // the expected format is a list of strings delimited by null characters,
         // and ending in a double null character pair.
 
         QFile argumentsFile(QStringLiteral("/proc/%1/cmdline").arg(pid));
         if (argumentsFile.open(QIODevice::ReadOnly)) {
             QTextStream stream(&argumentsFile);
             const QString &data = stream.readAll();
 
             const QStringList &argList = data.split(QLatin1Char('\0'));
 
             for (const QString &entry : argList) {
                 if (!entry.isEmpty()) {
                     addArgument(entry);
                 }
             }
         } else {
             setFileError(argumentsFile.error());
         }
 
         return true;
     }
 };
 
 #elif defined(Q_OS_FREEBSD)
 class FreeBSDProcessInfo : public UnixProcessInfo
 {
 public:
     FreeBSDProcessInfo(int pid) :
         UnixProcessInfo(pid)
     {
     }
 
 protected:
     bool readCurrentDir(int pid) override
     {
 #if defined(HAVE_OS_DRAGONFLYBSD)
         char buf[PATH_MAX];
         int managementInfoBase[4];
         size_t len;
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC;
         managementInfoBase[2] = KERN_PROC_CWD;
         managementInfoBase[3] = pid;
 
         len = sizeof(buf);
         if (sysctl(managementInfoBase, 4, buf, &len, NULL, 0) == -1) {
             return false;
         }
 
         setCurrentDir(QString::fromUtf8(buf));
 
         return true;
 #else
         int numrecords;
         struct kinfo_file *info = nullptr;
 
         info = kinfo_getfile(pid, &numrecords);
 
         if (!info) {
             return false;
         }
 
         for (int i = 0; i < numrecords; ++i) {
             if (info[i].kf_fd == KF_FD_TYPE_CWD) {
                 setCurrentDir(QString::fromUtf8(info[i].kf_path));
 
                 free(info);
                 return true;
             }
         }
 
         free(info);
         return false;
 #endif
     }
 
 private:
     bool readProcInfo(int pid) override
     {
         int managementInfoBase[4];
         size_t mibLength;
         struct kinfo_proc *kInfoProc;
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC;
         managementInfoBase[2] = KERN_PROC_PID;
         managementInfoBase[3] = pid;
 
         if (sysctl(managementInfoBase, 4, NULL, &mibLength, NULL, 0) == -1) {
             return false;
         }
 
         kInfoProc = new struct kinfo_proc [mibLength];
 
         if (sysctl(managementInfoBase, 4, kInfoProc, &mibLength, NULL, 0) == -1) {
             delete [] kInfoProc;
             return false;
         }
 
 #if defined(HAVE_OS_DRAGONFLYBSD)
         setName(QString::fromUtf8(kInfoProc->kp_comm));
         setPid(kInfoProc->kp_pid);
         setParentPid(kInfoProc->kp_ppid);
         setForegroundPid(kInfoProc->kp_pgid);
         setUserId(kInfoProc->kp_uid);
 #else
         setName(QString::fromUtf8(kInfoProc->ki_comm));
         setPid(kInfoProc->ki_pid);
         setParentPid(kInfoProc->ki_ppid);
         setForegroundPid(kInfoProc->ki_pgid);
         setUserId(kInfoProc->ki_uid);
 #endif
 
         readUserName();
 
         delete [] kInfoProc;
         return true;
     }
 
     bool readArguments(int pid) override
     {
         char args[ARG_MAX];
         int managementInfoBase[4];
         size_t len;
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC;
         managementInfoBase[2] = KERN_PROC_ARGS;
         managementInfoBase[3] = pid;
 
         len = sizeof(args);
         if (sysctl(managementInfoBase, 4, args, &len, NULL, 0) == -1) {
             return false;
         }
 
         // len holds the length of the string
         const QStringList argurments = QString::fromLocal8Bit(args, len).split(QLatin1Char('\u0000'));
         for (const QString &value : argurments) {
             if (!value.isEmpty()) {
                 addArgument(value);
             }
         }
 
         return true;
     }
 };
 
 #elif defined(Q_OS_OPENBSD)
 class OpenBSDProcessInfo : public UnixProcessInfo
 {
 public:
     OpenBSDProcessInfo(int pid) :
         UnixProcessInfo(pid)
     {
     }
 
 protected:
     bool readCurrentDir(int pid) override
     {
         char buf[PATH_MAX];
         int managementInfoBase[3];
         size_t len;
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC_CWD;
         managementInfoBase[2] = pid;
 
         len = sizeof(buf);
         if (::sysctl(managementInfoBase, 3, buf, &len, NULL, 0) == -1) {
             qWarning() << "sysctl() call failed with code" << errno;
             return false;
         }
 
         setCurrentDir(QString::fromUtf8(buf));
         return true;
     }
 
 private:
     bool readProcInfo(int pid) override
     {
         int managementInfoBase[6];
         size_t mibLength;
         struct kinfo_proc *kInfoProc;
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC;
         managementInfoBase[2] = KERN_PROC_PID;
         managementInfoBase[3] = pid;
         managementInfoBase[4] = sizeof(struct kinfo_proc);
         managementInfoBase[5] = 1;
 
         if (::sysctl(managementInfoBase, 6, NULL, &mibLength, NULL, 0) == -1) {
             qWarning() << "first sysctl() call failed with code" << errno;
             return false;
         }
 
         kInfoProc = (struct kinfo_proc *)malloc(mibLength);
 
         if (::sysctl(managementInfoBase, 6, kInfoProc, &mibLength, NULL, 0) == -1) {
             qWarning() << "second sysctl() call failed with code" << errno;
             free(kInfoProc);
             return false;
         }
 
         setName(kInfoProc->p_comm);
         setPid(kInfoProc->p_pid);
         setParentPid(kInfoProc->p_ppid);
         setForegroundPid(kInfoProc->p_tpgid);
         setUserId(kInfoProc->p_uid);
         setUserName(kInfoProc->p_login);
 
         free(kInfoProc);
         return true;
     }
 
     char **readProcArgs(int pid, int whatMib)
     {
         void *buf = NULL;
         void *nbuf;
         size_t len = 4096;
         int rc = -1;
         int managementInfoBase[4];
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC_ARGS;
         managementInfoBase[2] = pid;
         managementInfoBase[3] = whatMib;
 
         do {
             len *= 2;
             nbuf = realloc(buf, len);
             if (nbuf == NULL) {
                 break;
             }
 
             buf = nbuf;
             rc = ::sysctl(managementInfoBase, 4, buf, &len, NULL, 0);
             qWarning() << "sysctl() call failed with code" << errno;
         } while (rc == -1 && errno == ENOMEM);
 
         if (nbuf == NULL || rc == -1) {
             free(buf);
             return NULL;
         }
 
         return (char **)buf;
     }
 
     bool readArguments(int pid) override
     {
         char **argv;
 
         argv = readProcArgs(pid, KERN_PROC_ARGV);
         if (argv == NULL) {
             return false;
         }
 
         for (char **p = argv; *p != NULL; p++) {
             addArgument(QString(*p));
         }
         free(argv);
         return true;
     }
 };
 
 #elif defined(Q_OS_MACOS)
 class MacProcessInfo : public UnixProcessInfo
 {
 public:
     MacProcessInfo(int pid) :
         UnixProcessInfo(pid)
     {
     }
 
 protected:
     bool readCurrentDir(int pid) override
     {
         struct proc_vnodepathinfo vpi;
         const int nb = proc_pidinfo(pid, PROC_PIDVNODEPATHINFO, 0, &vpi, sizeof(vpi));
         if (nb == sizeof(vpi)) {
             setCurrentDir(QString::fromUtf8(vpi.pvi_cdir.vip_path));
             return true;
         }
         return false;
     }
 
 private:
     bool readProcInfo(int pid) override
     {
         int managementInfoBase[4];
         size_t mibLength;
         struct kinfo_proc *kInfoProc;
         QT_STATBUF statInfo;
 
         // Find the tty device of 'pid' (Example: /dev/ttys001)
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC;
         managementInfoBase[2] = KERN_PROC_PID;
         managementInfoBase[3] = pid;
 
         if (sysctl(managementInfoBase, 4, nullptr, &mibLength, nullptr, 0) == -1) {
             return false;
         } else {
             kInfoProc = new struct kinfo_proc [mibLength];
             if (sysctl(managementInfoBase, 4, kInfoProc, &mibLength, nullptr, 0) == -1) {
                 delete [] kInfoProc;
                 return false;
             } else {
                 const QString deviceNumber = QString::fromUtf8(devname(((&kInfoProc->kp_eproc)->e_tdev), S_IFCHR));
                 const QString fullDeviceName = QStringLiteral("/dev/")
                                                + deviceNumber.rightJustified(3, QLatin1Char('0'));
                 delete [] kInfoProc;
 
                 const QByteArray deviceName = fullDeviceName.toLatin1();
                 const char *ttyName = deviceName.data();
 
                 if (QT_STAT(ttyName, &statInfo) != 0) {
                     return false;
                 }
 
                 // Find all processes attached to ttyName
                 managementInfoBase[0] = CTL_KERN;
                 managementInfoBase[1] = KERN_PROC;
                 managementInfoBase[2] = KERN_PROC_TTY;
                 managementInfoBase[3] = statInfo.st_rdev;
 
                 mibLength = 0;
                 if (sysctl(managementInfoBase, sizeof(managementInfoBase) / sizeof(int), nullptr,
                            &mibLength, nullptr, 0) == -1) {
                     return false;
                 }
 
                 kInfoProc = new struct kinfo_proc [mibLength];
                 if (sysctl(managementInfoBase, sizeof(managementInfoBase) / sizeof(int), kInfoProc,
                            &mibLength, nullptr, 0) == -1) {
                     return false;
                 }
 
                 // The foreground program is the first one
                 setName(QString::fromUtf8(kInfoProc->kp_proc.p_comm));
 
                 delete [] kInfoProc;
             }
             setPid(pid);
         }
         return true;
     }
 
     bool readArguments(int pid) override
     {
         Q_UNUSED(pid)
         return false;
     }
 };
 
 #elif defined(Q_OS_SOLARIS)
 // The procfs structure definition requires off_t to be
 // 32 bits, which only applies if FILE_OFFSET_BITS=32.
 // Futz around here to get it to compile regardless,
 // although some of the structure sizes might be wrong.
 // Fortunately, the structures we actually use don't use
 // off_t, and we're safe.
 #if defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
 #undef _FILE_OFFSET_BITS
 #endif
 #include <procfs.h>
 
 class SolarisProcessInfo : public UnixProcessInfo
 {
 public:
     SolarisProcessInfo(int pid) :
         UnixProcessInfo(pid)
     {
     }
 
 protected:
     // FIXME: This will have the same issues as BKO 251351; the Linux
     // version uses readlink.
     bool readCurrentDir(int pid) override
     {
         QFileInfo info(QString("/proc/%1/path/cwd").arg(pid));
         const bool readable = info.isReadable();
 
         if (readable && info.isSymLink()) {
             setCurrentDir(info.symLinkTarget());
             return true;
         } else {
             if (!readable) {
                 setError(PermissionsError);
             } else {
                 setError(UnknownError);
             }
 
             return false;
         }
     }
 
 private:
     bool readProcInfo(int pid) override
     {
         QFile psinfo(QString("/proc/%1/psinfo").arg(pid));
         if (psinfo.open(QIODevice::ReadOnly)) {
             struct psinfo info;
             if (psinfo.read((char *)&info, sizeof(info)) != sizeof(info)) {
                 return false;
             }
 
             setParentPid(info.pr_ppid);
             setForegroundPid(info.pr_pgid);
             setName(info.pr_fname);
             setPid(pid);
 
             // Bogus, because we're treating the arguments as one single string
             info.pr_psargs[PRARGSZ - 1] = 0;
             addArgument(info.pr_psargs);
         }
         return true;
     }
 
     bool readArguments(int /*pid*/) override
     {
         // Handled in readProcInfo()
         return false;
     }
 };
 #endif
 
 SSHProcessInfo::SSHProcessInfo(const ProcessInfo &process) :
     _process(process),
     _user(QString()),
     _host(QString()),
     _port(QString()),
     _command(QString())
 {
     bool ok = false;
 
     // check that this is a SSH process
     const QString &name = _process.name(&ok);
 
     if (!ok || name != QLatin1String("ssh")) {
         if (!ok) {
             qWarning() << "Could not read process info";
         } else {
             qWarning() << "Process is not a SSH process";
         }
 
         return;
     }
 
     // read arguments
     const QVector<QString> &args = _process.arguments(&ok);
 
     // SSH options
     // these are taken from the SSH manual ( accessed via 'man ssh' )
 
     // options which take no arguments
     static const QString noArgumentOptions(QStringLiteral("1246AaCfgKkMNnqsTtVvXxYy"));
     // options which take one argument
     static const QString singleArgumentOptions(QStringLiteral("bcDeFIiLlmOopRSWw"));
 
     if (ok) {
         // find the username, host and command arguments
         //
         // the username/host is assumed to be the first argument
         // which is not an option
         // ( ie. does not start with a dash '-' character )
         // or an argument to a previous option.
         //
         // the command, if specified, is assumed to be the argument following
         // the username and host
         //
         // note that we skip the argument at index 0 because that is the
         // program name ( expected to be 'ssh' in this case )
         for (int i = 1; i < args.count(); i++) {
             // If this one is an option ...
             // Most options together with its argument will be skipped.
             if (args[i].startsWith(QLatin1Char('-'))) {
                 const QChar optionChar = (args[i].length() > 1) ? args[i][1] : QLatin1Char('\0');
                 // for example: -p2222 or -p 2222 ?
                 const bool optionArgumentCombined = args[i].length() > 2;
 
                 if (noArgumentOptions.contains(optionChar)) {
                     continue;
                 } else if (singleArgumentOptions.contains(optionChar)) {
                     QString argument;
                     if (optionArgumentCombined) {
                         argument = args[i].mid(2);
                     } else {
                         // Verify correct # arguments are given
                         if ((i + 1) < args.count()) {
                             argument = args[i + 1];
                         }
                         i++;
                     }
 
                     // support using `-l user` to specify username.
                     if (optionChar == QLatin1Char('l')) {
                         _user = argument;
                     }
                     // support using `-p port` to specify port.
                     else if (optionChar == QLatin1Char('p')) {
                         _port = argument;
                     }
 
                     continue;
                 }
             }
 
             // check whether the host has been found yet
             // if not, this must be the username/host argument
             if (_host.isEmpty()) {
                 // check to see if only a hostname is specified, or whether
                 // both a username and host are specified ( in which case they
                 // are separated by an '@' character:  username@host )
 
                 const int separatorPosition = args[i].indexOf(QLatin1Char('@'));
                 if (separatorPosition != -1) {
                     // username and host specified
                     _user = args[i].left(separatorPosition);
                     _host = args[i].mid(separatorPosition + 1);
                 } else {
                     // just the host specified
                     _host = args[i];
                 }
             } else {
                 // host has already been found, this must be part of the
                 // command arguments.
                 // Note this is not 100% correct.  If any of the above
                 // noArgumentOptions or singleArgumentOptions are found, this
                 // will not be correct (example ssh server top -i 50)
                 // Suggest putting ssh command in quotes
                 if (_command.isEmpty()) {
                     _command = args[i];
                 } else {
                     _command = _command + QLatin1Char(' ') + args[i];
                 }
             }
         }
     } else {
         qWarning() << "Could not read arguments";
 
         return;
     }
 }
 
 QString SSHProcessInfo::userName() const
 {
     return _user;
 }
 
 QString SSHProcessInfo::host() const
 {
     return _host;
 }
 
 QString SSHProcessInfo::port() const
 {
     return _port;
 }
 
 QString SSHProcessInfo::command() const
 {
     return _command;
 }
 
 QString SSHProcessInfo::format(const QString &input) const
 {
     QString output(input);
 
     // search for and replace known markers
     output.replace(QLatin1String("%u"), _user);
 
     // provide 'user@' if user is defined -- this makes nicer
     // remote tabs possible: "%U%h %c" => User@Host Command
     //                                 => Host Command
     // Depending on whether -l was passed to ssh (which is mostly not the
     // case due to ~/.ssh/config).
     if (_user.isEmpty()) {
         output.remove(QLatin1String("%U"));
     } else {
         output.replace(QLatin1String("%U"), _user + QLatin1Char('@'));
     }
 
     // test whether host is an ip address
     // in which case 'short host' and 'full host'
     // markers in the input string are replaced with
     // the full address
     struct in_addr address;
     const bool isIpAddress = inet_aton(_host.toLocal8Bit().constData(), &address) != 0;
     if (isIpAddress) {
         output.replace(QLatin1String("%h"), _host);
     } else {
         output.replace(QLatin1String("%h"), _host.left(_host.indexOf(QLatin1Char('.'))));
     }
 
     output.replace(QLatin1String("%H"), _host);
     output.replace(QLatin1String("%c"), _command);
 
     return output;
 }
 
 ProcessInfo *ProcessInfo::newInstance(int pid)
 {
     ProcessInfo *info;
 #if defined(Q_OS_LINUX)
     info = new LinuxProcessInfo(pid);
 #elif defined(Q_OS_SOLARIS)
     info = new SolarisProcessInfo(pid);
 #elif defined(Q_OS_MACOS)
     info = new MacProcessInfo(pid);
 #elif defined(Q_OS_FREEBSD)
     info = new FreeBSDProcessInfo(pid);
 #elif defined(Q_OS_OPENBSD)
     info = new OpenBSDProcessInfo(pid);
 #else
     info = new NullProcessInfo(pid);
 #endif
     info->readProcessInfo(pid);
     return info;
 }
diff --git a/src/ProfileManager.cpp b/src/ProfileManager.cpp
index db7f8b19..bde6e6b4 100644
--- a/src/ProfileManager.cpp
+++ b/src/ProfileManager.cpp
@@ -1,683 +1,683 @@
 /*
     This source file is part of Konsole, a terminal emulator.
 
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "ProfileManager.h"
 
 #include "konsoledebug.h"
 
 // Qt
 #include <QDir>
 #include <QFileInfo>
 #include <QList>
 #include <QString>
 
 // KDE
 #include <KSharedConfig>
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 
 // Konsole
 #include "ProfileReader.h"
 #include "ProfileWriter.h"
 
 using namespace Konsole;
 
 static bool profileIndexLessThan(const Profile::Ptr& p1, const Profile::Ptr& p2)
 {
     return p1->menuIndexAsInt() < p2->menuIndexAsInt();
 }
 
 static bool profileNameLessThan(const Profile::Ptr& p1, const Profile::Ptr& p2)
 {
     return QString::localeAwareCompare(p1->name(), p2->name()) < 0;
 }
 
 static bool stringLessThan(const QString& p1, const QString& p2)
 {
     return QString::localeAwareCompare(p1, p2) < 0;
 }
 
 static void sortByIndexProfileList(QList<Profile::Ptr>& list)
 {
     std::stable_sort(list.begin(), list.end(), profileIndexLessThan);
 }
 
 static void sortByNameProfileList(QList<Profile::Ptr>& list)
 {
     std::stable_sort(list.begin(), list.end(), profileNameLessThan);
 }
 
 ProfileManager::ProfileManager()
     : _profiles(QSet<Profile::Ptr>())
     , _favorites(QSet<Profile::Ptr>())
     , _defaultProfile(nullptr)
     , _fallbackProfile(nullptr)
     , _loadedAllProfiles(false)
     , _loadedFavorites(false)
     , _shortcuts(QMap<QKeySequence, ShortcutData>())
 {
     //load fallback profile
     _fallbackProfile = Profile::Ptr(new Profile());
     _fallbackProfile->useFallback();
     addProfile(_fallbackProfile);
 
     // lookup the default profile specified in <App>rc
     // for stand-alone Konsole, appConfig is just konsolerc
     // for konsolepart, appConfig might be yakuakerc, dolphinrc, katerc...
     KSharedConfigPtr appConfig = KSharedConfig::openConfig();
     KConfigGroup group = appConfig->group("Desktop Entry");
     QString defaultProfileFileName = group.readEntry("DefaultProfile", "");
 
     // if the hosting application of konsolepart does not specify its own
     // default profile, use the default profile of stand-alone Konsole.
     if (defaultProfileFileName.isEmpty()) {
         KSharedConfigPtr konsoleConfig = KSharedConfig::openConfig(QStringLiteral("konsolerc"));
         group = konsoleConfig->group("Desktop Entry");
         defaultProfileFileName = group.readEntry("DefaultProfile", "");
     }
 
     _defaultProfile = _fallbackProfile;
     if (!defaultProfileFileName.isEmpty()) {
         // load the default profile
         const QString path = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("konsole/") + defaultProfileFileName);
 
         if (!path.isEmpty()) {
             Profile::Ptr profile = loadProfile(path);
             if (profile) {
                 _defaultProfile = profile;
             }
         }
     }
 
     Q_ASSERT(_profiles.count() > 0);
     Q_ASSERT(_defaultProfile);
 
     // get shortcuts and paths of profiles associated with
     // them - this doesn't load the shortcuts themselves,
     // that is done on-demand.
     loadShortcuts();
 }
 
 ProfileManager::~ProfileManager() = default;
 
 Q_GLOBAL_STATIC(ProfileManager, theProfileManager)
 ProfileManager* ProfileManager::instance()
 {
     return theProfileManager;
 }
 
 Profile::Ptr ProfileManager::loadProfile(const QString& shortPath)
 {
     // the fallback profile has a 'special' path name, "FALLBACK/"
     if (shortPath == _fallbackProfile->path()) {
         return _fallbackProfile;
     }
 
     QString path = shortPath;
 
     // add a suggested suffix and relative prefix if missing
     QFileInfo fileInfo(path);
 
     if (fileInfo.isDir()) {
         return Profile::Ptr();
     }
 
     if (fileInfo.suffix() != QLatin1String("profile")) {
         path.append(QLatin1String(".profile"));
     }
     if (fileInfo.path().isEmpty() || fileInfo.path() == QLatin1String(".")) {
         path.prepend(QLatin1String("konsole") + QDir::separator());
     }
 
     // if the file is not an absolute path, look it up
     if (!fileInfo.isAbsolute()) {
         path = QStandardPaths::locate(QStandardPaths::GenericDataLocation, path);
     }
 
     // if the file is not found, return immediately
     if (path.isEmpty()) {
         return Profile::Ptr();
     }
 
     // check that we have not already loaded this profile
     for (const Profile::Ptr &profile : qAsConst(_profiles)) {
         if (profile->path() == path) {
             return profile;
         }
     }
 
     // guard to prevent problems if a profile specifies itself as its parent
     // or if there is recursion in the "inheritance" chain
     // (eg. two profiles, A and B, specifying each other as their parents)
     static QStack<QString> recursionGuard;
     PopStackOnExit<QString> popGuardOnExit(recursionGuard);
 
     if (recursionGuard.contains(path)) {
         qCDebug(KonsoleDebug) << "Ignoring attempt to load profile recursively from" << path;
         return _fallbackProfile;
     } else {
         recursionGuard.push(path);
     }
 
     // load the profile
     ProfileReader reader;
 
     Profile::Ptr newProfile = Profile::Ptr(new Profile(fallbackProfile()));
     newProfile->setProperty(Profile::Path, path);
 
     QString parentProfilePath;
     bool result = reader.readProfile(path, newProfile, parentProfilePath);
 
     if (!parentProfilePath.isEmpty()) {
         Profile::Ptr parentProfile = loadProfile(parentProfilePath);
         newProfile->setParent(parentProfile);
     }
 
     if (!result) {
         qCDebug(KonsoleDebug) << "Could not load profile from " << path;
         return Profile::Ptr();
     } else if (newProfile->name().isEmpty()) {
         qCWarning(KonsoleDebug) << path << " does not have a valid name, ignoring.";
         return Profile::Ptr();
     } else {
         addProfile(newProfile);
         return newProfile;
     }
 }
 QStringList ProfileManager::availableProfilePaths() const
 {
     ProfileReader reader;
 
     QStringList paths;
     paths += reader.findProfiles();
 
     std::stable_sort(paths.begin(), paths.end(), stringLessThan);
 
     return paths;
 }
 
 QStringList ProfileManager::availableProfileNames() const
 {
     QStringList names;
 
     const QList<Profile::Ptr> allProfiles = ProfileManager::instance()->allProfiles();
     for (const Profile::Ptr &profile : allProfiles) {
         if (!profile->isHidden()) {
             names.push_back(profile->name());
         }
     }
 
     std::stable_sort(names.begin(), names.end(), stringLessThan);
 
     return names;
 }
 
 void ProfileManager::loadAllProfiles()
 {
     if (_loadedAllProfiles) {
         return;
     }
 
     const QStringList& paths = availableProfilePaths();
     for (const QString &path : paths) {
         loadProfile(path);
     }
 
     _loadedAllProfiles = true;
 }
 
 void ProfileManager::sortProfiles(QList<Profile::Ptr>& list)
 {
     QList<Profile::Ptr> lackingIndices;
     QList<Profile::Ptr> havingIndices;
 
     for (const auto & i : list) {
         // dis-regard the fallback profile
         if (i->path() == _fallbackProfile->path()) {
             continue;
         }
 
         if (i->menuIndexAsInt() == 0) {
             lackingIndices.append(i);
         } else {
             havingIndices.append(i);
         }
     }
 
     // sort by index
     sortByIndexProfileList(havingIndices);
 
     // sort alphabetically those w/o an index
     sortByNameProfileList(lackingIndices);
 
     // Put those with indices in sequential order w/o any gaps
     int i = 0;
     for (i = 0; i < havingIndices.size(); ++i) {
         Profile::Ptr tempProfile = havingIndices.at(i);
         tempProfile->setProperty(Profile::MenuIndex, QString::number(i + 1));
         havingIndices.replace(i, tempProfile);
     }
     // Put those w/o indices in sequential order
     for (int j = 0; j < lackingIndices.size(); ++j) {
         Profile::Ptr tempProfile = lackingIndices.at(j);
         tempProfile->setProperty(Profile::MenuIndex, QString::number(j + 1 + i));
         lackingIndices.replace(j, tempProfile);
     }
 
     // combine the 2 list: first those who had indices
     list.clear();
     list.append(havingIndices);
     list.append(lackingIndices);
 }
 
 void ProfileManager::saveSettings()
 {
     // save default profile
     saveDefaultProfile();
 
     // save shortcuts
     saveShortcuts();
 
     // save favorites
     saveFavorites();
 
     // ensure default/favorites/shortcuts settings are synced into disk
     KSharedConfigPtr appConfig = KSharedConfig::openConfig();
     appConfig->sync();
 }
 
 QList<Profile::Ptr> ProfileManager::sortedFavorites()
 {
-    // Once Qt5.14+ is the mininum, change to use range constructors
-    QList<Profile::Ptr> favorites = findFavorites().toList();
+    QList<Profile::Ptr> favorites = findFavorites().values();
 
     sortProfiles(favorites);
     return favorites;
 }
 
 QList<Profile::Ptr> ProfileManager::allProfiles()
 {
     loadAllProfiles();
 
-    // Once Qt5.14+ is the mininum, change to use range constructors
-    return _profiles.toList();
+    return _profiles.values();
 }
 
 QList<Profile::Ptr> ProfileManager::loadedProfiles() const
 {
-    // Once Qt5.14+ is the mininum, change to use range constructors
-    return _profiles.toList();
+    return _profiles.values();
 }
 
 Profile::Ptr ProfileManager::defaultProfile() const
 {
     return _defaultProfile;
 }
 Profile::Ptr ProfileManager::fallbackProfile() const
 {
     return _fallbackProfile;
 }
 
 QString ProfileManager::saveProfile(const Profile::Ptr &profile)
 {
     ProfileWriter writer;
 
     QString newPath = writer.getPath(profile);
 
     if (!writer.writeProfile(newPath, profile)) {
         KMessageBox::sorry(nullptr,
                            i18n("Konsole does not have permission to save this profile to %1", newPath));
     }
 
     return newPath;
 }
 
 void ProfileManager::changeProfile(Profile::Ptr profile,
                                    QHash<Profile::Property, QVariant> propertyMap, bool persistent)
 {
     Q_ASSERT(profile);
 
     const QString origPath = profile->path();
 
     // never save a profile with empty name into disk!
     persistent = persistent && !profile->name().isEmpty();
 
     Profile::Ptr newProfile;
 
     // If we are asked to store the fallback profile (which has an
     // invalid path by design), we reset the path to an empty string
     // which will make the profile writer automatically generate a
     // proper path.
     if (persistent && profile->path() == _fallbackProfile->path()) {
 
         // Generate a new name, so it is obvious what is actually built-in
         // in the profile manager
         QStringList existingProfileNames;
         const QList<Profile::Ptr> profiles = allProfiles();
         for (const Profile::Ptr &existingProfile : profiles) {
             existingProfileNames.append(existingProfile->name());
         }
 
         int nameSuffix = 1;
         QString newName;
         QString newTranslatedName;
         do {
             newName = QStringLiteral("Profile ") + QString::number(nameSuffix);
             newTranslatedName = i18nc("The default name of a profile", "Profile #%1", nameSuffix);
             // TODO: remove the # above and below - too many issues
             newTranslatedName.remove(QLatin1Char('#'));
             nameSuffix++;
         } while (existingProfileNames.contains(newName));
 
         newProfile = Profile::Ptr(new Profile(ProfileManager::instance()->fallbackProfile()));
         newProfile->clone(profile, true);
         newProfile->setProperty(Profile::UntranslatedName, newName);
         newProfile->setProperty(Profile::Name, newTranslatedName);
         newProfile->setProperty(Profile::MenuIndex, QStringLiteral("0"));
         newProfile->setHidden(false);
 
         addProfile(newProfile);
         setDefaultProfile(newProfile);
 
     } else {
         newProfile = profile;
     }
 
     // insert the changes into the existing Profile instance
     QListIterator<Profile::Property> iter(propertyMap.keys());
     while (iter.hasNext()) {
         const Profile::Property property = iter.next();
         newProfile->setProperty(property, propertyMap[property]);
     }
 
     // when changing a group, iterate through the profiles
     // in the group and call changeProfile() on each of them
     //
     // this is so that each profile in the group, the profile is
     // applied, a change notification is emitted and the profile
     // is saved to disk
     ProfileGroup::Ptr group = newProfile->asGroup();
     if (group) {
         const QList<Profile::Ptr> profiles = group->profiles();
         for (const Profile::Ptr &groupProfile : profiles) {
             changeProfile(groupProfile, propertyMap, persistent);
         }
         return;
     }
 
     // save changes to disk, unless the profile is hidden, in which case
     // it has no file on disk
     if (persistent && !newProfile->isHidden()) {
         newProfile->setProperty(Profile::Path, saveProfile(newProfile));
         // if the profile was renamed, after saving the new profile
         // delete the old/redundant profile.
         // only do this if origPath is not empty, because it's empty
         // when creating a new profile, this works around a bug where
         // the newly created profile appears twice in the ProfileSettings
         // dialog
         if (!origPath.isEmpty() && (newProfile->path() != origPath)) {
             // this is needed to include the old profile too
             _loadedAllProfiles = false;
            const QList<Profile::Ptr> availableProfiles = ProfileManager::instance()->allProfiles();
             for (const Profile::Ptr &oldProfile : availableProfiles) {
                 if (oldProfile->path() == origPath) {
                     // assign the same shortcut of the old profile to
                     // the newly renamed profile
                     const auto oldShortcut = shortcut(oldProfile);
                     if (deleteProfile(oldProfile)) {
                         setShortcut(newProfile, oldShortcut);
                     }
                 }
             }
         }
     }
 
     // notify the world about the change
     emit profileChanged(newProfile);
 }
 
 void ProfileManager::addProfile(const Profile::Ptr &profile)
 {
     if (_profiles.isEmpty()) {
         _defaultProfile = profile;
     }
 
     _profiles.insert(profile);
 
     emit profileAdded(profile);
 }
 
 bool ProfileManager::deleteProfile(Profile::Ptr profile)
 {
     bool wasDefault = (profile == defaultProfile());
 
     if (profile) {
         // try to delete the config file
         if (profile->isPropertySet(Profile::Path) && QFile::exists(profile->path())) {
             if (!QFile::remove(profile->path())) {
                 qCDebug(KonsoleDebug) << "Could not delete profile: " << profile->path()
                            << "The file is most likely in a directory which is read-only.";
 
                 return false;
             }
         }
 
         // remove from favorites, profile list, shortcut list etc.
         setFavorite(profile, false);
         setShortcut(profile, QKeySequence());
         _profiles.remove(profile);
 
         // mark the profile as hidden so that it does not show up in the
         // Manage Profiles dialog and is not saved to disk
         profile->setHidden(true);
     }
 
     // If we just deleted the default profile, replace it with the first
     // profile in the list.
     if (wasDefault) {
         const QList<Profile::Ptr> existingProfiles = allProfiles();
         setDefaultProfile(existingProfiles.at(0));
     }
 
     emit profileRemoved(profile);
 
     return true;
 }
 
 void ProfileManager::setDefaultProfile(const Profile::Ptr &profile)
 {
     Q_ASSERT(_profiles.contains(profile));
 
     _defaultProfile = profile;
 }
 
 void ProfileManager::saveDefaultProfile()
 {
     QString path = _defaultProfile->path();
     ProfileWriter writer;
 
     if (path.isEmpty()) {
         path = writer.getPath(_defaultProfile);
     }
 
     QFileInfo fileInfo(path);
 
     KSharedConfigPtr appConfig = KSharedConfig::openConfig();
     KConfigGroup group = appConfig->group("Desktop Entry");
     group.writeEntry("DefaultProfile", fileInfo.fileName());
 }
 
 QSet<Profile::Ptr> ProfileManager::findFavorites()
 {
     loadFavorites();
 
     return _favorites;
 }
 void ProfileManager::setFavorite(const Profile::Ptr &profile , bool favorite)
 {
     if (!_profiles.contains(profile)) {
         addProfile(profile);
     }
 
     if (favorite && !_favorites.contains(profile)) {
         _favorites.insert(profile);
         emit favoriteStatusChanged(profile, favorite);
     } else if (!favorite && _favorites.contains(profile)) {
         _favorites.remove(profile);
         emit favoriteStatusChanged(profile, favorite);
     }
 }
 void ProfileManager::loadShortcuts()
 {
     KSharedConfigPtr appConfig = KSharedConfig::openConfig();
     KConfigGroup shortcutGroup = appConfig->group("Profile Shortcuts");
 
     QMap<QString, QString> entries = shortcutGroup.entryMap();
 
     QMapIterator<QString, QString> iter(entries);
     while (iter.hasNext()) {
         iter.next();
 
         QKeySequence shortcut = QKeySequence::fromString(iter.key());
         QString profilePath = iter.value();
 
         ShortcutData data;
 
         // if the file is not an absolute path, look it up
         QFileInfo fileInfo(profilePath);
         if (!fileInfo.isAbsolute()) {
             profilePath = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("konsole/") + profilePath);
         }
 
         data.profilePath = profilePath;
         _shortcuts.insert(shortcut, data);
     }
 }
 
 QString ProfileManager::normalizePath(const QString& path) const {
     QFileInfo fileInfo(path);
     const QString location = QStandardPaths::locate(
             QStandardPaths::GenericDataLocation, QStringLiteral("konsole/") + fileInfo.fileName());
     return (!fileInfo.isAbsolute()) || location.isEmpty() ? path : fileInfo.fileName();
 }
 
 void ProfileManager::saveShortcuts()
 {
     KSharedConfigPtr appConfig = KSharedConfig::openConfig();
     KConfigGroup shortcutGroup = appConfig->group("Profile Shortcuts");
     shortcutGroup.deleteGroup();
 
     QMapIterator<QKeySequence, ShortcutData> iter(_shortcuts);
     while (iter.hasNext()) {
         iter.next();
         QString shortcutString = iter.key().toString();
         QString profileName = normalizePath(iter.value().profilePath);
         shortcutGroup.writeEntry(shortcutString, profileName);
     }
 }
 
 
 void ProfileManager::saveFavorites()
 {
     KSharedConfigPtr appConfig = KSharedConfig::openConfig();
     KConfigGroup favoriteGroup = appConfig->group("Favorite Profiles");
 
     QStringList paths;
     for (const Profile::Ptr &profile : qAsConst(_favorites)) {
         Q_ASSERT(_profiles.contains(profile) && profile);
         paths << normalizePath(profile->path());
     }
     favoriteGroup.writeEntry("Favorites", paths);
 }
 
 
 void ProfileManager::setShortcut(Profile::Ptr profile ,
                                  const QKeySequence& keySequence)
 {
     QKeySequence existingShortcut = shortcut(profile);
     _shortcuts.remove(existingShortcut);
 
     if (keySequence.isEmpty()) {
         return;
     }
 
     ShortcutData data;
     data.profileKey = profile;
     data.profilePath = profile->path();
     // TODO - This won't work if the profile doesn't
     // have a path yet
     _shortcuts.insert(keySequence, data);
 
     emit shortcutChanged(profile, keySequence);
 }
 void ProfileManager::loadFavorites()
 {
     if (_loadedFavorites) {
         return;
     }
 
     KSharedConfigPtr appConfig = KSharedConfig::openConfig();
     KConfigGroup favoriteGroup = appConfig->group("Favorite Profiles");
 
     QSet<QString> favoriteSet;
 
     if (favoriteGroup.hasKey("Favorites")) {
-        QStringList list = favoriteGroup.readEntry("Favorites", QStringList());
-        // Once Qt5.14+ is the mininum, change to use range constructors
+        const QStringList list = favoriteGroup.readEntry("Favorites", QStringList());
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
+        favoriteSet = QSet<QString>(list.begin(), list.end());
+#else
         favoriteSet = QSet<QString>::fromList(list);
+#endif
     }
 
     // look for favorites among those already loaded
     for (const Profile::Ptr &profile : qAsConst(_profiles)) {
         const QString& path = profile->path();
         if (favoriteSet.contains(path)) {
             _favorites.insert(profile);
             favoriteSet.remove(path);
         }
     }
     // load any remaining favorites
     for (const QString &favorite : qAsConst(favoriteSet)) {
         Profile::Ptr profile = loadProfile(favorite);
         if (profile) {
             _favorites.insert(profile);
         }
     }
 
     _loadedFavorites = true;
 }
 
 QKeySequence ProfileManager::shortcut(Profile::Ptr profile) const
 {
     QMapIterator<QKeySequence, ShortcutData> iter(_shortcuts);
     while (iter.hasNext()) {
         iter.next();
         if (iter.value().profileKey == profile
                 || iter.value().profilePath == profile->path()) {
             return iter.key();
         }
     }
 
     return QKeySequence();
 }
 
diff --git a/src/SessionController.cpp b/src/SessionController.cpp
index afb58cd0..13058759 100644
--- a/src/SessionController.cpp
+++ b/src/SessionController.cpp
@@ -1,1829 +1,1842 @@
 /*
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
     Copyright 2009 by Thomas Dreibholz <dreibh@iem.uni-due.de>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "SessionController.h"
 
 #include "ProfileManager.h"
 #include "konsoledebug.h"
 
 // Qt
 #include <QApplication>
 #include <QAction>
 #include <QList>
 #include <QMenu>
 #include <QKeyEvent>
 #include <QPrinter>
 #include <QPrintDialog>
 #include <QFileDialog>
 #include <QPainter>
 #include <QStandardPaths>
 #include <QUrl>
 #include <QIcon>
 
 // KDE
 #include <KActionMenu>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KRun>
 #include <KShell>
 #include <KToolInvocation>
 #include <KToggleAction>
 #include <KSelectAction>
 #include <KXmlGuiWindow>
 #include <KXMLGUIFactory>
 #include <KXMLGUIBuilder>
 #include <KUriFilter>
 #include <KStringHandler>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KCodecAction>
 
 // Konsole
 #include "EditProfileDialog.h"
 #include "CopyInputDialog.h"
 #include "Emulation.h"
 #include "Filter.h"
 #include "History.h"
 #include "HistorySizeDialog.h"
 #include "IncrementalSearchBar.h"
 #include "RenameTabDialog.h"
 #include "ScreenWindow.h"
 #include "Session.h"
 #include "ProfileList.h"
 #include "TerminalDisplay.h"
 #include "SessionManager.h"
 #include "Enumeration.h"
 #include "PrintOptions.h"
 #include "SaveHistoryTask.h"
 #include "SearchHistoryTask.h"
 
 // For Unix signal names
 #include <csignal>
 
 using namespace Konsole;
 
 // TODO - Replace the icon choices below when suitable icons for silence and
 // activity are available
 Q_GLOBAL_STATIC_WITH_ARGS(QIcon, _activityIcon, (QIcon::fromTheme(QLatin1String("dialog-information"))))
 Q_GLOBAL_STATIC_WITH_ARGS(QIcon, _silenceIcon, (QIcon::fromTheme(QLatin1String("dialog-information"))))
 Q_GLOBAL_STATIC_WITH_ARGS(QIcon, _bellIcon, (QIcon::fromTheme(QLatin1String("preferences-desktop-notification-bell"))))
 Q_GLOBAL_STATIC_WITH_ARGS(QIcon, _broadcastIcon, (QIcon::fromTheme(QLatin1String("emblem-important"))))
 
 QSet<SessionController*> SessionController::_allControllers;
 int SessionController::_lastControllerId;
 
 SessionController::SessionController(Session* session , TerminalDisplay* view, QObject* parent)
     : ViewProperties(parent)
     , KXMLGUIClient()
     , _session(session)
     , _view(view)
     , _copyToGroup(nullptr)
     , _profileList(nullptr)
     , _sessionIcon(QIcon())
     , _sessionIconName(QString())
     , _previousState(-1)
     , _searchFilter(nullptr)
     , _urlFilter(nullptr)
     , _fileFilter(nullptr)
     , _copyInputToAllTabsAction(nullptr)
     , _findAction(nullptr)
     , _findNextAction(nullptr)
     , _findPreviousAction(nullptr)
     , _interactionTimer(nullptr)
     , _searchStartLine(0)
     , _prevSearchResultLine(0)
     , _codecAction(nullptr)
     , _switchProfileMenu(nullptr)
     , _webSearchMenu(nullptr)
     , _listenForScreenWindowUpdates(false)
     , _preventClose(false)
     , _keepIconUntilInteraction(false)
     , _selectedText(QString())
     , _showMenuAction(nullptr)
     , _bookmarkValidProgramsToClear(QStringList())
     , _isSearchBarEnabled(false)
     , _editProfileDialog(nullptr)
     , _searchBar(view->searchBar())
 {
     Q_ASSERT(session);
     Q_ASSERT(view);
 
     // handle user interface related to session (menus etc.)
     if (isKonsolePart()) {
         setComponentName(QStringLiteral("konsole"), i18n("Konsole"));
         setXMLFile(QStringLiteral("partui.rc"));
         setupCommonActions();
     } else {
         setXMLFile(QStringLiteral("sessionui.rc"));
         setupCommonActions();
         setupExtraActions();
     }
 
     actionCollection()->addAssociatedWidget(view);
 
     const QList<QAction *> actionsList = actionCollection()->actions();
     for (QAction *action : actionsList) {
         action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     }
 
     setIdentifier(++_lastControllerId);
     sessionAttributeChanged();
 
     view->installEventFilter(this);
     view->setSessionController(this);
 
     // install filter on the view to highlight URLs and files
     updateFilterList(SessionManager::instance()->sessionProfile(_session));
 
     // listen for changes in session, we might need to change the enabled filters
     connect(ProfileManager::instance(), &Konsole::ProfileManager::profileChanged, this, &Konsole::SessionController::updateFilterList);
 
     // listen for session resize requests
     connect(_session.data(), &Konsole::Session::resizeRequest, this, &Konsole::SessionController::sessionResizeRequest);
 
     // listen for popup menu requests
     connect(_view.data(), &Konsole::TerminalDisplay::configureRequest, this, &Konsole::SessionController::showDisplayContextMenu);
 
     // move view to newest output when keystrokes occur
     connect(_view.data(), &Konsole::TerminalDisplay::keyPressedSignal, this, &Konsole::SessionController::trackOutput);
 
     // listen to activity / silence notifications from session
     connect(_session.data(), &Konsole::Session::stateChanged, this, &Konsole::SessionController::sessionStateChanged);
     // listen to title and icon changes
     connect(_session.data(), &Konsole::Session::sessionAttributeChanged, this, &Konsole::SessionController::sessionAttributeChanged);
     connect(_session.data(), &Konsole::Session::readOnlyChanged, this, &Konsole::SessionController::sessionReadOnlyChanged);
 
     connect(this, &Konsole::SessionController::tabRenamedByUser,  _session,  &Konsole::Session::tabTitleSetByUser);
 
     connect(_session.data() , &Konsole::Session::currentDirectoryChanged , this , &Konsole::SessionController::currentDirectoryChanged);
 
     // listen for color changes
     connect(_session.data(), &Konsole::Session::changeBackgroundColorRequest, _view.data(), &Konsole::TerminalDisplay::setBackgroundColor);
     connect(_session.data(), &Konsole::Session::changeForegroundColorRequest, _view.data(), &Konsole::TerminalDisplay::setForegroundColor);
 
     // update the title when the session starts
     connect(_session.data(), &Konsole::Session::started, this, &Konsole::SessionController::snapshot);
 
     // listen for output changes to set activity flag
     connect(_session->emulation(), &Konsole::Emulation::outputChanged, this, &Konsole::SessionController::fireActivity);
 
     // listen for detection of ZModem transfer
     connect(_session.data(), &Konsole::Session::zmodemDownloadDetected, this, &Konsole::SessionController::zmodemDownload);
     connect(_session.data(), &Konsole::Session::zmodemUploadDetected, this, &Konsole::SessionController::zmodemUpload);
 
     // listen for flow control status changes
     connect(_session.data(), &Konsole::Session::flowControlEnabledChanged, _view.data(), &Konsole::TerminalDisplay::setFlowControlWarningEnabled);
     _view->setFlowControlWarningEnabled(_session->flowControlEnabled());
 
     // take a snapshot of the session state every so often when
     // user activity occurs
     //
     // the timer is owned by the session so that it will be destroyed along
     // with the session
     _interactionTimer = new QTimer(_session);
     _interactionTimer->setSingleShot(true);
     _interactionTimer->setInterval(500);
     connect(_interactionTimer, &QTimer::timeout, this, &Konsole::SessionController::snapshot);
     connect(_view.data(), &Konsole::TerminalDisplay::focusGained, this, &Konsole::SessionController::interactionHandler);
     connect(_view.data(), &Konsole::TerminalDisplay::keyPressedSignal, this, &Konsole::SessionController::interactionHandler);
 
     // take a snapshot of the session state periodically in the background
     auto backgroundTimer = new QTimer(_session);
     backgroundTimer->setSingleShot(false);
     backgroundTimer->setInterval(2000);
     connect(backgroundTimer, &QTimer::timeout, this, &Konsole::SessionController::snapshot);
     backgroundTimer->start();
 
     // xterm '10;?' request
     connect(_session.data(), &Konsole::Session::getForegroundColor,
             this, &Konsole::SessionController::sendForegroundColor);
     // xterm '11;?' request
     connect(_session.data(), &Konsole::Session::getBackgroundColor,
             this, &Konsole::SessionController::sendBackgroundColor);
 
     _allControllers.insert(this);
 
     // A list of programs that accept Ctrl+C to clear command line used
     // before outputting bookmark.
     _bookmarkValidProgramsToClear << QStringLiteral("bash") << QStringLiteral("fish") << QStringLiteral("sh");
     _bookmarkValidProgramsToClear << QStringLiteral("tcsh") << QStringLiteral("zsh");
     setupSearchBar();
     _searchBar->setVisible(_isSearchBarEnabled);
 }
 
 SessionController::~SessionController()
 {
     _allControllers.remove(this);
 
     if (!_editProfileDialog.isNull()) {
         delete _editProfileDialog.data();
     }
     if(factory()) {
         factory()->removeClient(this);
     }
 }
 void SessionController::trackOutput(QKeyEvent* event)
 {
     Q_ASSERT(_view->screenWindow());
 
     // Qt has broken something, so we can't rely on just checking if certain
     // keys are passed as modifiers anymore.
     const int key = event->key();
     const bool shouldNotTriggerScroll =
         key == Qt::Key_Super_L      ||
         key == Qt::Key_Super_R      ||
         key == Qt::Key_Hyper_L      ||
         key == Qt::Key_Hyper_R      ||
         key == Qt::Key_Shift        ||
         key == Qt::Key_Control      ||
         key == Qt::Key_Meta         ||
         key == Qt::Key_Alt          ||
         key == Qt::Key_AltGr        ||
         key == Qt::Key_CapsLock     ||
         key == Qt::Key_NumLock      ||
         key == Qt::Key_ScrollLock;
 
 
     // Only jump to the bottom if the user actually typed something in,
     // not if the user e. g. just pressed a modifier.
     if (event->text().isEmpty() && ((event->modifiers() != 0u) || shouldNotTriggerScroll)) {
         return;
     }
 
     _view->screenWindow()->setTrackOutput(true);
 }
 void SessionController::interactionHandler()
 {
     // This flag is used to make sure those special icons indicating interest
     // events (activity/silence/bell?) remain in the tab until user interaction
     // happens. Otherwise, those special icons will quickly be replaced by
     // normal icon when ::snapshot() is triggered
     _keepIconUntilInteraction = false;
     _interactionTimer->start();
 }
 
 void SessionController::snapshot()
 {
     Q_ASSERT(!_session.isNull());
 
     QString title = _session->getDynamicTitle();
     title         = title.simplified();
 
     // Visualize that the session is broadcasting to others
     if ((_copyToGroup != nullptr) && _copyToGroup->sessions().count() > 1) {
         title.append(QLatin1Char('*'));
     }
 
     // use the fallback title if needed
     if (title.isEmpty()) {
         title = _session->title(Session::NameRole);
     }
 
     // apply new title
     _session->setTitle(Session::DisplayedTitleRole, title);
 
     // do not forget icon
     updateSessionIcon();
 }
 
 QString SessionController::currentDir() const
 {
     return _session->currentWorkingDirectory();
 }
 
 QUrl SessionController::url() const
 {
     return _session->getUrl();
 }
 
 void SessionController::rename()
 {
     renameSession();
 }
 
 void SessionController::openUrl(const QUrl& url)
 {
     // Clear shell's command line
     if (!_session->isForegroundProcessActive()
             && _bookmarkValidProgramsToClear.contains(_session->foregroundProcessName())) {
         _session->sendTextToTerminal(QChar(0x03), QLatin1Char('\n')); // Ctrl+C
     }
 
     // handle local paths
     if (url.isLocalFile()) {
         QString path = url.toLocalFile();
         _session->sendTextToTerminal(QStringLiteral("cd ") + KShell::quoteArg(path), QLatin1Char('\r'));
     } else if (url.scheme().isEmpty()) {
         // QUrl couldn't parse what the user entered into the URL field
         // so just dump it to the shell
         QString command = url.toDisplayString();
         if (!command.isEmpty()) {
             _session->sendTextToTerminal(command, QLatin1Char('\r'));
         }
     } else if (url.scheme() == QLatin1String("ssh")) {
         QString sshCommand = QStringLiteral("ssh ");
 
         if (url.port() > -1) {
             sshCommand += QStringLiteral("-p %1 ").arg(url.port());
         }
         if (!url.userName().isEmpty()) {
             sshCommand += (url.userName() + QLatin1Char('@'));
         }
         if (!url.host().isEmpty()) {
             sshCommand += url.host();
         }
         _session->sendTextToTerminal(sshCommand, QLatin1Char('\r'));
 
     } else if (url.scheme() == QLatin1String("telnet")) {
         QString telnetCommand = QStringLiteral("telnet ");
 
         if (!url.userName().isEmpty()) {
             telnetCommand += QStringLiteral("-l %1 ").arg(url.userName());
         }
         if (!url.host().isEmpty()) {
             telnetCommand += (url.host() + QLatin1Char(' '));
         }
         if (url.port() > -1) {
             telnetCommand += QString::number(url.port());
         }
 
         _session->sendTextToTerminal(telnetCommand, QLatin1Char('\r'));
 
     } else {
         //TODO Implement handling for other Url types
 
         KMessageBox::sorry(_view->window(),
                            i18n("Konsole does not know how to open the bookmark: ") +
                            url.toDisplayString());
 
         qCDebug(KonsoleDebug) << "Unable to open bookmark at url" << url << ", I do not know"
                    << " how to handle the protocol " << url.scheme();
     }
 }
 
 void SessionController::setupPrimaryScreenSpecificActions(bool use)
 {
     KActionCollection* collection = actionCollection();
     QAction* clearAction = collection->action(QStringLiteral("clear-history"));
     QAction* resetAction = collection->action(QStringLiteral("clear-history-and-reset"));
     QAction* selectAllAction = collection->action(QStringLiteral("select-all"));
     QAction* selectLineAction = collection->action(QStringLiteral("select-line"));
 
     // these actions are meaningful only when primary screen is used.
     clearAction->setEnabled(use);
     resetAction->setEnabled(use);
     selectAllAction->setEnabled(use);
     selectLineAction->setEnabled(use);
 }
 
 void SessionController::selectionChanged(const QString& selectedText)
 {
     _selectedText = selectedText;
     updateCopyAction(selectedText);
 }
 
 void SessionController::updateCopyAction(const QString& selectedText)
 {
     QAction* copyAction = actionCollection()->action(QStringLiteral("edit_copy"));
 
     // copy action is meaningful only when some text is selected.
     copyAction->setEnabled(!selectedText.isEmpty());
 }
 
 void SessionController::updateWebSearchMenu()
 {
     // reset
     _webSearchMenu->setVisible(false);
     _webSearchMenu->menu()->clear();
 
     if (_selectedText.isEmpty()) {
         return;
     }
 
     QString searchText = _selectedText;
     searchText = searchText.replace(QLatin1Char('\n'), QLatin1Char(' ')).replace(QLatin1Char('\r'), QLatin1Char(' ')).simplified();
 
     if (searchText.isEmpty()) {
         return;
     }
 
     KUriFilterData filterData(searchText);
     filterData.setSearchFilteringOptions(KUriFilterData::RetrievePreferredSearchProvidersOnly);
 
     if (KUriFilter::self()->filterSearchUri(filterData, KUriFilter::NormalTextFilter)) {
         const QStringList searchProviders = filterData.preferredSearchProviders();
         if (!searchProviders.isEmpty()) {
             _webSearchMenu->setText(i18n("Search for '%1' with",  KStringHandler::rsqueeze(searchText, 16)));
 
             QAction* action = nullptr;
 
             for (const QString &searchProvider : searchProviders) {
                 action = new QAction(searchProvider, _webSearchMenu);
                 action->setIcon(QIcon::fromTheme(filterData.iconNameForPreferredSearchProvider(searchProvider)));
                 action->setData(filterData.queryForPreferredSearchProvider(searchProvider));
                 connect(action, &QAction::triggered, this, &Konsole::SessionController::handleWebShortcutAction);
                 _webSearchMenu->addAction(action);
             }
 
             _webSearchMenu->addSeparator();
 
             action = new QAction(i18n("Configure Web Shortcuts..."), _webSearchMenu);
             action->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
             connect(action, &QAction::triggered, this, &Konsole::SessionController::configureWebShortcuts);
             _webSearchMenu->addAction(action);
 
             _webSearchMenu->setVisible(true);
         }
     }
 }
 
 void SessionController::handleWebShortcutAction()
 {
     auto * action = qobject_cast<QAction*>(sender());
     if (action == nullptr) {
         return;
     }
 
     KUriFilterData filterData(action->data().toString());
 
     if (KUriFilter::self()->filterUri(filterData, QStringList() << QStringLiteral("kurisearchfilter"))) {
         const QUrl& url = filterData.uri();
         new KRun(url, QApplication::activeWindow());
     }
 }
 
 void SessionController::configureWebShortcuts()
 {
     KToolInvocation::kdeinitExec(QStringLiteral("kcmshell5"), QStringList() << QStringLiteral("webshortcuts"));
 }
 
 void SessionController::sendSignal(QAction* action)
 {
     const auto signal = action->data().toInt();
     _session->sendSignal(signal);
 }
 
 void SessionController::sendForegroundColor()
 {
     const QColor c = _view->getForegroundColor();
     _session->reportForegroundColor(c);
 }
 
 void SessionController::sendBackgroundColor()
 {
     const QColor c = _view->getBackgroundColor();
     _session->reportBackgroundColor(c);
 }
 
 void SessionController::toggleReadOnly()
 {
     auto *action = qobject_cast<QAction*>(sender());
     if (action != nullptr) {
         bool readonly = !isReadOnly();
         _session->setReadOnly(readonly);
     }
 }
 
 bool SessionController::eventFilter(QObject* watched , QEvent* event)
 {
     if (event->type() == QEvent::FocusIn && watched == _view) {
         // notify the world that the view associated with this session has been focused
         // used by the view manager to update the title of the MainWindow widget containing the view
         emit focused(this);
 
         // when the view is focused, set bell events from the associated session to be delivered
         // by the focused view
 
         // first, disconnect any other views which are listening for bell signals from the session
         disconnect(_session.data(), &Konsole::Session::bellRequest, nullptr, nullptr);
         // second, connect the newly focused view to listen for the session's bell signal
         connect(_session.data(), &Konsole::Session::bellRequest, _view.data(), &Konsole::TerminalDisplay::bell);
 
         if ((_copyInputToAllTabsAction != nullptr) && _copyInputToAllTabsAction->isChecked()) {
             // A session with "Copy To All Tabs" has come into focus:
             // Ensure that newly created sessions are included in _copyToGroup!
             copyInputToAllTabs();
         }
     }
     return Konsole::ViewProperties::eventFilter(watched, event);
 }
 
 void SessionController::removeSearchFilter()
 {
     if (_searchFilter == nullptr) {
         return;
     }
 
     _view->filterChain()->removeFilter(_searchFilter);
     delete _searchFilter;
     _searchFilter = nullptr;
 }
 
 void SessionController::setupSearchBar()
 {
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::unhandledMovementKeyPressed, this, &Konsole::SessionController::movementKeyFromSearchBarReceived);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::closeClicked, this, &Konsole::SessionController::searchClosed);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchFromClicked, this, &Konsole::SessionController::searchFrom);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::findNextClicked, this, &Konsole::SessionController::findNextInHistory);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::findPreviousClicked, this, &Konsole::SessionController::findPreviousInHistory);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::highlightMatchesToggled , this , &Konsole::SessionController::highlightMatches);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::matchCaseToggled, this, &Konsole::SessionController::changeSearchMatch);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::matchRegExpToggled, this, &Konsole::SessionController::changeSearchMatch);
 }
 
 void SessionController::setShowMenuAction(QAction* action)
 {
     _showMenuAction = action;
 }
 
 void SessionController::setupCommonActions()
 {
     KActionCollection* collection = actionCollection();
 
     // Close Session
     QAction* action = collection->addAction(QStringLiteral("close-session"), this, SLOT(closeSession()));
     action->setText(i18n("&Close Session"));
 
     action->setIcon(QIcon::fromTheme(QStringLiteral("tab-close")));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_W);
 
     // Open Browser
     action = collection->addAction(QStringLiteral("open-browser"), this, SLOT(openBrowser()));
     action->setText(i18n("Open File Manager"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("system-file-manager")));
 
     // Copy and Paste
     action = KStandardAction::copy(this, SLOT(copy()), collection);
 #ifdef Q_OS_MACOS
     // Don't use the Konsole::ACCEL const here, we really want the Command key (Qt::META)
     // TODO: check what happens if we leave it to Qt to assign the default?
     collection->setDefaultShortcut(action, Qt::META + Qt::Key_C);
 #else
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_C);
 #endif
     // disabled at first, since nothing has been selected now
     action->setEnabled(false);
 
     action = KStandardAction::paste(this, SLOT(paste()), collection);
     QList<QKeySequence> pasteShortcut;
 #ifdef Q_OS_MACOS
     pasteShortcut.append(QKeySequence(Qt::META + Qt::Key_V));
     // No Insert key on Mac keyboards
 #else
     pasteShortcut.append(QKeySequence(Konsole::ACCEL + Qt::SHIFT + Qt::Key_V));
     pasteShortcut.append(QKeySequence(Qt::SHIFT + Qt::Key_Insert));
 #endif
     collection->setDefaultShortcuts(action, pasteShortcut);
 
     action = collection->addAction(QStringLiteral("paste-selection"), this, SLOT(pasteFromX11Selection()));
     action->setText(i18n("Paste Selection"));
 #ifdef Q_OS_MACOS
     collection->setDefaultShortcut(action, Qt::META + Qt::SHIFT + Qt::Key_V);
 #else
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_Insert);
 #endif
 
     _webSearchMenu = new KActionMenu(i18n("Web Search"), this);
     _webSearchMenu->setIcon(QIcon::fromTheme(QStringLiteral("preferences-web-browser-shortcuts")));
     _webSearchMenu->setVisible(false);
     collection->addAction(QStringLiteral("web-search"), _webSearchMenu);
 
 
     action = collection->addAction(QStringLiteral("select-all"), this, SLOT(selectAll()));
     action->setText(i18n("&Select All"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-select-all")));
 
     action = collection->addAction(QStringLiteral("select-line"), this, SLOT(selectLine()));
     action->setText(i18n("Select &Line"));
 
     action = KStandardAction::saveAs(this, SLOT(saveHistory()), collection);
     action->setText(i18n("Save Output &As..."));
 #ifdef Q_OS_MACOS
     action->setShortcut(QKeySequence(Qt::META + Qt::Key_S));
 #endif
 
     action = KStandardAction::print(this, SLOT(print_screen()), collection);
     action->setText(i18n("&Print Screen..."));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_P);
 
     action = collection->addAction(QStringLiteral("adjust-history"), this, SLOT(showHistoryOptions()));
     action->setText(i18n("Adjust Scrollback..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
 
     action = collection->addAction(QStringLiteral("clear-history"), this, SLOT(clearHistory()));
     action->setText(i18n("Clear Scrollback"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-clear-history")));
 
     action = collection->addAction(QStringLiteral("clear-history-and-reset"), this, SLOT(clearHistoryAndReset()));
     action->setText(i18n("Clear Scrollback and Reset"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-clear-history")));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_K);
 
     // Profile Options
     action = collection->addAction(QStringLiteral("edit-current-profile"), this, SLOT(editCurrentProfile()));
     action->setText(i18n("Edit Current Profile..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("document-properties")));
 
     _switchProfileMenu = new KActionMenu(i18n("Switch Profile"), this);
     collection->addAction(QStringLiteral("switch-profile"), _switchProfileMenu);
     connect(_switchProfileMenu->menu(), &QMenu::aboutToShow, this, &Konsole::SessionController::prepareSwitchProfileMenu);
 
     // History
     _findAction = KStandardAction::find(this, SLOT(searchBarEvent()), collection);
 
     _findNextAction = KStandardAction::findNext(this, SLOT(findNextInHistory()), collection);
     _findNextAction->setEnabled(false);
 
     _findPreviousAction = KStandardAction::findPrev(this, SLOT(findPreviousInHistory()), collection);
     _findPreviousAction->setEnabled(false);
 
 #ifdef Q_OS_MACOS
     collection->setDefaultShortcut(_findAction, Qt::META + Qt::Key_F);
     collection->setDefaultShortcut(_findNextAction, Qt::META + Qt::Key_G);
     collection->setDefaultShortcut(_findPreviousAction, Qt::META + Qt::SHIFT + Qt::Key_G);
 #else
     collection->setDefaultShortcut(_findAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_F);
     collection->setDefaultShortcut(_findNextAction, Qt::Key_F3);
     collection->setDefaultShortcut(_findPreviousAction, Qt::SHIFT + Qt::Key_F3);
 #endif
 
     // Character Encoding
     _codecAction = new KCodecAction(i18n("Set &Encoding"), this);
     _codecAction->setIcon(QIcon::fromTheme(QStringLiteral("character-set")));
     collection->addAction(QStringLiteral("set-encoding"), _codecAction);
     connect(_codecAction->menu(), &QMenu::aboutToShow, this, &Konsole::SessionController::updateCodecAction);
     connect(_codecAction,
             QOverload<QTextCodec*>::of(&KCodecAction::triggered), this,
             &Konsole::SessionController::changeCodec);
 
     // Read-only
     action = collection->addAction(QStringLiteral("view-readonly"), this, SLOT(toggleReadOnly()));
     action->setText(i18nc("@item:inmenu A read only (locked) session", "Read-only"));
     action->setCheckable(true);
     updateReadOnlyActionStates();
 }
 
 void SessionController::setupExtraActions()
 {
     KActionCollection* collection = actionCollection();
 
     // Rename Session
     QAction* action = collection->addAction(QStringLiteral("rename-session"), this, SLOT(renameSession()));
     action->setText(i18n("&Rename Tab..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-rename")));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::ALT + Qt::Key_S);
 
     // Copy input to ==> all tabs
     auto* copyInputToAllTabsAction = collection->add<KToggleAction>(QStringLiteral("copy-input-to-all-tabs"));
     copyInputToAllTabsAction->setText(i18n("&All Tabs in Current Window"));
     copyInputToAllTabsAction->setData(CopyInputToAllTabsMode);
     // this action is also used in other place, so remember it
     _copyInputToAllTabsAction = copyInputToAllTabsAction;
 
     // Copy input to ==> selected tabs
     auto* copyInputToSelectedTabsAction = collection->add<KToggleAction>(QStringLiteral("copy-input-to-selected-tabs"));
     copyInputToSelectedTabsAction->setText(i18n("&Select Tabs..."));
     collection->setDefaultShortcut(copyInputToSelectedTabsAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_Period);
     copyInputToSelectedTabsAction->setData(CopyInputToSelectedTabsMode);
 
     // Copy input to ==> none
     auto* copyInputToNoneAction = collection->add<KToggleAction>(QStringLiteral("copy-input-to-none"));
     copyInputToNoneAction->setText(i18nc("@action:inmenu Do not select any tabs", "&None"));
     collection->setDefaultShortcut(copyInputToNoneAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_Slash);
     copyInputToNoneAction->setData(CopyInputToNoneMode);
     copyInputToNoneAction->setChecked(true); // the default state
 
     // The "Copy Input To" submenu
     // The above three choices are represented as combo boxes
     auto* copyInputActions = collection->add<KSelectAction>(QStringLiteral("copy-input-to"));
     copyInputActions->setText(i18n("Copy Input To"));
     copyInputActions->addAction(copyInputToAllTabsAction);
     copyInputActions->addAction(copyInputToSelectedTabsAction);
     copyInputActions->addAction(copyInputToNoneAction);
     connect(copyInputActions,
             QOverload<QAction*>::of(&KSelectAction::triggered), this,
             &Konsole::SessionController::copyInputActionsTriggered);
 
     action = collection->addAction(QStringLiteral("zmodem-upload"), this, SLOT(zmodemUpload()));
     action->setText(i18n("&ZModem Upload..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("document-open")));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::ALT + Qt::Key_U);
 
     // Monitor
     KToggleAction* toggleAction = new KToggleAction(i18n("Monitor for &Activity"), this);
     collection->setDefaultShortcut(toggleAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_A);
     action = collection->addAction(QStringLiteral("monitor-activity"), toggleAction);
     connect(action, &QAction::toggled, this, &Konsole::SessionController::monitorActivity);
 
     toggleAction = new KToggleAction(i18n("Monitor for &Silence"), this);
     collection->setDefaultShortcut(toggleAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_I);
     action = collection->addAction(QStringLiteral("monitor-silence"), toggleAction);
     connect(action, &QAction::toggled, this, &Konsole::SessionController::monitorSilence);
 
     // Text Size
     action = collection->addAction(QStringLiteral("enlarge-font"), this, SLOT(increaseFontSize()));
     action->setText(i18n("Enlarge Font"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("format-font-size-more")));
     QList<QKeySequence> enlargeFontShortcut;
     enlargeFontShortcut.append(QKeySequence(Konsole::ACCEL + Qt::Key_Plus));
     enlargeFontShortcut.append(QKeySequence(Konsole::ACCEL + Qt::Key_Equal));
     collection->setDefaultShortcuts(action, enlargeFontShortcut);
 
     action = collection->addAction(QStringLiteral("shrink-font"), this, SLOT(decreaseFontSize()));
     action->setText(i18n("Shrink Font"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("format-font-size-less")));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::Key_Minus);
 
     action = collection->addAction(QStringLiteral("reset-font-size"), this, SLOT(resetFontSize()));
     action->setText(i18n("Reset Font Size"));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::ALT + Qt::Key_0);
 
     // Send signal
     auto* sendSignalActions = collection->add<KSelectAction>(QStringLiteral("send-signal"));
     sendSignalActions->setText(i18n("Send Signal"));
     connect(sendSignalActions,
             QOverload<QAction*>::of(&KSelectAction::triggered), this,
             &Konsole::SessionController::sendSignal);
 
     action = collection->addAction(QStringLiteral("sigstop-signal"));
     action->setText(i18n("&Suspend Task")   + QStringLiteral(" (STOP)"));
     action->setData(SIGSTOP);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigcont-signal"));
     action->setText(i18n("&Continue Task")  + QStringLiteral(" (CONT)"));
     action->setData(SIGCONT);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sighup-signal"));
     action->setText(i18n("&Hangup")         + QStringLiteral(" (HUP)"));
     action->setData(SIGHUP);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigint-signal"));
     action->setText(i18n("&Interrupt Task") + QStringLiteral(" (INT)"));
     action->setData(SIGINT);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigterm-signal"));
     action->setText(i18n("&Terminate Task") + QStringLiteral(" (TERM)"));
     action->setData(SIGTERM);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigkill-signal"));
     action->setText(i18n("&Kill Task")      + QStringLiteral(" (KILL)"));
     action->setData(SIGKILL);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigusr1-signal"));
     action->setText(i18n("User Signal &1")   + QStringLiteral(" (USR1)"));
     action->setData(SIGUSR1);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigusr2-signal"));
     action->setText(i18n("User Signal &2")   + QStringLiteral(" (USR2)"));
     action->setData(SIGUSR2);
     sendSignalActions->addAction(action);
 }
 
 void SessionController::switchProfile(const Profile::Ptr &profile)
 {
     SessionManager::instance()->setSessionProfile(_session, profile);
     updateFilterList(profile);
 }
 
 void SessionController::prepareSwitchProfileMenu()
 {
     if (_switchProfileMenu->menu()->isEmpty()) {
         _profileList = new ProfileList(false, this);
         connect(_profileList, &Konsole::ProfileList::profileSelected, this, &Konsole::SessionController::switchProfile);
     }
 
     _switchProfileMenu->menu()->clear();
     _switchProfileMenu->menu()->addActions(_profileList->actions());
 }
 void SessionController::updateCodecAction()
 {
     _codecAction->setCurrentCodec(QString::fromUtf8(_session->codec()));
 }
 
 void SessionController::changeCodec(QTextCodec* codec)
 {
     _session->setCodec(codec);
 }
 
 EditProfileDialog* SessionController::profileDialogPointer()
 {
     return _editProfileDialog.data();
 }
 
 void SessionController::editCurrentProfile()
 {
     // Searching for Edit profile dialog opened with the same profile
     for (SessionController *controller : qAsConst(_allControllers)) {
         if ( (controller->profileDialogPointer() != nullptr)
              && controller->profileDialogPointer()->isVisible()
              && (controller->profileDialogPointer()->lookupProfile()
                  == SessionManager::instance()->sessionProfile(_session)) ) {
             controller->profileDialogPointer()->close();
         }
     }
 
     // NOTE bug311270: For to prevent the crash, the profile must be reset.
     if (!_editProfileDialog.isNull()) {
         // exists but not visible
         delete _editProfileDialog.data();
     }
 
     _editProfileDialog = new EditProfileDialog(QApplication::activeWindow());
     _editProfileDialog.data()->setProfile(SessionManager::instance()->sessionProfile(_session));
     _editProfileDialog.data()->show();
 }
 
 void SessionController::renameSession()
 {
     const QString &sessionLocalTabTitleFormat = _session->tabTitleFormat(Session::LocalTabTitle);
     const QString &sessionRemoteTabTitleFormat = _session->tabTitleFormat(Session::RemoteTabTitle);
 
     QScopedPointer<RenameTabDialog> dialog(new RenameTabDialog(QApplication::activeWindow()));
     dialog->setTabTitleText(sessionLocalTabTitleFormat);
     dialog->setRemoteTabTitleText(sessionRemoteTabTitleFormat);
 
     if (_session->isRemote()) {
         dialog->focusRemoteTabTitleText();
     } else {
         dialog->focusTabTitleText();
     }
 
     QPointer<Session> guard(_session);
     int result = dialog->exec();
     if (guard.isNull()) {
         return;
     }
 
     if (result != 0) {
         const QString &tabTitle = dialog->tabTitleText();
         const QString &remoteTabTitle = dialog->remoteTabTitleText();
 
         if (tabTitle != sessionLocalTabTitleFormat) {
             _session->setTabTitleFormat(Session::LocalTabTitle, tabTitle);
             emit tabRenamedByUser(true);
             // trigger an update of the tab text
             snapshot();
         }
 
         if(remoteTabTitle != sessionRemoteTabTitleFormat) {
             _session->setTabTitleFormat(Session::RemoteTabTitle, remoteTabTitle);
             emit tabRenamedByUser(true);
             snapshot();
         }
     }
 }
 
 // This is called upon Menu->Close Sesssion and right-click on tab->Close Tab
 bool SessionController::confirmClose() const
 {
     if (_session->isForegroundProcessActive()) {
         QString title = _session->foregroundProcessName();
 
         // hard coded for now.  In future make it possible for the user to specify which programs
         // are ignored when considering whether to display a confirmation
         QStringList ignoreList;
         ignoreList << QString::fromUtf8(qgetenv("SHELL")).section(QLatin1Char('/'), -1);
         if (ignoreList.contains(title)) {
             return true;
         }
 
         QString question;
         if (title.isEmpty()) {
             question = i18n("A program is currently running in this session."
                             "  Are you sure you want to close it?");
         } else {
             question = i18n("The program '%1' is currently running in this session."
                             "  Are you sure you want to close it?", title);
         }
 
         int result = KMessageBox::warningYesNo(_view->window(),
                                                question,
                                                i18n("Confirm Close"),
                                                KStandardGuiItem::yes(),
                                                KStandardGuiItem::no(),
                                                QStringLiteral("CloseSingleTab"));
         return result == KMessageBox::Yes;
     }
     return true;
 }
 bool SessionController::confirmForceClose() const
 {
     if (_session->isRunning()) {
         QString title = _session->program();
 
         // hard coded for now.  In future make it possible for the user to specify which programs
         // are ignored when considering whether to display a confirmation
         QStringList ignoreList;
         ignoreList << QString::fromUtf8(qgetenv("SHELL")).section(QLatin1Char('/'), -1);
         if (ignoreList.contains(title)) {
             return true;
         }
 
         QString question;
         if (title.isEmpty()) {
             question = i18n("A program in this session would not die."
                             "  Are you sure you want to kill it by force?");
         } else {
             question = i18n("The program '%1' is in this session would not die."
                             "  Are you sure you want to kill it by force?", title);
         }
 
         int result = KMessageBox::warningYesNo(_view->window(), question, i18n("Confirm Close"));
         return result == KMessageBox::Yes;
     }
     return true;
 }
 void SessionController::closeSession()
 {
     if (_preventClose) {
         return;
     }
 
     if (confirmClose()) {
         if (_session->closeInNormalWay()) {
             return;
         } else if (confirmForceClose()) {
             if (_session->closeInForceWay()) {
                 return;
             } else {
                 qCDebug(KonsoleDebug) << "Konsole failed to close a session in any way.";
             }
         }
     }
 }
 
 // Trying to open a remote Url may produce unexpected results.
 // Therefore, if a remote url, open the user's home path.
 // TODO consider: 1) disable menu upon remote session
 //   2) transform url to get the desired result (ssh -> sftp, etc)
 void SessionController::openBrowser()
 {
     const QUrl currentUrl = url();
 
     if (currentUrl.isLocalFile()) {
         new KRun(currentUrl, QApplication::activeWindow(), true);
     } else {
         new KRun(QUrl::fromLocalFile(QDir::homePath()), QApplication::activeWindow(), true);
     }
 }
 
 void SessionController::copy()
 {
     _view->copyToClipboard();
 }
 
 void SessionController::paste()
 {
     _view->pasteFromClipboard();
 }
 void SessionController::pasteFromX11Selection()
 {
     _view->pasteFromX11Selection();
 }
 void SessionController::selectAll()
 {
     _view->selectAll();
 }
 void SessionController::selectLine()
 {
     _view->selectCurrentLine();
 }
 static const KXmlGuiWindow* findWindow(const QObject* object)
 {
     // Walk up the QObject hierarchy to find a KXmlGuiWindow.
     while (object != nullptr) {
         const auto* window = qobject_cast<const KXmlGuiWindow*>(object);
         if (window != nullptr) {
             return(window);
         }
         object = object->parent();
     }
     return(nullptr);
 }
 
 static bool hasTerminalDisplayInSameWindow(const Session* session, const KXmlGuiWindow* window)
 {
     // Iterate all TerminalDisplays of this Session ...
     const QList<TerminalDisplay *> views = session->views();
     for (const TerminalDisplay *terminalDisplay : views) {
         // ... and check whether a TerminalDisplay has the same
         // window as given in the parameter
         if (window == findWindow(terminalDisplay)) {
             return(true);
         }
     }
     return(false);
 }
 
 void SessionController::copyInputActionsTriggered(QAction* action)
 {
     const auto mode = action->data().toInt();
 
     switch (mode) {
     case CopyInputToAllTabsMode:
         copyInputToAllTabs();
         break;
     case CopyInputToSelectedTabsMode:
         copyInputToSelectedTabs();
         break;
     case CopyInputToNoneMode:
         copyInputToNone();
         break;
     default:
         Q_ASSERT(false);
     }
 }
 
 void SessionController::copyInputToAllTabs()
 {
     if (_copyToGroup == nullptr) {
         _copyToGroup = new SessionGroup(this);
     }
 
     // Find our window ...
     const KXmlGuiWindow* myWindow = findWindow(_view);
 
-    // Once Qt5.14+ is the mininum, change to use range constructors
-    QSet<Session*> group =
-        QSet<Session*>::fromList(SessionManager::instance()->sessions());
+    const QList<Session *> sessionsList = SessionManager::instance()->sessions();
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
+    QSet<Session*> group(sessionsList.begin(), sessionsList.end());
+#else
+    QSet<Session*> group = QSet<Session*>::fromList(sessionsList);
+#endif
     for (auto session : group) {
         // First, ensure that the session is removed
         // (necessary to avoid duplicates on addSession()!)
         _copyToGroup->removeSession(session);
 
         // Add current session if it is displayed our window
         if (hasTerminalDisplayInSameWindow(session, myWindow)) {
             _copyToGroup->addSession(session);
         }
     }
     _copyToGroup->setMasterStatus(_session, true);
     _copyToGroup->setMasterMode(SessionGroup::CopyInputToAll);
 
     snapshot();
 }
 
 void SessionController::copyInputToSelectedTabs()
 {
     if (_copyToGroup == nullptr) {
         _copyToGroup = new SessionGroup(this);
         _copyToGroup->addSession(_session);
         _copyToGroup->setMasterStatus(_session, true);
         _copyToGroup->setMasterMode(SessionGroup::CopyInputToAll);
     }
 
     QPointer<CopyInputDialog> dialog = new CopyInputDialog(_view);
     dialog->setMasterSession(_session);
 
-    // Once Qt5.14+ is the mininum, change to use range constructors
-    QSet<Session*> currentGroup = QSet<Session*>::fromList(_copyToGroup->sessions());
+    const QList<Session*> sessionsList = _copyToGroup->sessions();
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
+    QSet<Session*> currentGroup(sessionsList.begin(), sessionsList.end());
+#else
+    QSet<Session*> currentGroup = QSet<Session*>::fromList(sessionsList);
+#endif
+
     currentGroup.remove(_session);
 
     dialog->setChosenSessions(currentGroup);
 
     QPointer<Session> guard(_session);
     int result = dialog->exec();
     if (guard.isNull()) {
         return;
     }
 
     if (result == QDialog::Accepted) {
         QSet<Session*> newGroup = dialog->chosenSessions();
         newGroup.remove(_session);
 
         const QSet<Session *> completeGroup = newGroup | currentGroup;
         for (Session *session : completeGroup) {
             if (newGroup.contains(session) && !currentGroup.contains(session)) {
                 _copyToGroup->addSession(session);
             } else if (!newGroup.contains(session) && currentGroup.contains(session)) {
                 _copyToGroup->removeSession(session);
             }
         }
 
         _copyToGroup->setMasterStatus(_session, true);
         _copyToGroup->setMasterMode(SessionGroup::CopyInputToAll);
         snapshot();
     }
 }
 
 void SessionController::copyInputToNone()
 {
     if (_copyToGroup == nullptr) {      // No 'Copy To' is active
         return;
     }
 
     // Once Qt5.14+ is the mininum, change to use range constructors
-    QSet<Session*> group =
-        QSet<Session*>::fromList(SessionManager::instance()->sessions());
+    const QList<Session*> groupList = SessionManager::instance()->sessions();
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
+    QSet<Session*> group(groupList.begin(), groupList.end());
+#else
+    QSet<Session*> group = QSet<Session*>::fromList(groupList);
+#endif
+
     for (auto iterator : group) {
         Session* session = iterator;
 
         if (session != _session) {
             _copyToGroup->removeSession(iterator);
         }
     }
     delete _copyToGroup;
     _copyToGroup = nullptr;
     snapshot();
 }
 
 void SessionController::searchClosed()
 {
     _isSearchBarEnabled = false;
     searchHistory(false);
 }
 
 void SessionController::updateFilterList(Profile::Ptr profile)
 {
     if (profile != SessionManager::instance()->sessionProfile(_session)) {
         return;
     }
 
     bool underlineFiles = profile->underlineFilesEnabled();
 
     if (!underlineFiles && (_fileFilter != nullptr)) {
         _view->filterChain()->removeFilter(_fileFilter);
         delete _fileFilter;
         _fileFilter = nullptr;
     } else if (underlineFiles && (_fileFilter == nullptr)) {
         _fileFilter = new FileFilter(_session);
         _view->filterChain()->addFilter(_fileFilter);
     }
 
     bool underlineLinks = profile->underlineLinksEnabled();
     if (!underlineLinks && (_urlFilter != nullptr)) {
         _view->filterChain()->removeFilter(_urlFilter);
         delete _urlFilter;
         _urlFilter = nullptr;
     } else if (underlineLinks && (_urlFilter == nullptr)) {
         _urlFilter = new UrlFilter();
         _view->filterChain()->addFilter(_urlFilter);
     }
 }
 
 void SessionController::setSearchStartToWindowCurrentLine()
 {
     setSearchStartTo(-1);
 }
 
 void SessionController::setSearchStartTo(int line)
 {
     _searchStartLine = line;
     _prevSearchResultLine = line;
 }
 
 void SessionController::listenForScreenWindowUpdates()
 {
     if (_listenForScreenWindowUpdates) {
         return;
     }
 
     connect(_view->screenWindow(), &Konsole::ScreenWindow::outputChanged, this, &Konsole::SessionController::updateSearchFilter);
     connect(_view->screenWindow(), &Konsole::ScreenWindow::scrolled, this, &Konsole::SessionController::updateSearchFilter);
     connect(_view->screenWindow(),
             &Konsole::ScreenWindow::currentResultLineChanged, _view.data(),
             QOverload<>::of(&Konsole::TerminalDisplay::update));
 
     _listenForScreenWindowUpdates = true;
 }
 
 void SessionController::updateSearchFilter()
 {
     if ((_searchFilter != nullptr) && (!_searchBar.isNull())) {
         _view->processFilters();
     }
 }
 
 void SessionController::searchBarEvent()
 {
     QString selectedText = _view->screenWindow()->selectedText(Screen::PreserveLineBreaks | Screen::TrimLeadingWhitespace | Screen::TrimTrailingWhitespace);
     if (!selectedText.isEmpty()) {
         _searchBar->setSearchText(selectedText);
     }
 
     if (_searchBar->isVisible()) {
         _searchBar->focusLineEdit();
     } else {
         searchHistory(true);
         _isSearchBarEnabled = true;
     }
 }
 
 void SessionController::enableSearchBar(bool showSearchBar)
 {
     if (_searchBar.isNull()) {
         return;
     }
 
     if (showSearchBar && !_searchBar->isVisible()) {
         setSearchStartToWindowCurrentLine();
     }
 
     _searchBar->setVisible(showSearchBar);
     if (showSearchBar) {
         connect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchChanged, this, &Konsole::SessionController::searchTextChanged);
         connect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchReturnPressed, this, &Konsole::SessionController::findPreviousInHistory);
         connect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchShiftPlusReturnPressed, this, &Konsole::SessionController::findNextInHistory);
     } else {
         disconnect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchChanged, this,
                    &Konsole::SessionController::searchTextChanged);
         disconnect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchReturnPressed, this,
                    &Konsole::SessionController::findPreviousInHistory);
         disconnect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchShiftPlusReturnPressed, this,
                    &Konsole::SessionController::findNextInHistory);
         if ((!_view.isNull()) && (_view->screenWindow() != nullptr)) {
             _view->screenWindow()->setCurrentResultLine(-1);
         }
     }
 }
 
 
 bool SessionController::reverseSearchChecked() const
 {
     Q_ASSERT(_searchBar);
 
     QBitArray options = _searchBar->optionsChecked();
     return options.at(IncrementalSearchBar::ReverseSearch);
 }
 
 QRegularExpression SessionController::regexpFromSearchBarOptions() const
 {
     QBitArray options = _searchBar->optionsChecked();
 
     QString text(_searchBar->searchText());
 
     QRegularExpression regExp;
     if (options.at(IncrementalSearchBar::RegExp)) {
         regExp.setPattern(text);
     } else {
         regExp.setPattern(QRegularExpression::escape(text));
     }
 
     if (!options.at(IncrementalSearchBar::MatchCase)) {
         regExp.setPatternOptions(QRegularExpression::CaseInsensitiveOption);
     }
 
     return regExp;
 }
 
 // searchHistory() may be called either as a result of clicking a menu item or
 // as a result of changing the search bar widget
 void SessionController::searchHistory(bool showSearchBar)
 {
     enableSearchBar(showSearchBar);
 
     if (!_searchBar.isNull()) {
         if (showSearchBar) {
             removeSearchFilter();
 
             listenForScreenWindowUpdates();
 
             _searchFilter = new RegExpFilter();
             _searchFilter->setRegExp(regexpFromSearchBarOptions());
             _view->filterChain()->addFilter(_searchFilter);
             _view->processFilters();
 
             setFindNextPrevEnabled(true);
         } else {
             setFindNextPrevEnabled(false);
 
             removeSearchFilter();
 
             _view->setFocus(Qt::ActiveWindowFocusReason);
         }
     }
 }
 
 void SessionController::setFindNextPrevEnabled(bool enabled)
 {
     _findNextAction->setEnabled(enabled);
     _findPreviousAction->setEnabled(enabled);
 }
 void SessionController::searchTextChanged(const QString& text)
 {
     Q_ASSERT(_view->screenWindow());
 
     if (_searchText == text) {
         return;
     }
 
     _searchText = text;
 
     if (text.isEmpty()) {
         _view->screenWindow()->clearSelection();
         _view->screenWindow()->scrollTo(_searchStartLine);
     }
 
     // update search.  this is called even when the text is
     // empty to clear the view's filters
     beginSearch(text , reverseSearchChecked() ? Enum::BackwardsSearch : Enum::ForwardsSearch);
 }
 void SessionController::searchCompleted(bool success)
 {
     _prevSearchResultLine = _view->screenWindow()->currentResultLine();
 
     if (!_searchBar.isNull()) {
         _searchBar->setFoundMatch(success);
     }
 }
 
 void SessionController::beginSearch(const QString& text, Enum::SearchDirection direction)
 {
     Q_ASSERT(_searchBar);
     Q_ASSERT(_searchFilter);
 
     QRegularExpression regExp = regexpFromSearchBarOptions();
     _searchFilter->setRegExp(regExp);
 
     if (_searchStartLine < 0 || _searchStartLine > _view->screenWindow()->lineCount()) {
         if (direction == Enum::ForwardsSearch) {
             setSearchStartTo(_view->screenWindow()->currentLine());
         } else {
             setSearchStartTo(_view->screenWindow()->currentLine() + _view->screenWindow()->windowLines());
         }
     }
 
     if (!regExp.pattern().isEmpty()) {
         _view->screenWindow()->setCurrentResultLine(-1);
         auto task = new SearchHistoryTask(this);
 
         connect(task, &Konsole::SearchHistoryTask::completed, this, &Konsole::SessionController::searchCompleted);
 
         task->setRegExp(regExp);
         task->setSearchDirection(direction);
         task->setAutoDelete(true);
         task->setStartLine(_searchStartLine);
         task->addScreenWindow(_session , _view->screenWindow());
         task->execute();
     } else if (text.isEmpty()) {
         searchCompleted(false);
     }
 
     _view->processFilters();
 }
 void SessionController::highlightMatches(bool highlight)
 {
     if (highlight) {
         _view->filterChain()->addFilter(_searchFilter);
         _view->processFilters();
     } else {
         _view->filterChain()->removeFilter(_searchFilter);
     }
 
     _view->update();
 }
 
 void SessionController::searchFrom()
 {
     Q_ASSERT(_searchBar);
     Q_ASSERT(_searchFilter);
 
     if (reverseSearchChecked()) {
         setSearchStartTo(_view->screenWindow()->lineCount());
     } else {
         setSearchStartTo(0);
     }
 
 
     beginSearch(_searchBar->searchText(), reverseSearchChecked() ? Enum::BackwardsSearch : Enum::ForwardsSearch);
 }
 void SessionController::findNextInHistory()
 {
     Q_ASSERT(_searchBar);
     Q_ASSERT(_searchFilter);
 
     setSearchStartTo(_prevSearchResultLine);
 
     beginSearch(_searchBar->searchText(), reverseSearchChecked() ? Enum::BackwardsSearch : Enum::ForwardsSearch);
 }
 void SessionController::findPreviousInHistory()
 {
     Q_ASSERT(_searchBar);
     Q_ASSERT(_searchFilter);
 
     setSearchStartTo(_prevSearchResultLine);
 
     beginSearch(_searchBar->searchText(), reverseSearchChecked() ? Enum::ForwardsSearch : Enum::BackwardsSearch);
 }
 void SessionController::changeSearchMatch()
 {
     Q_ASSERT(_searchBar);
     Q_ASSERT(_searchFilter);
 
     // reset Selection for new case match
     _view->screenWindow()->clearSelection();
     beginSearch(_searchBar->searchText(), reverseSearchChecked() ? Enum::BackwardsSearch : Enum::ForwardsSearch);
 }
 void SessionController::showHistoryOptions()
 {
     QScopedPointer<HistorySizeDialog> dialog(new HistorySizeDialog(QApplication::activeWindow()));
     const HistoryType& currentHistory = _session->historyType();
 
     if (currentHistory.isEnabled()) {
         if (currentHistory.isUnlimited()) {
             dialog->setMode(Enum::UnlimitedHistory);
         } else {
             dialog->setMode(Enum::FixedSizeHistory);
             dialog->setLineCount(currentHistory.maximumLineCount());
         }
     } else {
         dialog->setMode(Enum::NoHistory);
     }
 
     QPointer<Session> guard(_session);
     int result = dialog->exec();
     if (guard.isNull()) {
         return;
     }
 
     if (result != 0) {
         scrollBackOptionsChanged(dialog->mode(), dialog->lineCount());
     }
 }
 void SessionController::sessionResizeRequest(const QSize& size)
 {
     ////qDebug() << "View resize requested to " << size;
     _view->setSize(size.width(), size.height());
 }
 void SessionController::scrollBackOptionsChanged(int mode, int lines)
 {
     switch (mode) {
     case Enum::NoHistory:
         _session->setHistoryType(HistoryTypeNone());
         break;
     case Enum::FixedSizeHistory:
         _session->setHistoryType(CompactHistoryType(lines));
         break;
     case Enum::UnlimitedHistory:
         _session->setHistoryType(HistoryTypeFile());
         break;
     }
 }
 
 void SessionController::print_screen()
 {
     QPrinter printer;
 
     QPointer<QPrintDialog> dialog = new QPrintDialog(&printer, _view);
     auto options = new PrintOptions();
 
     dialog->setOptionTabs(QList<QWidget*>() << options);
     dialog->setWindowTitle(i18n("Print Shell"));
     connect(dialog.data(),
             QOverload<>::of(&QPrintDialog::accepted),
             options,
             &Konsole::PrintOptions::saveSettings);
     if (dialog->exec() != QDialog::Accepted) {
         return;
     }
 
     QPainter painter;
     painter.begin(&printer);
 
     KConfigGroup configGroup(KSharedConfig::openConfig(), "PrintOptions");
 
     if (configGroup.readEntry("ScaleOutput", true)) {
         double scale = qMin(printer.pageRect().width() / static_cast<double>(_view->width()),
                             printer.pageRect().height() / static_cast<double>(_view->height()));
         painter.scale(scale, scale);
     }
 
     _view->printContent(painter, configGroup.readEntry("PrinterFriendly", true));
 }
 
 void SessionController::saveHistory()
 {
     SessionTask* task = new SaveHistoryTask(this);
     task->setAutoDelete(true);
     task->addSession(_session);
     task->execute();
 }
 
 void SessionController::clearHistory()
 {
     _session->clearHistory();
     _view->updateImage();   // To reset view scrollbar
     _view->repaint();
 }
 
 void SessionController::clearHistoryAndReset()
 {
     Profile::Ptr profile = SessionManager::instance()->sessionProfile(_session);
     QByteArray name = profile->defaultEncoding().toUtf8();
 
     Emulation* emulation = _session->emulation();
     emulation->reset();
     _session->refresh();
     _session->setCodec(QTextCodec::codecForName(name));
     clearHistory();
 }
 
 void SessionController::increaseFontSize()
 {
     _view->increaseFontSize();
 }
 
 void SessionController::decreaseFontSize()
 {
     _view->decreaseFontSize();
 }
 
 void SessionController::resetFontSize()
 {
     _view->resetFontSize();
 }
 
 void SessionController::monitorActivity(bool monitor)
 {
     _session->setMonitorActivity(monitor);
 }
 void SessionController::monitorSilence(bool monitor)
 {
     _session->setMonitorSilence(monitor);
 }
 void SessionController::updateSessionIcon()
 {
     // If the default profile icon is being used, don't put it on the tab
     // Only show the icon if the user specifically chose one
     if (_session->iconName() == QStringLiteral("utilities-terminal")) {
         _sessionIconName = QString();
     } else {
         _sessionIconName = _session->iconName();
     }
     _sessionIcon = QIcon::fromTheme(_sessionIconName);
 
     // Visualize that the session is broadcasting to others
     if ((_copyToGroup != nullptr) && _copyToGroup->sessions().count() > 1) {
         // Master Mode: set different icon, to warn the user to be careful
         setIcon(*_broadcastIcon);
     } else {
         if (!_keepIconUntilInteraction) {
             // Not in Master Mode: use normal icon
             setIcon(_sessionIcon);
         }
     }
 }
 
 void SessionController::updateReadOnlyActionStates()
 {
     bool readonly = isReadOnly();
     QAction *readonlyAction = actionCollection()->action(QStringLiteral("view-readonly"));
     Q_ASSERT(readonlyAction != nullptr);
     readonlyAction->setIcon(QIcon::fromTheme(readonly ? QStringLiteral("object-locked") : QStringLiteral("object-unlocked")));
     readonlyAction->setChecked(readonly);
 
     auto updateActionState = [this, readonly](const QString &name) {
         QAction *action = actionCollection()->action(name);
         if (action != nullptr) {
             action->setEnabled(!readonly);
         }
     };
 
     updateActionState(QStringLiteral("edit_paste"));
     updateActionState(QStringLiteral("clear-history"));
     updateActionState(QStringLiteral("clear-history-and-reset"));
     updateActionState(QStringLiteral("edit-current-profile"));
     updateActionState(QStringLiteral("switch-profile"));
     updateActionState(QStringLiteral("adjust-history"));
     updateActionState(QStringLiteral("send-signal"));
     updateActionState(QStringLiteral("zmodem-upload"));
 
     _codecAction->setEnabled(!readonly);
 
     // Without the timer, when detaching a tab while the message widget is visible,
     // the size of the terminal becomes really small...
     QTimer::singleShot(0, this, [this, readonly]() {
         _view->updateReadOnlyState(readonly);
     });
 }
 
 bool SessionController::isReadOnly() const
 {
     if (!_session.isNull()) {
         return _session->isReadOnly();
     } else {
         return false;
     }
 }
 
 void SessionController::sessionAttributeChanged()
 {
     if (_sessionIconName != _session->iconName()) {
         updateSessionIcon();
     }
 
     QString title = _session->title(Session::DisplayedTitleRole);
 
     // special handling for the "%w" marker which is replaced with the
     // window title set by the shell
     title.replace(QLatin1String("%w"), _session->userTitle());
     // special handling for the "%#" marker which is replaced with the
     // number of the shell
     title.replace(QLatin1String("%#"), QString::number(_session->sessionId()));
 
     if (title.isEmpty()) {
         title = _session->title(Session::NameRole);
     }
 
     setTitle(title);
     emit rawTitleChanged();
 }
 
 void SessionController::sessionReadOnlyChanged() {
     // Trigger icon update
     sessionAttributeChanged();
 
     updateReadOnlyActionStates();
 
     // Update all views
     const QList<TerminalDisplay *> viewsList = session()->views();
     for (TerminalDisplay *terminalDisplay : viewsList) {
         if (terminalDisplay != _view.data()) {
             terminalDisplay->updateReadOnlyState(isReadOnly());
         }
     }
 }
 
 void SessionController::showDisplayContextMenu(const QPoint& position)
 {
     // needed to make sure the popup menu is available, even if a hosting
     // application did not merge our GUI.
     if (factory() == nullptr) {
         if (clientBuilder() == nullptr) {
             setClientBuilder(new KXMLGUIBuilder(_view));
         }
 
         auto factory = new KXMLGUIFactory(clientBuilder(), this);
         factory->addClient(this);
         ////qDebug() << "Created xmlgui factory" << factory;
     }
 
     QPointer<QMenu> popup = qobject_cast<QMenu*>(factory()->container(QStringLiteral("session-popup-menu"), this));
     if (!popup.isNull()) {
         updateReadOnlyActionStates();
 
         auto contentSeparator = new QAction(popup);
         contentSeparator->setSeparator(true);
 
         // prepend content-specific actions such as "Open Link", "Copy Email Address" etc.
         QSharedPointer<Filter::HotSpot> hotSpot = _view->filterActions(position);
         if (hotSpot) {
             popup->insertActions(popup->actions().value(0, nullptr), hotSpot->actions() << contentSeparator );
 
         }
 
         // always update this submenu before showing the context menu,
         // because the available search services might have changed
         // since the context menu is shown last time
         updateWebSearchMenu();
 
         _preventClose = true;
 
         if (_showMenuAction != nullptr) {
             if (  _showMenuAction->isChecked() ) {
                 popup->removeAction( _showMenuAction);
             } else {
                 popup->insertAction(_switchProfileMenu, _showMenuAction);
             }
         }
 
         // they are here.
         // qDebug() << popup->actions().indexOf(contentActions[0]) << popup->actions().indexOf(contentActions[1]) << popup->actions()[3];
         QAction* chosen = popup->exec(QCursor::pos());
 
         // check for validity of the pointer to the popup menu
         if (!popup.isNull()) {
             delete contentSeparator;
         }
 
         _preventClose = false;
 
         if ((chosen != nullptr) && chosen->objectName() == QLatin1String("close-session")) {
             chosen->trigger();
         }
     } else {
         qCDebug(KonsoleDebug) << "Unable to display popup menu for session"
                    << _session->title(Session::NameRole)
                    << ", no GUI factory available to build the popup.";
     }
 }
 
 void SessionController::movementKeyFromSearchBarReceived(QKeyEvent *event)
 {
     QCoreApplication::sendEvent(_view, event);
     setSearchStartToWindowCurrentLine();
 }
 
 void SessionController::sessionStateChanged(int state)
 {
     if (state == _previousState) {
         return;
     }
 
     if (state == NOTIFYACTIVITY) {
         setIcon(*_activityIcon);
         _keepIconUntilInteraction = true;
     } else if (state == NOTIFYSILENCE) {
         setIcon(*_silenceIcon);
         _keepIconUntilInteraction = true;
     } else if (state == NOTIFYBELL) {
         setIcon(*_bellIcon);
         _keepIconUntilInteraction = true;
     } else if (state == NOTIFYNORMAL) {
         updateSessionIcon();
     }
 
     _previousState = state;
 }
 
 void SessionController::zmodemDownload()
 {
     QString zmodem = QStandardPaths::findExecutable(QStringLiteral("rz"));
     if (zmodem.isEmpty()) {
         zmodem = QStandardPaths::findExecutable(QStringLiteral("lrz"));
     }
     if (!zmodem.isEmpty()) {
         const QString path = QFileDialog::getExistingDirectory(_view,
                 i18n("Save ZModem Download to..."),
                 QDir::homePath(),
                 QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
 
         if (!path.isEmpty()) {
             _session->startZModem(zmodem, path, QStringList());
             return;
         }
     } else {
         KMessageBox::error(_view,
                            i18n("<p>A ZModem file transfer attempt has been detected, "
                                 "but no suitable ZModem software was found on this system.</p>"
                                 "<p>You may wish to install the 'rzsz' or 'lrzsz' package.</p>"));
     }
     _session->cancelZModem();
 }
 
 void SessionController::zmodemUpload()
 {
     if (_session->isZModemBusy()) {
         KMessageBox::sorry(_view,
                            i18n("<p>The current session already has a ZModem file transfer in progress.</p>"));
         return;
     }
 
     QString zmodem = QStandardPaths::findExecutable(QStringLiteral("sz"));
     if (zmodem.isEmpty()) {
         zmodem = QStandardPaths::findExecutable(QStringLiteral("lsz"));
     }
     if (zmodem.isEmpty()) {
         KMessageBox::sorry(_view,
                            i18n("<p>No suitable ZModem software was found on this system.</p>"
                                 "<p>You may wish to install the 'rzsz' or 'lrzsz' package.</p>"));
         return;
     }
 
     QStringList files = QFileDialog::getOpenFileNames(_view,
                         i18n("Select Files for ZModem Upload"),
                         QDir::homePath());
     if (!files.isEmpty()) {
         _session->startZModem(zmodem, QString(), files);
     }
 }
 
 bool SessionController::isKonsolePart() const
 {
     // Check to see if we are being called from Konsole or a KPart
     return !(qApp->applicationName() == QLatin1String("konsole"));
 }
 
 QString SessionController::userTitle() const
 {
     if (!_session.isNull()) {
         return _session->userTitle();
     } else {
         return QString();
     }
 }
diff --git a/src/ViewSplitter.cpp b/src/ViewSplitter.cpp
index f150900e..2a056e12 100644
--- a/src/ViewSplitter.cpp
+++ b/src/ViewSplitter.cpp
@@ -1,357 +1,356 @@
 /*
     This file is part of the Konsole Terminal.
 
     Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "ViewSplitter.h"
 
 // Qt
 #include <QChildEvent>
 #include <QDragEnterEvent>
 #include <QMimeData>
 #include <QApplication>
 #include <memory>
 
 
 // Konsole
 #include "ViewContainer.h"
 #include "TerminalDisplay.h"
 
 using Konsole::ViewSplitter;
 using Konsole::TerminalDisplay;
 
 //TODO: Connect the TerminalDisplay destroyed signal here.
 
 ViewSplitter::ViewSplitter(QWidget *parent) :
     QSplitter(parent)
 {
     setAcceptDrops(true);
 }
 
 /* This function is called on the toplevel splitter, we need to look at the actual ViewSplitter inside it */
 void ViewSplitter::adjustActiveTerminalDisplaySize(int percentage)
 {
     auto focusedTerminalDisplay = activeTerminalDisplay();
     Q_ASSERT(focusedTerminalDisplay);
 
     auto parentSplitter = qobject_cast<ViewSplitter*>(focusedTerminalDisplay->parent());
     const int containerIndex = parentSplitter->indexOf(activeTerminalDisplay());
     Q_ASSERT(containerIndex != -1);
 
     QList<int> containerSizes = parentSplitter->sizes();
 
     const int oldSize = containerSizes[containerIndex];
     const auto newSize = static_cast<int>(oldSize * (1.0 + percentage / 100.0));
     const int perContainerDelta = (count() == 1) ? 0 : ((newSize - oldSize) / (count() - 1)) * (-1);
 
     for (int& size : containerSizes) {
         size += perContainerDelta;
     }
     containerSizes[containerIndex] = newSize;
 
     parentSplitter->setSizes(containerSizes);
 }
 
 // Get the first splitter that's a parent of the current focused widget.
 ViewSplitter *ViewSplitter::activeSplitter()
 {
     QWidget *widget = focusWidget() != nullptr ? focusWidget() : this;
 
     ViewSplitter *splitter = nullptr;
 
     while ((splitter == nullptr) && (widget != nullptr)) {
         splitter = qobject_cast<ViewSplitter *>(widget);
         widget = widget->parentWidget();
     }
 
     Q_ASSERT(splitter);
     return splitter;
 }
 
 void ViewSplitter::updateSizes()
 {
     const int space = (orientation() == Qt::Horizontal ? width() : height()) / count();
-    // Once Qt5.14+ is the mininum, change to use range constructors
     setSizes(QVector<int>(count(), space).toList());
 }
 
 void ViewSplitter::addTerminalDisplay(TerminalDisplay *terminalDisplay, Qt::Orientation containerOrientation, AddBehavior behavior)
 {
     ViewSplitter *splitter = activeSplitter();
     const int currentIndex = splitter->activeTerminalDisplay() == nullptr ? splitter->count()
                             : splitter->indexOf(splitter->activeTerminalDisplay());
 
     if (splitter->count() < 2) {
         splitter->insertWidget(behavior == AddBehavior::AddBefore ? currentIndex : currentIndex + 1, terminalDisplay);
         splitter->setOrientation(containerOrientation);
     } else if (containerOrientation == splitter->orientation()) {
         splitter->insertWidget(currentIndex, terminalDisplay);
     } else {
         auto newSplitter = new ViewSplitter();
         TerminalDisplay *oldTerminalDisplay = splitter->activeTerminalDisplay();
         const int oldContainerIndex = splitter->indexOf(oldTerminalDisplay);
         newSplitter->addWidget(behavior == AddBehavior::AddBefore ? terminalDisplay : oldTerminalDisplay);
         newSplitter->addWidget(behavior == AddBehavior::AddBefore ? oldTerminalDisplay : terminalDisplay);
         newSplitter->setOrientation(containerOrientation);
         newSplitter->updateSizes();
         newSplitter->show();
         splitter->insertWidget(oldContainerIndex, newSplitter);
     }
     splitter->updateSizes();
 }
 
 void ViewSplitter::childEvent(QChildEvent *event)
 {
     QSplitter::childEvent(event);
 
     if (event->removed()) {
         if (count() == 0) {
             deleteLater();
         }
         if (findChild<TerminalDisplay*>() == nullptr) {
             deleteLater();
         }
     }
 
     auto terminals = getToplevelSplitter()->findChildren<TerminalDisplay*>();
     if (terminals.size() == 1) {
         terminals.at(0)->headerBar()->setVisible(false);
     } else {
         for(auto terminal : terminals) {
             terminal->headerBar()->setVisible(true);
         }
     }
 }
 
 void ViewSplitter::handleFocusDirection(Qt::Orientation orientation, int direction)
 {
     auto terminalDisplay = activeTerminalDisplay();
     auto parentSplitter = qobject_cast<ViewSplitter*>(terminalDisplay->parentWidget());
     auto topSplitter = parentSplitter->getToplevelSplitter();
 
     // Find the theme's splitter width + extra space to find valid terminal
     // See https://bugs.kde.org/show_bug.cgi?id=411387 for more info
     const auto handleWidth = parentSplitter->handleWidth() + 3;
 
     const auto start = QPoint(terminalDisplay->x(), terminalDisplay->y());
     const auto startMapped = parentSplitter->mapTo(topSplitter, start);
 
     const int newX = orientation != Qt::Horizontal ? startMapped.x() + handleWidth
              : direction == 1 ? startMapped.x() + terminalDisplay->width() + handleWidth
              : startMapped.x() - handleWidth;
 
     const int newY = orientation != Qt::Vertical ? startMapped.y() + handleWidth
                     : direction == 1 ? startMapped.y() + terminalDisplay->height() + handleWidth
                     : startMapped.y() - handleWidth;
 
     const auto newPoint = QPoint(newX, newY);
     auto child = topSplitter->childAt(newPoint);
 
     TerminalDisplay *focusTerminal = nullptr;
     if (auto* terminal = qobject_cast<TerminalDisplay*>(child)) {
         focusTerminal = terminal;
     } else if (qobject_cast<QSplitterHandle*>(child) != nullptr) {
         auto targetSplitter = qobject_cast<QSplitter*>(child->parent());
         focusTerminal = qobject_cast<TerminalDisplay*>(targetSplitter->widget(0));
     } else if (qobject_cast<QWidget*>(child) != nullptr) {
         while(child != nullptr && focusTerminal == nullptr) {
             focusTerminal = qobject_cast<TerminalDisplay*>(child->parentWidget());
             child = child->parentWidget();
         }
     }
     if (focusTerminal != nullptr) {
         focusTerminal->setFocus(Qt::OtherFocusReason);
     }
 }
 
 void ViewSplitter::focusUp()
 {
     handleFocusDirection(Qt::Vertical, -1);
 }
 
 void ViewSplitter::focusDown()
 {
     handleFocusDirection(Qt::Vertical, +1);
 }
 
 void ViewSplitter::focusLeft()
 {
     handleFocusDirection(Qt::Horizontal, -1);
 }
 
 void ViewSplitter::focusRight()
 {
     handleFocusDirection(Qt::Horizontal, +1);
 }
 
 TerminalDisplay *ViewSplitter::activeTerminalDisplay() const
 {
     auto focusedWidget = qobject_cast<TerminalDisplay*>(focusWidget());
     return focusedWidget != nullptr ? focusedWidget : findChild<TerminalDisplay*>();
 }
 
 void ViewSplitter::toggleMaximizeCurrentTerminal()
 {
     m_terminalMaximized = !m_terminalMaximized;
     handleMinimizeMaximize(m_terminalMaximized);
 }
 
 namespace {
     void restoreAll(QList<TerminalDisplay*>&& terminalDisplays, QList<ViewSplitter*>&& splitters) {
         for (auto splitter : splitters) {
             splitter->setVisible(true);
         }
         for (auto terminalDisplay : terminalDisplays) {
             terminalDisplay->setVisible(true);
         }
     }
 }
 
 bool ViewSplitter::hideRecurse(TerminalDisplay *currentTerminalDisplay) {
     bool allHidden = true;
 
     for(int i = 0, end = count(); i < end; i++) {
         if (auto *maybeSplitter = qobject_cast<ViewSplitter*>(widget(i))) {
             allHidden = maybeSplitter->hideRecurse(currentTerminalDisplay) && allHidden;
             continue;
         }
         if (auto maybeTerminalDisplay = qobject_cast<TerminalDisplay*>(widget(i))) {
             if (maybeTerminalDisplay == currentTerminalDisplay) {
                 allHidden = false;
             } else {
                 maybeTerminalDisplay->setVisible(false);
             }
         }
     }
 
     if (allHidden) {
         setVisible(false);
     }
     return allHidden;
 }
 
 void ViewSplitter::handleMinimizeMaximize(bool maximize)
 {
     auto topLevelSplitter = getToplevelSplitter();
     auto currentTerminalDisplay = topLevelSplitter->activeTerminalDisplay();
     if (maximize) {
         for (int i = 0, end = topLevelSplitter->count(); i < end; i++) {
             auto widgetAt = topLevelSplitter->widget(i);
             if (auto *maybeSplitter = qobject_cast<ViewSplitter*>(widgetAt)) {
                 maybeSplitter->hideRecurse(currentTerminalDisplay);
             }
             if (auto maybeTerminalDisplay = qobject_cast<TerminalDisplay*>(widgetAt)) {
                 if (maybeTerminalDisplay != currentTerminalDisplay) {
                     maybeTerminalDisplay->setVisible(false);
                 }
             }
         }
     } else {
         restoreAll(topLevelSplitter->findChildren<TerminalDisplay*>(),
                    topLevelSplitter->findChildren<ViewSplitter*>());
     }
 }
 
 ViewSplitter *ViewSplitter::getToplevelSplitter()
 {
     ViewSplitter *current = this;
     while(qobject_cast<ViewSplitter*>(current->parentWidget()) != nullptr) {
         current = qobject_cast<ViewSplitter*>(current->parentWidget());
     }
     return current;
 }
 
 namespace {
     TerminalDisplay *currentDragTarget = nullptr;
 }
 
 void Konsole::ViewSplitter::dragEnterEvent(QDragEnterEvent* ev)
 {
     const auto dragId = QStringLiteral("konsole/terminal_display");
     if (ev->mimeData()->hasFormat(dragId)) {
         auto other_pid = ev->mimeData()->data(dragId).toInt();
         // don't accept the drop if it's another instance of konsole
         if (qApp->applicationPid() != other_pid) {
             return;
         }
         if (getToplevelSplitter()->terminalMaximized()) {
             return;
         }
         ev->accept();
     }
 }
 
 void Konsole::ViewSplitter::dragMoveEvent(QDragMoveEvent* ev)
 {
     auto currentWidget = childAt(ev->pos());
     if (auto terminal = qobject_cast<TerminalDisplay*>(currentWidget)) {
         if ((currentDragTarget != nullptr) && currentDragTarget != terminal) {
             currentDragTarget->hideDragTarget();
         }
         if (terminal == ev->source()) {
             return;
         }
         currentDragTarget = terminal;
         auto localPos = currentDragTarget->mapFromParent(ev->pos());
         currentDragTarget->showDragTarget(localPos);
     }
 }
 
 void Konsole::ViewSplitter::dragLeaveEvent(QDragLeaveEvent* event)
 {
     Q_UNUSED(event)
     if (currentDragTarget != nullptr) {
         currentDragTarget->hideDragTarget();
         currentDragTarget = nullptr;
     }
 }
 
 void Konsole::ViewSplitter::dropEvent(QDropEvent* ev)
 {
     if (ev->mimeData()->hasFormat(QStringLiteral("konsole/terminal_display"))) {
         if (getToplevelSplitter()->terminalMaximized()) {
             return;
         }
         if (currentDragTarget != nullptr) {
             currentDragTarget->hideDragTarget();
             auto source = qobject_cast<TerminalDisplay*>(ev->source());
             source->setVisible(false);
             source->setParent(nullptr);
 
             currentDragTarget->setFocus(Qt::OtherFocusReason);
             const auto droppedEdge = currentDragTarget->droppedEdge();
 
             AddBehavior behavior = droppedEdge == Qt::LeftEdge || droppedEdge == Qt::TopEdge
                 ? AddBehavior::AddBefore : AddBehavior::AddAfter;
 
             Qt::Orientation orientation = droppedEdge == Qt::LeftEdge || droppedEdge == Qt::RightEdge
                 ? Qt::Horizontal : Qt::Vertical;
 
             // topLevel is the splitter that's connected with the ViewManager
             // that in turn can call the SessionController.
             emit getToplevelSplitter()->terminalDisplayDropped(source);
             addTerminalDisplay(source, orientation, behavior);
             source->setVisible(true);
             currentDragTarget = nullptr;
         }
     }
 }