diff --git a/src/Application.cpp b/src/Application.cpp
index fd44ce35..1d4aec98 100644
--- a/src/Application.cpp
+++ b/src/Application.cpp
@@ -1,604 +1,605 @@
 /*
     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 "Application.h"
 
 // Qt
 #include <QApplication>
 #include <QHashIterator>
 #include <QFileInfo>
 #include <QDir>
 #include <QCommandLineParser>
 #include <QStandardPaths>
 
 // KDE
 #include <KActionCollection>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 
 // Konsole
 #include "SessionManager.h"
 #include "ProfileManager.h"
 #include "MainWindow.h"
 #include "Session.h"
 #include "ShellCommand.h"
 #include "KonsoleSettings.h"
 #include "ViewManager.h"
 #include "WindowSystemInfo.h"
 #include "ViewContainer.h"
 #include "TerminalDisplay.h"
 
 using namespace Konsole;
 
 Application::Application(QSharedPointer<QCommandLineParser> parser,
                          const QStringList &customCommand) :
     _backgroundInstance(nullptr),
     m_parser(parser),
     m_customCommand(customCommand)
 {
 }
 
 void Application::populateCommandLineParser(QCommandLineParser *parser)
 {
-    auto options = QVector<QCommandLineOption> {
+    const auto options = QVector<QCommandLineOption> {
         { { QStringLiteral("profile") },
             i18nc("@info:shell", "Name of profile to use for new Konsole instance"),
             QStringLiteral("name")
         },
         { { QStringLiteral("fallback-profile") },
             i18nc("@info:shell", "Use the internal FALLBACK profile")
         },
         { { QStringLiteral("workdir") },
             i18nc("@info:shell", "Set the initial working directory of the new tab or window to 'dir'"),
             QStringLiteral("dir")
         },
         { { QStringLiteral("hold"), QStringLiteral("noclose") },
            i18nc("@info:shell", "Do not close the initial session automatically when it ends.")
         },
         {  {QStringLiteral("new-tab") },
             i18nc("@info:shell", "Create a new tab in an existing window rather than creating a new window")
         },
         { { QStringLiteral("tabs-from-file") },
             i18nc("@info:shell","Create tabs as specified in given tabs configuration"" file"),
             QStringLiteral("file")
         },
         { { QStringLiteral("background-mode") },
             i18nc("@info:shell", "Start Konsole in the background and bring to the front when Ctrl+Shift+F12 (by default) is pressed")
         },
         { { QStringLiteral("separate"), QStringLiteral("nofork") },
             i18nc("@info:shell", "Run in a separate process")
         },
         { { QStringLiteral("show-menubar") },
             i18nc("@info:shell", "Show the menubar, overriding the default setting")
         },
         { { QStringLiteral("hide-menubar") },
             i18nc("@info:shell", "Hide the menubar, overriding the default setting")
         },
         { { QStringLiteral("show-tabbar") },
             i18nc("@info:shell", "Show the tabbar, overriding the default setting")
         },
         { { QStringLiteral("hide-tabbar") },
             i18nc("@info:shell", "Hide the tabbar, overriding the default setting")
         },
         { { QStringLiteral("fullscreen") },
             i18nc("@info:shell", "Start Konsole in fullscreen mode")
         },
         { { QStringLiteral("notransparency") },
             i18nc("@info:shell", "Disable transparent backgrounds, even if the system supports them.")
         },
         { { QStringLiteral("list-profiles") },
             i18nc("@info:shell", "List the available profiles")
         },
         { { QStringLiteral("list-profile-properties") },
             i18nc("@info:shell", "List all the profile properties names and their type (for use with -p)")
         },
         { { QStringLiteral("p") },
             i18nc("@info:shell", "Change the value of a profile property."),
             QStringLiteral("property=value")
         },
         { { QStringLiteral("e") },
             i18nc("@info:shell", "Command to execute. This option will catch all following arguments, so use it as the last option."),
             QStringLiteral("cmd")
         }
     };
-    foreach(const auto& option, options) {
+    for (const auto &option : options) {
         parser->addOption(option);
     }
 
     parser->addPositionalArgument(QStringLiteral("[args]"),
                                   i18nc("@info:shell", "Arguments passed to command"));
 
     // Add a no-op compatibility option to make Konsole compatible with
     // Debian's policy on X terminal emulators.
     // -T is technically meant to set a title, that is not really meaningful
     // for Konsole as we have multiple user-facing options controlling
     // the title and overriding whatever is set elsewhere.
     // https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=532029
     // https://www.debian.org/doc/debian-policy/ch-customized-programs.html#s11.8.3
     auto titleOption = QCommandLineOption({ QStringLiteral("T") },
                                           QStringLiteral("Debian policy compatibility, not used"),
                                           QStringLiteral("value"));
     titleOption.setFlags(QCommandLineOption::HiddenFromHelp);
     parser->addOption(titleOption);
 }
 
 QStringList Application::getCustomCommand(QStringList &args)
 {
     int i = args.indexOf(QLatin1String("-e"));
     QStringList customCommand;
     if ((0 < i) && (i < (args.size() - 1))) {
         // -e was specified with at least one extra argument
         // if -e was specified without arguments, QCommandLineParser will deal
         // with that
         args.removeAt(i);
         while (args.size() > i) {
             customCommand << args.takeAt(i);
         }
     }
     return customCommand;
 }
 
 Application::~Application()
 {
     SessionManager::instance()->closeAllSessions();
     ProfileManager::instance()->saveSettings();
 }
 
 MainWindow *Application::newMainWindow()
 {
     WindowSystemInfo::HAVE_TRANSPARENCY = !m_parser->isSet(QStringLiteral("notransparency"));
 
     auto window = new MainWindow();
 
     connect(window, &Konsole::MainWindow::newWindowRequest, this,
             &Konsole::Application::createWindow);
     connect(window, &Konsole::MainWindow::terminalsDetached, this, &Konsole::Application::detachTerminals);
 
     return window;
 }
 
 void Application::createWindow(const Profile::Ptr &profile, const QString &directory)
 {
     MainWindow *window = newMainWindow();
     window->createSession(profile, directory);
     finalizeNewMainWindow(window);
 }
 
 void Application::detachTerminals(ViewSplitter *splitter,const QHash<TerminalDisplay*, Session*>& sessionsMap)
 {
     MainWindow *currentWindow = qobject_cast<MainWindow*>(sender());
     MainWindow *window = newMainWindow();
     ViewManager *manager = window->viewManager();
 
-    foreach(TerminalDisplay* terminal, splitter->findChildren<TerminalDisplay*>()) {
+    const QList<TerminalDisplay *> displays = splitter->findChildren<TerminalDisplay *>();
+    for (TerminalDisplay* terminal : displays) {
         manager->attachView(terminal, sessionsMap[terminal]);
     }
     manager->activeContainer()->addSplitter(splitter);
 
     window->show();
     window->resize(currentWindow->width(), currentWindow->height());
     window->move(QCursor::pos());
 }
 
 int Application::newInstance()
 {
     // handle session management
 
     // returns from processWindowArgs(args, createdNewMainWindow)
     // if a new window was created
     bool createdNewMainWindow = false;
 
     // check for arguments to print help or other information to the
     // terminal, quit if such an argument was found
     if (processHelpArgs()) {
         return 0;
     }
 
     // create a new window or use an existing one
     MainWindow *window = processWindowArgs(createdNewMainWindow);
 
     if (m_parser->isSet(QStringLiteral("tabs-from-file"))) {
         // create new session(s) as described in file
         if (!processTabsFromFileArgs(window)) {
             return 0;
         }
     }
 
     // select profile to use
     Profile::Ptr baseProfile = processProfileSelectArgs();
 
     // process various command-line options which cause a property of the
     // selected profile to be changed
     Profile::Ptr newProfile = processProfileChangeArgs(baseProfile);
 
     // create new session
     Session *session = window->createSession(newProfile, QString());
 
     if (m_parser->isSet(QStringLiteral("noclose"))) {
         session->setAutoClose(false);
     }
 
     // if the background-mode argument is supplied, start the background
     // session ( or bring to the front if it already exists )
     if (m_parser->isSet(QStringLiteral("background-mode"))) {
         startBackgroundMode(window);
     } else {
         // Qt constrains top-level windows which have not been manually
         // resized (via QWidget::resize()) to a maximum of 2/3rds of the
         //  screen size.
         //
         // This means that the terminal display might not get the width/
         // height it asks for.  To work around this, the widget must be
         // manually resized to its sizeHint().
         //
         // This problem only affects the first time the application is run.
         // run. After that KMainWindow will have manually resized the
         // window to its saved size at this point (so the Qt::WA_Resized
         // attribute will be set)
 
         // If not restoring size from last time or only adding new tab,
         // resize window to chosen profile size (see Bug:345403)
         if (createdNewMainWindow) {
             finalizeNewMainWindow(window);
         } else {
             window->show();
         }
     }
 
     return 1;
 }
 
 /* Documentation for tab file:
  *
  * ;; is the token separator
  * # at the beginning of line results in line being ignored.
  * supported tokens: title, command, profile and workdir
  *
  * Note that the title is static and the tab will close when the
  * command is complete (do not use --noclose).  You can start new tabs.
  *
  * Example below will create 6 tabs as listed and a 7th default tab
 title: This is the title;; command: ssh localhost
 title: This is the title;; command: ssh localhost;; profile: Shell
 title: Top this!;; command: top
 title: mc this!;; command: mc;; workdir: /tmp
 #this line is comment
 command: ssh localhost
 profile: Shell
 */
 bool Application::processTabsFromFileArgs(MainWindow *window)
 {
     // Open tab configuration file
     const QString tabsFileName(m_parser->value(QStringLiteral("tabs-from-file")));
     QFile tabsFile(tabsFileName);
     if (!tabsFile.open(QFile::ReadOnly)) {
         qWarning() << "ERROR: Cannot open tabs file "
                    << tabsFileName.toLocal8Bit().data();
         return false;
     }
 
     unsigned int sessions = 0;
     while (!tabsFile.atEnd()) {
         QString lineString(QString::fromUtf8(tabsFile.readLine()).trimmed());
         if ((lineString.isEmpty()) || (lineString[0] == QLatin1Char('#'))) {
             continue;
         }
 
         QHash<QString, QString> lineTokens;
         QStringList lineParts = lineString.split(QStringLiteral(";;"), QString::SkipEmptyParts);
 
         for (int i = 0; i < lineParts.size(); ++i) {
             QString key = lineParts.at(i).section(QLatin1Char(':'), 0, 0).trimmed().toLower();
             QString value = lineParts.at(i).section(QLatin1Char(':'), 1, -1).trimmed();
             lineTokens[key] = value;
         }
         // should contain at least one of 'command' and 'profile'
         if (lineTokens.contains(QLatin1String("command"))
             || lineTokens.contains(QLatin1String("profile"))) {
             createTabFromArgs(window, lineTokens);
             sessions++;
         } else {
             qWarning() << "Each line should contain at least one of 'command' and 'profile'.";
         }
     }
     tabsFile.close();
 
     if (sessions < 1) {
         qWarning() << "No valid lines found in "
                    << tabsFileName.toLocal8Bit().data();
         return false;
     }
 
     return true;
 }
 
 void Application::createTabFromArgs(MainWindow *window, const QHash<QString, QString> &tokens)
 {
     const QString &title = tokens[QStringLiteral("title")];
     const QString &command = tokens[QStringLiteral("command")];
     const QString &profile = tokens[QStringLiteral("profile")];
     const QString &workdir = tokens[QStringLiteral("workdir")];
 
     Profile::Ptr baseProfile;
     if (!profile.isEmpty()) {
         baseProfile = ProfileManager::instance()->loadProfile(profile);
     }
     if (!baseProfile) {
         // fallback to default profile
         baseProfile = ProfileManager::instance()->defaultProfile();
     }
 
     Profile::Ptr newProfile = Profile::Ptr(new Profile(baseProfile));
     newProfile->setHidden(true);
 
     // FIXME: the method of determining whether to use newProfile does not
     // scale well when we support more fields in the future
     bool shouldUseNewProfile = false;
 
     if (!command.isEmpty()) {
         newProfile->setProperty(Profile::Command, command);
         newProfile->setProperty(Profile::Arguments, command.split(QLatin1Char(' ')));
         shouldUseNewProfile = true;
     }
 
     if (!title.isEmpty()) {
         newProfile->setProperty(Profile::LocalTabTitleFormat, title);
         newProfile->setProperty(Profile::RemoteTabTitleFormat, title);
         shouldUseNewProfile = true;
     }
 
     if (m_parser->isSet(QStringLiteral("workdir"))) {
         newProfile->setProperty(Profile::Directory, m_parser->value(QStringLiteral("workdir")));
         shouldUseNewProfile = true;
     }
 
     if (!workdir.isEmpty()) {
         newProfile->setProperty(Profile::Directory, workdir);
         shouldUseNewProfile = true;
     }
 
     // Create the new session
     Profile::Ptr theProfile = shouldUseNewProfile ? newProfile : baseProfile;
     Session *session = window->createSession(theProfile, QString());
 
     if (m_parser->isSet(QStringLiteral("noclose"))) {
         session->setAutoClose(false);
     }
 
     if (!window->testAttribute(Qt::WA_Resized)) {
         window->resize(window->sizeHint());
     }
 
     // FIXME: this ugly hack here is to make the session start running, so that
     // its tab title is displayed as expected.
     //
     // This is another side effect of the commit fixing BKO 176902.
     window->show();
     window->hide();
 }
 
 // Creates a new Konsole window.
 // If --new-tab is given, use existing window.
 MainWindow *Application::processWindowArgs(bool &createdNewMainWindow)
 {
     MainWindow *window = nullptr;
     if (m_parser->isSet(QStringLiteral("new-tab"))) {
         QListIterator<QWidget *> iter(QApplication::topLevelWidgets());
         iter.toBack();
         while (iter.hasPrevious()) {
             window = qobject_cast<MainWindow *>(iter.previous());
             if (window != nullptr) {
                 break;
             }
         }
     }
 
     if (window == nullptr) {
         createdNewMainWindow = true;
         window = newMainWindow();
 
         // override default menubar visibility
         if (m_parser->isSet(QStringLiteral("show-menubar"))) {
             window->setMenuBarInitialVisibility(true);
         }
         if (m_parser->isSet(QStringLiteral("hide-menubar"))) {
             window->setMenuBarInitialVisibility(false);
         }
         if (m_parser->isSet(QStringLiteral("fullscreen"))) {
             window->viewFullScreen(true);
         }
         if (m_parser->isSet(QStringLiteral("show-tabbar"))) {
             window->viewManager()->setNavigationVisibility(ViewManager::AlwaysShowNavigation);
         }
         else if (m_parser->isSet(QStringLiteral("hide-tabbar"))) {
             window->viewManager()->setNavigationVisibility(ViewManager::AlwaysHideNavigation);
         }
     }
     return window;
 }
 
 // Loads a profile.
 // If --profile <name> is given, loads profile <name>.
 // If --fallback-profile is given, loads profile FALLBACK/.
 // Else loads the default profile.
 Profile::Ptr Application::processProfileSelectArgs()
 {
     Profile::Ptr defaultProfile = ProfileManager::instance()->defaultProfile();
 
     if (m_parser->isSet(QStringLiteral("profile"))) {
         Profile::Ptr profile = ProfileManager::instance()->loadProfile(
             m_parser->value(QStringLiteral("profile")));
         if (profile) {
             return profile;
         }
     } else if (m_parser->isSet(QStringLiteral("fallback-profile"))) {
         Profile::Ptr profile = ProfileManager::instance()->loadProfile(QStringLiteral("FALLBACK/"));
         if (profile) {
             return profile;
         }
     }
 
     return defaultProfile;
 }
 
 bool Application::processHelpArgs()
 {
     if (m_parser->isSet(QStringLiteral("list-profiles"))) {
         listAvailableProfiles();
         return true;
     } else if (m_parser->isSet(QStringLiteral("list-profile-properties"))) {
         listProfilePropertyInfo();
         return true;
     }
     return false;
 }
 
 void Application::listAvailableProfiles()
 {
-    QStringList paths = ProfileManager::instance()->availableProfilePaths();
+    const QStringList paths = ProfileManager::instance()->availableProfilePaths();
 
-    foreach (const QString &path, paths) {
+    for (const QString &path : paths) {
         QFileInfo info(path);
         printf("%s\n", info.completeBaseName().toLocal8Bit().constData());
     }
 }
 
 void Application::listProfilePropertyInfo()
 {
     Profile::Ptr tempProfile = ProfileManager::instance()->defaultProfile();
     const QStringList names = tempProfile->propertiesInfoList();
 
-    foreach (const QString &name, names) {
+    for (const QString &name : names) {
         printf("%s\n", name.toLocal8Bit().constData());
     }
 }
 
 Profile::Ptr Application::processProfileChangeArgs(Profile::Ptr baseProfile)
 {
     bool shouldUseNewProfile = false;
 
     Profile::Ptr newProfile = Profile::Ptr(new Profile(baseProfile));
     newProfile->setHidden(true);
 
     // change the initial working directory
     if (m_parser->isSet(QStringLiteral("workdir"))) {
         newProfile->setProperty(Profile::Directory, m_parser->value(QStringLiteral("workdir")));
         shouldUseNewProfile = true;
     }
 
     // temporary changes to profile options specified on the command line
     const QStringList profileProperties = m_parser->values(QStringLiteral("p"));
-    foreach (const QString &value, profileProperties) {
+    for (const QString &value : profileProperties) {
         ProfileCommandParser parser;
 
         QHashIterator<Profile::Property, QVariant> iter(parser.parse(value));
         while (iter.hasNext()) {
             iter.next();
             newProfile->setProperty(iter.key(), iter.value());
         }
 
         shouldUseNewProfile = true;
     }
 
     // run a custom command
     if (!m_customCommand.isEmpty()) {
         // Example: konsole -e man ls
         QString commandExec = m_customCommand[0];
         QStringList commandArguments(m_customCommand);
         if ((m_customCommand.size() == 1)
             && (QStandardPaths::findExecutable(commandExec).isEmpty())) {
             // Example: konsole -e "man ls"
             ShellCommand shellCommand(commandExec);
             commandExec = shellCommand.command();
             commandArguments = shellCommand.arguments();
         }
 
         if (commandExec.startsWith(QLatin1String("./"))) {
             commandExec = QDir::currentPath() + commandExec.mid(1);
         }
 
         newProfile->setProperty(Profile::Command, commandExec);
         newProfile->setProperty(Profile::Arguments, commandArguments);
 
         shouldUseNewProfile = true;
     }
 
     if (shouldUseNewProfile) {
         return newProfile;
     } else {
         return baseProfile;
     }
 }
 
 void Application::startBackgroundMode(MainWindow *window)
 {
     if (_backgroundInstance != nullptr) {
         return;
     }
 
     KActionCollection* collection = window->actionCollection();
     QAction* action = collection->addAction(QStringLiteral("toggle-background-window"));
     action->setObjectName(QStringLiteral("Konsole Background Mode"));
     action->setText(i18nc("@item", "Toggle Background Window"));
     KGlobalAccel::self()->setGlobalShortcut(action, QKeySequence(Konsole::ACCEL + Qt::SHIFT + Qt::Key_F12));
     connect(action, &QAction::triggered, this, &Application::toggleBackgroundInstance);
 
     _backgroundInstance = window;
 }
 
 void Application::toggleBackgroundInstance()
 {
     Q_ASSERT(_backgroundInstance);
 
     if (!_backgroundInstance->isVisible()) {
         _backgroundInstance->show();
         // ensure that the active terminal display has the focus. Without
         // this, an odd problem occurred where the focus widget would change
         // each time the background instance was shown
         _backgroundInstance->setFocus();
     } else {
         _backgroundInstance->hide();
     }
 }
 
 void Application::slotActivateRequested(QStringList args, const QString & /*workingDir*/)
 {
     // QCommandLineParser expects the first argument to be the executable name
     // In the current version it just strips it away
     args.prepend(qApp->applicationFilePath());
 
     m_customCommand = getCustomCommand(args);
 
     // We can't re-use QCommandLineParser instances, it preserves earlier parsed values
     auto parser = new QCommandLineParser;
     populateCommandLineParser(parser);
     parser->parse(args);
     m_parser.reset(parser);
 
     newInstance();
 }
 
 void Application::finalizeNewMainWindow(MainWindow *window)
 {
     if (!KonsoleSettings::saveGeometryOnExit()) {
         window->resize(window->sizeHint());
     }
     window->show();
 }
diff --git a/src/ColorSchemeManager.cpp b/src/ColorSchemeManager.cpp
index 0b030234..bed07128 100644
--- a/src/ColorSchemeManager.cpp
+++ b/src/ColorSchemeManager.cpp
@@ -1,258 +1,258 @@
 /*
     This source file is part of Konsole, a terminal emulator.
 
     Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
     Copyright 2018 by Harald Sitter <sitter@kde.org>
 
     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 "ColorSchemeManager.h"
 
 #include "konsoledebug.h"
 
 // Qt
 #include <QFileInfo>
 #include <QFile>
 #include <QDir>
 
 // KDE
 #include <KConfig>
 
 using namespace Konsole;
 
 ColorSchemeManager::ColorSchemeManager() :
     _colorSchemes(QHash<QString, const ColorScheme *>()),
     _haveLoadedAll(false)
 {
 }
 
 ColorSchemeManager::~ColorSchemeManager()
 {
     qDeleteAll(_colorSchemes);
 }
 
 Q_GLOBAL_STATIC(ColorSchemeManager, theColorSchemeManager)
 
 ColorSchemeManager* ColorSchemeManager::instance()
 {
     return theColorSchemeManager;
 }
 
 void ColorSchemeManager::loadAllColorSchemes()
 {
     int success = 0;
     int failed = 0;
 
-    QStringList nativeColorSchemes = listColorSchemes();
-    foreach (const QString &colorScheme, nativeColorSchemes) {
+    const QStringList nativeColorSchemes = listColorSchemes();
+    for (const QString &colorScheme : nativeColorSchemes) {
         if (loadColorScheme(colorScheme)) {
             success++;
         } else {
             failed++;
         }
     }
 
     if (failed > 0) {
         qCDebug(KonsoleDebug) << "failed to load " << failed << " color schemes.";
     }
 
     _haveLoadedAll = true;
 }
 
 QList<const ColorScheme *> ColorSchemeManager::allColorSchemes()
 {
     if (!_haveLoadedAll) {
         loadAllColorSchemes();
     }
 
     return _colorSchemes.values();
 }
 
 bool ColorSchemeManager::loadColorScheme(const QString &filePath)
 {
     if (!pathIsColorScheme(filePath) || !QFile::exists(filePath)) {
         return false;
     }
 
     auto name = colorSchemeNameFromPath(filePath);
 
     KConfig config(filePath, KConfig::NoGlobals);
     auto scheme = new ColorScheme();
     scheme->setName(name);
     scheme->read(config);
 
     if (scheme->name().isEmpty()) {
         qCDebug(KonsoleDebug) << "Color scheme in" << filePath
                               << "does not have a valid name and was not loaded.";
         delete scheme;
         return false;
     }
 
     if (!_colorSchemes.contains(name)) {
         _colorSchemes.insert(scheme->name(), scheme);
     } else {
         //qDebug() << "color scheme with name" << scheme->name() << "has already been" <<
         //         "found, ignoring.";
 
         delete scheme;
     }
 
     return true;
 }
 
 bool ColorSchemeManager::unloadColorScheme(const QString &filePath)
 {
     if (!pathIsColorScheme(filePath)) {
         return false;
     }
     auto name = colorSchemeNameFromPath(filePath);
     delete _colorSchemes.take(name);
     return true;
 }
 
 QString ColorSchemeManager::colorSchemeNameFromPath(const QString &path)
 {
     if (!pathIsColorScheme(path)) {
         return QString();
     }
     return QFileInfo(path).completeBaseName();
 }
 
 QStringList ColorSchemeManager::listColorSchemes()
 {
     QStringList colorschemes;
     const QStringList dirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("konsole"),
                                                        QStandardPaths::LocateDirectory);
     colorschemes.reserve(dirs.size());
 
     for (const QString &dir : dirs) {
         const QStringList fileNames = QDir(dir).entryList(QStringList() << QStringLiteral("*.colorscheme"));
         for (const QString &file : fileNames) {
             colorschemes.append(dir + QLatin1Char('/') + file);
         }
     }
     return colorschemes;
 }
 
 const ColorScheme ColorSchemeManager::_defaultColorScheme;
 const ColorScheme *ColorSchemeManager::defaultColorScheme() const
 {
     return &_defaultColorScheme;
 }
 
 void ColorSchemeManager::addColorScheme(ColorScheme *scheme)
 {
     // remove existing colorscheme with the same name
     if (_colorSchemes.contains(scheme->name())) {
         delete _colorSchemes.take(scheme->name());
     }
 
     _colorSchemes.insert(scheme->name(), scheme);
 
     // save changes to disk
 
     const QString dir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation)
                         + QStringLiteral("/konsole/");
     QDir().mkpath(dir);
     const QString path = dir + scheme->name() + QStringLiteral(".colorscheme");
     KConfig config(path, KConfig::NoGlobals);
 
     scheme->write(config);
 }
 
 bool ColorSchemeManager::deleteColorScheme(const QString &name)
 {
     Q_ASSERT(_colorSchemes.contains(name));
 
     // look up the path and delete
     QString path = findColorSchemePath(name);
     if (QFile::remove(path)) {
         delete _colorSchemes.take(name);
         return true;
     } else {
         qCDebug(KonsoleDebug)<<"Failed to remove color scheme -"<<path;
         return false;
     }
 }
 
 const ColorScheme *ColorSchemeManager::findColorScheme(const QString &name)
 {
     if (name.isEmpty()) {
         return defaultColorScheme();
     }
 
     // A fix to prevent infinite loops if users puts / in ColorScheme name
     // Konsole will create a sub-folder in that case (bko 315086)
     // More code will have to go in to prevent the users from doing that.
     if (name.contains(QLatin1String("/"))) {
         qCDebug(KonsoleDebug)<<name<<" has an invalid character / in the name ... skipping";
         return defaultColorScheme();
     }
 
     if (_colorSchemes.contains(name)) {
         return _colorSchemes[name];
     } else {
         // look for this color scheme
         QString path = findColorSchemePath(name);
         if (!path.isEmpty() && loadColorScheme(path)) {
             return findColorScheme(name);
         }
 
         qCDebug(KonsoleDebug) << "Could not find color scheme - " << name;
 
         return nullptr;
     }
 }
 
 QString ColorSchemeManager::findColorSchemePath(const QString &name) const
 {
     QString path = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QLatin1String("konsole/") + name + QLatin1String(".colorscheme"));
 
     if (!path.isEmpty()) {
         return path;
     }
 
     return QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("konsole/") + name + QStringLiteral(".schema"));
 }
 
 bool ColorSchemeManager::pathIsColorScheme(const QString &path)
 {
     return path.endsWith(QLatin1String(".colorscheme"));
 }
 
 bool ColorSchemeManager::isColorSchemeDeletable(const QString &name)
 {
     const QString path = findColorSchemePath(name);
 
     QFileInfo fileInfo(path);
     QFileInfo dirInfo = fileInfo.path();
 
     return dirInfo.isWritable();
 }
 
 bool ColorSchemeManager::canResetColorScheme(const QString &name)
 {
     const QStringList paths = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QLatin1String("konsole/") + name + QLatin1String(".colorscheme"));
 
     // if the colorscheme exists in both a writable location under the
     // user's home dir and a system-wide location, then it's possible
     // to delete the colorscheme under the user's home dir so that the
     // colorscheme from the system-wide location can be used instead,
     // i.e. resetting the colorscheme
     return (paths.count() > 1);
 }
diff --git a/src/CopyInputDialog.cpp b/src/CopyInputDialog.cpp
index 4913cc33..89669be6 100644
--- a/src/CopyInputDialog.cpp
+++ b/src/CopyInputDialog.cpp
@@ -1,230 +1,230 @@
 /*
     Copyright 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 "CopyInputDialog.h"
 
 // Qt
 #include <QSortFilterProxyModel>
 
 // Konsole
 #include "ui_CopyInputDialog.h"
 
 #include <KLocalizedString>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 using namespace Konsole;
 
 CopyInputDialog::CopyInputDialog(QWidget *parent) :
     QDialog(parent)
     , _ui(nullptr)
     , _model(nullptr)
     , _masterSession(nullptr)
 {
     setWindowTitle(i18n("Copy Input"));
     auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     auto mainWidget = new QWidget(this);
     auto mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
     mainLayout->addWidget(mainWidget);
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &CopyInputDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &CopyInputDialog::reject);
     mainLayout->addWidget(buttonBox);
 
     setWindowModality(Qt::WindowModal);
 
     _ui = new Ui::CopyInputDialog();
     _ui->setupUi(mainWidget);
 
     connect(_ui->selectAllButton, &QPushButton::clicked, this,
             &Konsole::CopyInputDialog::selectAll);
     connect(_ui->deselectAllButton, &QPushButton::clicked, this,
             &Konsole::CopyInputDialog::deselectAll);
 
     _ui->filterEdit->setClearButtonEnabled(true);
     _ui->filterEdit->setFocus();
 
     _model = new CheckableSessionModel(parent);
     _model->setCheckColumn(1);
     _model->setSessions(SessionManager::instance()->sessions());
 
     auto filterProxyModel = new QSortFilterProxyModel(this);
     filterProxyModel->setDynamicSortFilter(true);
     filterProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
     filterProxyModel->setSourceModel(_model);
     filterProxyModel->setFilterKeyColumn(-1);
 
     connect(_ui->filterEdit, &QLineEdit::textChanged, filterProxyModel,
             &QSortFilterProxyModel::setFilterFixedString);
 
     _ui->sessionList->setModel(filterProxyModel);
     _ui->sessionList->setColumnHidden(0, true); // Hide number column
     _ui->sessionList->header()->hide();
 }
 
 CopyInputDialog::~CopyInputDialog()
 {
     delete _ui;
 }
 
 void CopyInputDialog::setChosenSessions(const QSet<Session *> &sessions)
 {
     QSet<Session *> checked = sessions;
     if (!_masterSession.isNull()) {
         checked.insert(_masterSession);
     }
 
     _model->setCheckedSessions(checked);
 }
 
 QSet<Session *> CopyInputDialog::chosenSessions() const
 {
     return _model->checkedSessions();
 }
 
 void CopyInputDialog::setMasterSession(Session *session)
 {
     if (!_masterSession.isNull()) {
         _model->setCheckable(_masterSession, true);
     }
 
     _model->setCheckable(session, false);
     QSet<Session *> checked = _model->checkedSessions();
     checked.insert(session);
     _model->setCheckedSessions(checked);
 
     _masterSession = session;
 }
 
 void CopyInputDialog::setSelectionChecked(bool checked)
 {
     QAbstractItemModel *model = _ui->sessionList->model();
     int rows = model->rowCount();
 
-    QModelIndexList selected = _ui->sessionList->selectionModel()->selectedIndexes();
+    const QModelIndexList selected = _ui->sessionList->selectionModel()->selectedIndexes();
 
     if (selected.count() > 1) {
-        foreach (const QModelIndex &index, selected) {
+        for (const QModelIndex &index : selected) {
             setRowChecked(index.row(), checked);
         }
     } else {
         for (int i = 0; i < rows; i++) {
             setRowChecked(i, checked);
         }
     }
 }
 
 void CopyInputDialog::setRowChecked(int row, bool checked)
 {
     QAbstractItemModel *model = _ui->sessionList->model();
     QModelIndex index = model->index(row, _model->checkColumn());
     model->setData(index, static_cast<int>( checked ? Qt::Checked : Qt::Unchecked), Qt::CheckStateRole);
 }
 
 CheckableSessionModel::CheckableSessionModel(QObject *parent) :
     SessionListModel(parent),
     _checkedSessions(QSet<Session *>()),
     _fixedSessions(QSet<Session *>()),
     _checkColumn(0)
 {
 }
 
 void CheckableSessionModel::setCheckColumn(int column)
 {
     beginResetModel();
     _checkColumn = column;
     endResetModel();
 }
 
 Qt::ItemFlags CheckableSessionModel::flags(const QModelIndex &index) const
 {
     auto *session = static_cast<Session *>(index.internalPointer());
 
     if (_fixedSessions.contains(session)) {
         return SessionListModel::flags(index) & ~Qt::ItemIsEnabled;
     }
    return SessionListModel::flags(index) | Qt::ItemIsUserCheckable;
 }
 
 QVariant CheckableSessionModel::data(const QModelIndex &index, int role) const
 {
     if (role == Qt::CheckStateRole && index.column() == _checkColumn) {
         auto *session = static_cast<Session *>(index.internalPointer());
         return QVariant::fromValue(static_cast<int>(
             _checkedSessions.contains(session) ? Qt::Checked : Qt::Unchecked)
         );
     }
     return SessionListModel::data(index, role);
 }
 
 bool CheckableSessionModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (role == Qt::CheckStateRole && index.column() == _checkColumn) {
         auto *session = static_cast<Session *>(index.internalPointer());
 
         if (_fixedSessions.contains(session)) {
             return false;
         }
 
         if (value.toInt() == Qt::Checked) {
             _checkedSessions.insert(session);
         } else {
             _checkedSessions.remove(session);
         }
 
         emit dataChanged(index, index);
         return true;
     }
     return SessionListModel::setData(index, value, role);
 }
 
 void CheckableSessionModel::setCheckedSessions(const QSet<Session *> &sessions)
 {
     beginResetModel();
     _checkedSessions = sessions;
     endResetModel();
 }
 
 QSet<Session *> CheckableSessionModel::checkedSessions() const
 {
     return _checkedSessions;
 }
 
 void CheckableSessionModel::setCheckable(Session *session, bool checkable)
 {
     beginResetModel();
 
     if (!checkable) {
         _fixedSessions.insert(session);
     } else {
         _fixedSessions.remove(session);
     }
 
     endResetModel();
 }
 
 void CheckableSessionModel::sessionRemoved(Session *session)
 {
     _checkedSessions.remove(session);
     _fixedSessions.remove(session);
 }
diff --git a/src/EditProfileDialog.cpp b/src/EditProfileDialog.cpp
index 06674bd2..4ad949ca 100644
--- a/src/EditProfileDialog.cpp
+++ b/src/EditProfileDialog.cpp
@@ -1,1947 +1,1948 @@
 /*
     Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
     Copyright 2018 by Harald Sitter <sitter@kde.org>
 
     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 "EditProfileDialog.h"
 
 // Qt
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <QFileDialog>
 #include <QInputDialog>
 #include <QIcon>
 #include <QPainter>
 #include <QPushButton>
 #include <QStandardItem>
 #include <QTextCodec>
 #include <QTimer>
 #include <QUrl>
 #include <QStandardPaths>
 
 // KDE
 #include <KCodecAction>
 #include <KIconDialog>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KNSCore/DownloadManager>
 #include <KWindowSystem>
 
 // Konsole
 #include "ui_EditProfileGeneralPage.h"
 #include "ui_EditProfileTabsPage.h"
 #include "ui_EditProfileAppearancePage.h"
 #include "ui_EditProfileScrollingPage.h"
 #include "ui_EditProfileKeyboardPage.h"
 #include "ui_EditProfileMousePage.h"
 #include "ui_EditProfileAdvancedPage.h"
 #include "ColorSchemeManager.h"
 #include "KeyBindingEditor.h"
 #include "KeyboardTranslator.h"
 #include "KeyboardTranslatorManager.h"
 #include "ProfileManager.h"
 #include "ShellCommand.h"
 #include "WindowSystemInfo.h"
 #include "FontDialog.h"
 
 using namespace Konsole;
 
 EditProfileDialog::EditProfileDialog(QWidget *parent)
     : KPageDialog(parent)
     , _generalUi(nullptr)
     , _tabsUi(nullptr)
     , _appearanceUi(nullptr)
     , _scrollingUi(nullptr)
     , _keyboardUi(nullptr)
     , _mouseUi(nullptr)
     , _advancedUi(nullptr)
     , _tempProfile(nullptr)
     , _profile(nullptr)
     , _previewedProperties(QHash<int, QVariant>())
     , _delayedPreviewProperties(QHash<int, QVariant>())
     , _delayedPreviewTimer(new QTimer(this))
     , _colorDialog(nullptr)
     , _buttonBox(nullptr)
     , _fontDialog(nullptr)
 {
     setWindowTitle(i18n("Edit Profile"));
     setFaceType(KPageDialog::List);
 
     _buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::Apply);
     setButtonBox(_buttonBox);
 
     QPushButton *okButton = _buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     connect(_buttonBox, &QDialogButtonBox::accepted, this, &Konsole::EditProfileDialog::accept);
     connect(_buttonBox, &QDialogButtonBox::rejected, this, &Konsole::EditProfileDialog::reject);
 
     // disable the apply button , since no modification has been made
     _buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
 
     connect(_buttonBox->button(QDialogButtonBox::Apply),
             &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::apply);
 
     connect(_delayedPreviewTimer, &QTimer::timeout, this,
             &Konsole::EditProfileDialog::delayedPreviewActivate);
 
     // Set a fallback icon for non-plasma desktops as this dialog looks
     // terrible without all the icons on the left sidebar.  On GTK related
     // desktops, this dialog look good enough without installing
     // oxygen-icon-theme, qt5ct and setting export QT_QPA_PLATFORMTHEME=qt5ct
     // Plain Xorg desktops still look terrible as there are no icons
     // visible.
     const auto defaultIcon = QIcon::fromTheme(QStringLiteral("utilities-terminal"));
 
     // General page
 
     const QString generalPageName = i18nc("@title:tab Generic, common options", "General");
     auto *generalPageWidget = new QWidget(this);
     _generalUi = new Ui::EditProfileGeneralPage();
     _generalUi->setupUi(generalPageWidget);
     auto *generalPageItem = addPage(generalPageWidget, generalPageName);
     generalPageItem->setHeader(generalPageName);
     generalPageItem->setIcon(QIcon::fromTheme(QStringLiteral("utilities-terminal")));
     _pages[generalPageItem] = Page(&EditProfileDialog::setupGeneralPage);
 
     // Tabs page
 
     const QString tabsPageName = i18n("Tabs");
     auto *tabsPageWidget = new QWidget(this);
     _tabsUi = new Ui::EditProfileTabsPage();
     _tabsUi->setupUi(tabsPageWidget);
     auto *tabsPageItem = addPage(tabsPageWidget, tabsPageName);
     tabsPageItem->setHeader(tabsPageName);
     tabsPageItem->setIcon(QIcon::fromTheme(QStringLiteral("tab-duplicate"),
                           defaultIcon));
     _pages[tabsPageItem] = Page(&EditProfileDialog::setupTabsPage);
 
     LabelsAligner tabsAligner(tabsPageWidget);
     tabsAligner.addLayout(dynamic_cast<QGridLayout *>(_tabsUi->tabMonitoringGroup->layout()));
     tabsAligner.addLayout(dynamic_cast<QGridLayout *>(_tabsUi->renameTabWidget->layout()));
     tabsAligner.updateLayouts();
     tabsAligner.align();
 
     // Appearance page
 
     const QString appearancePageName = i18n("Appearance");
     auto *appearancePageWidget = new QWidget(this);
     _appearanceUi = new Ui::EditProfileAppearancePage();
     _appearanceUi->setupUi(appearancePageWidget);
     auto *appearancePageItem = addPage(appearancePageWidget, appearancePageName);
     appearancePageItem->setHeader(appearancePageName);
     appearancePageItem->setIcon(QIcon::fromTheme(QStringLiteral("kcolorchooser"),
                                 defaultIcon));
     _pages[appearancePageItem] = Page(&EditProfileDialog::setupAppearancePage);
 
     LabelsAligner appearanceAligner(appearancePageWidget);
     appearanceAligner.addLayout(dynamic_cast<QGridLayout *>(_appearanceUi->miscTabLayout));
     appearanceAligner.addLayout(dynamic_cast<QGridLayout *>(_appearanceUi->contentsGroup->layout()));
     appearanceAligner.updateLayouts();
     appearanceAligner.align();
 
     // Scrolling page
 
     const QString scrollingPageName = i18n("Scrolling");
     auto *scrollingPageWidget = new QWidget(this);
     _scrollingUi = new Ui::EditProfileScrollingPage();
     _scrollingUi->setupUi(scrollingPageWidget);
     auto *scrollingPageItem = addPage(scrollingPageWidget, scrollingPageName);
     scrollingPageItem->setHeader(scrollingPageName);
     scrollingPageItem->setIcon(QIcon::fromTheme(QStringLiteral("transform-move-vertical"),
                                defaultIcon));
     _pages[scrollingPageItem] = Page(&EditProfileDialog::setupScrollingPage);
 
     // adjust "history size" label height to match history size widget's first radio button
     _scrollingUi->historySizeLabel->setFixedHeight(_scrollingUi->historySizeWidget->preferredLabelHeight());
 
     // Keyboard page
 
     const QString keyboardPageName = i18n("Keyboard");
     const QString keyboardPageTitle = i18n("Key bindings");
     auto *keyboardPageWidget = new QWidget(this);
     _keyboardUi = new Ui::EditProfileKeyboardPage();
     _keyboardUi->setupUi(keyboardPageWidget);
     auto *keyboardPageItem = addPage(keyboardPageWidget, keyboardPageName);
     keyboardPageItem->setHeader(keyboardPageTitle);
     keyboardPageItem->setIcon(QIcon::fromTheme(QStringLiteral("input-keyboard"),
                               defaultIcon));
     _pages[keyboardPageItem] = Page(&EditProfileDialog::setupKeyboardPage);
 
     // Mouse page
 
     const QString mousePageName = i18n("Mouse");
     auto *mousePageWidget = new QWidget(this);
     _mouseUi = new Ui::EditProfileMousePage();
     _mouseUi->setupUi(mousePageWidget);
     auto *mousePageItem = addPage(mousePageWidget, mousePageName);
     mousePageItem->setHeader(mousePageName);
     mousePageItem->setIcon(QIcon::fromTheme(QStringLiteral("input-mouse"),
                            defaultIcon));
     _pages[mousePageItem] = Page(&EditProfileDialog::setupMousePage);
 
     // Advanced page
 
     const QString advancedPageName = i18nc("@title:tab Complex options", "Advanced");
     auto *advancedPageWidget = new QWidget(this);
     _advancedUi = new Ui::EditProfileAdvancedPage();
     _advancedUi->setupUi(advancedPageWidget);
     auto *advancedPageItem = addPage(advancedPageWidget, advancedPageName);
     advancedPageItem->setHeader(advancedPageName);
     advancedPageItem->setIcon(QIcon::fromTheme(QStringLiteral("configure"),
                               defaultIcon));
     _pages[advancedPageItem] = Page(&EditProfileDialog::setupAdvancedPage);
 
     // there are various setupXYZPage() methods to load the items
     // for each page and update their states to match the profile
     // being edited.
     //
     // these are only called when needed ( ie. when the user clicks
     // the tab to move to that page ).
     //
     // the _pageNeedsUpdate vector keeps track of the pages that have
     // not been updated since the last profile change and will need
     // to be refreshed when the user switches to them
     connect(this, &KPageDialog::currentPageChanged,
             this, &Konsole::EditProfileDialog::preparePage);
 
     createTempProfile();
 }
 
 EditProfileDialog::~EditProfileDialog()
 {
     delete _generalUi;
     delete _tabsUi;
     delete _appearanceUi;
     delete _scrollingUi;
     delete _keyboardUi;
     delete _mouseUi;
     delete _advancedUi;
 }
 
 void EditProfileDialog::save()
 {
     if (_tempProfile->isEmpty()) {
         return;
     }
 
     ProfileManager::instance()->changeProfile(_profile, _tempProfile->setProperties());
 
     // ensure that these settings are not undone by a call
     // to unpreview()
     QHashIterator<Profile::Property, QVariant> iter(_tempProfile->setProperties());
     while (iter.hasNext()) {
         iter.next();
         _previewedProperties.remove(iter.key());
     }
 
     createTempProfile();
 
     _buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
 }
 
 void EditProfileDialog::reject()
 {
     unpreviewAll();
     QDialog::reject();
 }
 
 void EditProfileDialog::accept()
 {
     // if the Apply button is disabled then no settings were changed
     // or the changes have already been saved by apply()
     if (_buttonBox->button(QDialogButtonBox::Apply)->isEnabled()) {
         if (!isValidProfileName()) {
             return;
         }
         save();
     }
 
     unpreviewAll();
     QDialog::accept();
 }
 
 void EditProfileDialog::apply()
 {
     if (!isValidProfileName()) {
         return;
     }
     save();
 }
 
 bool EditProfileDialog::isValidProfileName()
 {
     Q_ASSERT(_profile);
     Q_ASSERT(_tempProfile);
 
     // check whether the user has enough permissions to save the profile
     QFileInfo fileInfo(_profile->path());
     if (fileInfo.exists() && !fileInfo.isWritable()) {
         if (!_tempProfile->isPropertySet(Profile::Name)
             || (_tempProfile->name() == _profile->name())) {
                 KMessageBox::sorry(this,
                                    i18n("<p>Konsole does not have permission to save this profile to:<br /> \"%1\"</p>"
                                         "<p>To be able to save settings you can either change the permissions "
                                         "of the profile configuration file or change the profile name to save "
                                         "the settings to a new profile.</p>", _profile->path()));
                 return false;
         }
     }
 
     const QList<Profile::Ptr> existingProfiles = ProfileManager::instance()->allProfiles();
     QStringList otherExistingProfileNames;
 
-    foreach(auto existingProfile, existingProfiles) {
+    for (const Profile::Ptr existingProfile : existingProfiles) {
         if (existingProfile->name() != _profile->name()) {
             otherExistingProfileNames.append(existingProfile->name());
         }
     }
 
     if ((_tempProfile->isPropertySet(Profile::Name)
          && _tempProfile->name().isEmpty())
         || (_profile->name().isEmpty() && _tempProfile->name().isEmpty())) {
         KMessageBox::sorry(this,
                            i18n("<p>Each profile must have a name before it can be saved "
                                 "into disk.</p>"));
         // revert the name in the dialog
         _generalUi->profileNameEdit->setText(_profile->name());
         selectProfileName();
         return false;
     } else if (!_tempProfile->name().isEmpty() && otherExistingProfileNames.contains(_tempProfile->name())) {
         KMessageBox::sorry(this,
                             i18n("<p>A profile with this name already exists.</p>"));
         // revert the name in the dialog
         _generalUi->profileNameEdit->setText(_profile->name());
         selectProfileName();
         return false;
     } else {
         return true;
     }
 }
 
 QString EditProfileDialog::groupProfileNames(const ProfileGroup::Ptr &group, int maxLength)
 {
     QString caption;
     int count = group->profiles().count();
     for (int i = 0; i < count; i++) {
         caption += group->profiles()[i]->name();
         if (i < (count - 1)) {
             caption += QLatin1Char(',');
             // limit caption length to prevent very long window titles
             if (maxLength > 0 && caption.length() > maxLength) {
                 caption += QLatin1String("...");
                 break;
             }
         }
     }
     return caption;
 }
 
 void EditProfileDialog::updateCaption(const Profile::Ptr &profile)
 {
     const int MAX_GROUP_CAPTION_LENGTH = 25;
     ProfileGroup::Ptr group = profile->asGroup();
     if (group && group->profiles().count() > 1) {
         QString caption = groupProfileNames(group, MAX_GROUP_CAPTION_LENGTH);
         setWindowTitle(i18np("Editing profile: %2",
                              "Editing %1 profiles: %2",
                              group->profiles().count(),
                              caption));
     } else {
         setWindowTitle(i18n("Edit Profile \"%1\"", profile->name()));
     }
 }
 
 void EditProfileDialog::setProfile(const Konsole::Profile::Ptr &profile)
 {
     Q_ASSERT(profile);
 
     _profile = profile;
 
     // update caption
     updateCaption(profile);
 
     // mark each page of the dialog as out of date
     // and force an update of the currently visible page
     //
     // the other pages will be updated as necessary
     for (Page &page: _pages) {
         page.needsUpdate = true;
     }
     preparePage(currentPage());
 
     if (_tempProfile) {
         createTempProfile();
     }
 }
 
 const Profile::Ptr EditProfileDialog::lookupProfile() const
 {
     return _profile;
 }
 
 const QString EditProfileDialog::currentColorSchemeName() const
 {
     const QString &currentColorSchemeName = lookupProfile()->colorScheme();
     return currentColorSchemeName;
 }
 
 void EditProfileDialog::preparePage(KPageWidgetItem *current, KPageWidgetItem *before)
 {
     Q_UNUSED(before);
     Q_ASSERT(current);
     Q_ASSERT(_pages.contains(current));
 
     const Profile::Ptr profile = lookupProfile();
     auto setupPage = _pages[current].setupPage;
     Q_ASSERT(profile);
     Q_ASSERT(setupPage);
 
     if (_pages[current].needsUpdate) {
         (*this.*setupPage)(profile);
         _pages[current].needsUpdate = false;
     }
 }
 
 void Konsole::EditProfileDialog::selectProfileName()
 {
     _generalUi->profileNameEdit->setFocus();
     _generalUi->profileNameEdit->selectAll();
 }
 
 void EditProfileDialog::setupGeneralPage(const Profile::Ptr &profile)
 {
     // basic profile options
     {
         ProfileGroup::Ptr group = profile->asGroup();
         if (!group || group->profiles().count() < 2) {
             _generalUi->profileNameEdit->setText(profile->name());
             _generalUi->profileNameEdit->setClearButtonEnabled(true);
         } else {
             _generalUi->profileNameEdit->setText(groupProfileNames(group, -1));
             _generalUi->profileNameEdit->setEnabled(false);
         }
     }
 
     ShellCommand command(profile->command(), profile->arguments());
     _generalUi->commandEdit->setText(command.fullCommand());
     // If a "completion" is requested, consider changing this to KLineEdit
     // and using KCompletion.
     _generalUi->initialDirEdit->setText(profile->defaultWorkingDirectory());
     _generalUi->initialDirEdit->setClearButtonEnabled(true);
     _generalUi->initialDirEdit->setPlaceholderText(QStandardPaths::standardLocations(QStandardPaths::HomeLocation).value(0));
 
     _generalUi->dirSelectButton->setIcon(QIcon::fromTheme(QStringLiteral("folder-open")));
     _generalUi->iconSelectButton->setIcon(QIcon::fromTheme(profile->icon()));
     _generalUi->startInSameDirButton->setChecked(profile->startInCurrentSessionDir());
 
     // initial terminal size
     const auto colsSuffix = ki18ncp("Suffix of the number of columns (N columns)", " column", " columns");
     const auto rowsSuffix = ki18ncp("Suffix of the number of rows (N rows)", " row", " rows");
     _generalUi->terminalColumnsEntry->setValue(profile->terminalColumns());
     _generalUi->terminalRowsEntry->setValue(profile->terminalRows());
     _generalUi->terminalColumnsEntry->setSuffix(colsSuffix);
     _generalUi->terminalRowsEntry->setSuffix(rowsSuffix);
     // make width of initial terminal size spinboxes equal
     const int sizeEntryWidth = qMax(maxSpinBoxWidth(_generalUi->terminalColumnsEntry, colsSuffix),
                                     maxSpinBoxWidth(_generalUi->terminalRowsEntry, rowsSuffix));
     _generalUi->terminalColumnsEntry->setFixedWidth(sizeEntryWidth);
     _generalUi->terminalRowsEntry->setFixedWidth(sizeEntryWidth);
 
     // signals and slots
     connect(_generalUi->dirSelectButton, &QToolButton::clicked, this,
             &Konsole::EditProfileDialog::selectInitialDir);
     connect(_generalUi->iconSelectButton, &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::selectIcon);
     connect(_generalUi->startInSameDirButton, &QCheckBox::toggled, this,
             &Konsole::EditProfileDialog::startInSameDir);
     connect(_generalUi->profileNameEdit, &QLineEdit::textChanged, this,
             &Konsole::EditProfileDialog::profileNameChanged);
     connect(_generalUi->initialDirEdit, &QLineEdit::textChanged, this,
             &Konsole::EditProfileDialog::initialDirChanged);
     connect(_generalUi->commandEdit, &QLineEdit::textChanged, this,
             &Konsole::EditProfileDialog::commandChanged);
     connect(_generalUi->environmentEditButton, &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::showEnvironmentEditor);
 
     connect(_generalUi->terminalColumnsEntry,
             QOverload<int>::of(&QSpinBox::valueChanged), this,
             &Konsole::EditProfileDialog::terminalColumnsEntryChanged);
     connect(_generalUi->terminalRowsEntry,
             QOverload<int>::of(&QSpinBox::valueChanged), this,
             &Konsole::EditProfileDialog::terminalRowsEntryChanged);
 }
 
 void EditProfileDialog::showEnvironmentEditor()
 {
     bool ok;
     const Profile::Ptr profile = lookupProfile();
 
     QStringList currentEnvironment;
 
     // The user could re-open the environment editor before clicking
     // OK/Apply in the parent edit profile dialog, so we make sure
     // to show the new environment vars
     if (_tempProfile->isPropertySet(Profile::Environment)) {
             currentEnvironment  = _tempProfile->environment();
     } else {
         currentEnvironment = profile->environment();
     }
 
     QString text = QInputDialog::getMultiLineText(this,
                                                   i18n("Edit Environment"),
                                                   i18n("One environment variable per line"),
                                                   currentEnvironment.join(QLatin1Char('\n')),
                                                   &ok);
 
     QStringList newEnvironment;
 
     if (ok) {
         if(!text.isEmpty()) {
             newEnvironment = text.split(QLatin1Char('\n'));
             updateTempProfileProperty(Profile::Environment, newEnvironment);
         } else {
             // the user could have removed all entries so we return an empty list
             updateTempProfileProperty(Profile::Environment, newEnvironment);
         }
     }
 }
 
 void EditProfileDialog::setupTabsPage(const Profile::Ptr &profile)
 {
     // tab title format
     _tabsUi->renameTabWidget->setTabTitleText(profile->localTabTitleFormat());
     _tabsUi->renameTabWidget->setRemoteTabTitleText(profile->remoteTabTitleFormat());
 
     connect(_tabsUi->renameTabWidget, &Konsole::RenameTabWidget::tabTitleFormatChanged, this,
             &Konsole::EditProfileDialog::tabTitleFormatChanged);
     connect(_tabsUi->renameTabWidget, &Konsole::RenameTabWidget::remoteTabTitleFormatChanged, this,
             &Konsole::EditProfileDialog::remoteTabTitleFormatChanged);
 
     // tab monitoring
     const int silenceSeconds = profile->silenceSeconds();
     _tabsUi->silenceSecondsSpinner->setValue(silenceSeconds);
     auto suffix = ki18ncp("Unit of time", " second", " seconds");
     _tabsUi->silenceSecondsSpinner->setSuffix(suffix);
     int silenceCheckBoxWidth = maxSpinBoxWidth(_generalUi->terminalColumnsEntry, suffix);
     _tabsUi->silenceSecondsSpinner->setFixedWidth(silenceCheckBoxWidth);
 
     connect(_tabsUi->silenceSecondsSpinner,
             QOverload<int>::of(&QSpinBox::valueChanged), this,
             &Konsole::EditProfileDialog::silenceSecondsChanged);
 }
 
 void EditProfileDialog::terminalColumnsEntryChanged(int value)
 {
     updateTempProfileProperty(Profile::TerminalColumns, value);
 }
 
 void EditProfileDialog::terminalRowsEntryChanged(int value)
 {
     updateTempProfileProperty(Profile::TerminalRows, value);
 }
 
 void EditProfileDialog::showTerminalSizeHint(bool value)
 {
     updateTempProfileProperty(Profile::ShowTerminalSizeHint, value);
 }
 
 void EditProfileDialog::setDimWhenInactive(bool value)
 {
     updateTempProfileProperty(Profile::DimWhenInactive, value);
 }
 
 void EditProfileDialog::tabTitleFormatChanged(const QString &format)
 {
     updateTempProfileProperty(Profile::LocalTabTitleFormat, format);
 }
 
 void EditProfileDialog::remoteTabTitleFormatChanged(const QString &format)
 {
     updateTempProfileProperty(Profile::RemoteTabTitleFormat, format);
 }
 
 void EditProfileDialog::silenceSecondsChanged(int seconds)
 {
     updateTempProfileProperty(Profile::SilenceSeconds, seconds);
 }
 
 void EditProfileDialog::selectIcon()
 {
     const QString &icon = KIconDialog::getIcon(KIconLoader::Desktop, KIconLoader::Application,
                                                false, 0, false, this);
     if (!icon.isEmpty()) {
         _generalUi->iconSelectButton->setIcon(QIcon::fromTheme(icon));
         updateTempProfileProperty(Profile::Icon, icon);
     }
 }
 
 void EditProfileDialog::profileNameChanged(const QString &name)
 {
     updateTempProfileProperty(Profile::Name, name);
     updateTempProfileProperty(Profile::UntranslatedName, name);
     updateCaption(_tempProfile);
 }
 
 void EditProfileDialog::startInSameDir(bool sameDir)
 {
     updateTempProfileProperty(Profile::StartInCurrentSessionDir, sameDir);
 }
 
 void EditProfileDialog::initialDirChanged(const QString &dir)
 {
     updateTempProfileProperty(Profile::Directory, dir);
 }
 
 void EditProfileDialog::commandChanged(const QString &command)
 {
     ShellCommand shellCommand(command);
 
     updateTempProfileProperty(Profile::Command, shellCommand.command());
     updateTempProfileProperty(Profile::Arguments, shellCommand.arguments());
 }
 
 void EditProfileDialog::selectInitialDir()
 {
     const QUrl url = QFileDialog::getExistingDirectoryUrl(this,
                                                           i18n("Select Initial Directory"),
                                                           QUrl::fromUserInput(_generalUi->initialDirEdit->text()));
 
     if (!url.isEmpty()) {
         _generalUi->initialDirEdit->setText(url.path());
     }
 }
 
 void EditProfileDialog::setupAppearancePage(const Profile::Ptr &profile)
 {
     auto delegate = new ColorSchemeViewDelegate(this);
     _appearanceUi->colorSchemeList->setItemDelegate(delegate);
 
     _appearanceUi->transparencyWarningWidget->setVisible(false);
     _appearanceUi->transparencyWarningWidget->setWordWrap(true);
     _appearanceUi->transparencyWarningWidget->setCloseButtonVisible(false);
     _appearanceUi->transparencyWarningWidget->setMessageType(KMessageWidget::Warning);
 
     _appearanceUi->colorSchemeMessageWidget->setVisible(false);
     _appearanceUi->colorSchemeMessageWidget->setWordWrap(true);
     _appearanceUi->colorSchemeMessageWidget->setCloseButtonVisible(false);
     _appearanceUi->colorSchemeMessageWidget->setMessageType(KMessageWidget::Warning);
 
     _appearanceUi->editColorSchemeButton->setEnabled(false);
     _appearanceUi->removeColorSchemeButton->setEnabled(false);
     _appearanceUi->resetColorSchemeButton->setEnabled(false);
 
     _appearanceUi->downloadColorSchemeButton->setConfigFile(QStringLiteral("konsole.knsrc"));
 
     // setup color list
     // select the colorScheme used in the current profile
     updateColorSchemeList(currentColorSchemeName());
 
     _appearanceUi->colorSchemeList->setMouseTracking(true);
     _appearanceUi->colorSchemeList->installEventFilter(this);
     _appearanceUi->colorSchemeList->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 
     connect(_appearanceUi->colorSchemeList->selectionModel(),
             &QItemSelectionModel::selectionChanged, this,
             &Konsole::EditProfileDialog::colorSchemeSelected);
     connect(_appearanceUi->colorSchemeList, &QListView::entered, this,
             &Konsole::EditProfileDialog::previewColorScheme);
 
     updateColorSchemeButtons();
 
     connect(_appearanceUi->editColorSchemeButton, &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::editColorScheme);
     connect(_appearanceUi->removeColorSchemeButton, &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::removeColorScheme);
     connect(_appearanceUi->newColorSchemeButton, &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::newColorScheme);
     connect(_appearanceUi->downloadColorSchemeButton, &KNS3::Button::dialogFinished, this,
             &Konsole::EditProfileDialog::gotNewColorSchemes);
 
     connect(_appearanceUi->resetColorSchemeButton, &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::resetColorScheme);
 
     connect(_appearanceUi->chooseFontButton, &QAbstractButton::clicked, this,
             &EditProfileDialog::showFontDialog);
 
     // setup font preview
     const bool antialias = profile->antiAliasFonts();
 
     QFont profileFont = profile->font();
     profileFont.setStyleStrategy(antialias ? QFont::PreferAntialias : QFont::NoAntialias);
 
     _appearanceUi->fontPreview->setFont(profileFont);
     _appearanceUi->fontPreview->setText(QStringLiteral("%1 %2pt").arg(profileFont.family()).arg(profileFont.pointSize()));
 
     // setup font smoothing
     _appearanceUi->antialiasTextButton->setChecked(antialias);
     connect(_appearanceUi->antialiasTextButton, &QCheckBox::toggled, this,
             &Konsole::EditProfileDialog::setAntialiasText);
 
     _appearanceUi->boldIntenseButton->setChecked(profile->boldIntense());
     connect(_appearanceUi->boldIntenseButton, &QCheckBox::toggled, this,
             &Konsole::EditProfileDialog::setBoldIntense);
 
     _appearanceUi->useFontLineCharactersButton->setChecked(profile->useFontLineCharacters());
     connect(_appearanceUi->useFontLineCharactersButton, &QCheckBox::toggled, this,
             &Konsole::EditProfileDialog::useFontLineCharacters);
 
     _mouseUi->enableMouseWheelZoomButton->setChecked(profile->mouseWheelZoomEnabled());
     connect(_mouseUi->enableMouseWheelZoomButton, &QCheckBox::toggled, this,
             &Konsole::EditProfileDialog::toggleMouseWheelZoom);
 
     // cursor options
     const auto options = QVector<BooleanOption>{
         {
             _appearanceUi->enableBlinkingCursorButton, Profile::BlinkingCursorEnabled,
             SLOT(toggleBlinkingCursor(bool))
         },
     };
     setupCheckBoxes(options, profile);
 
     if (profile->useCustomCursorColor()) {
         _appearanceUi->customCursorColorButton->setChecked(true);
     } else {
         _appearanceUi->autoCursorColorButton->setChecked(true);
     }
 
     _appearanceUi->customColorSelectButton->setColor(profile->customCursorColor());
 
     connect(_appearanceUi->customCursorColorButton, &QRadioButton::clicked, this, &Konsole::EditProfileDialog::customCursorColor);
     connect(_appearanceUi->autoCursorColorButton, &QRadioButton::clicked, this, &Konsole::EditProfileDialog::autoCursorColor);
     connect(_appearanceUi->customColorSelectButton, &KColorButton::changed, this, &Konsole::EditProfileDialog::customCursorColorChanged);
 
     // Make radio buttons height equal
     int cursorColorRadioHeight = qMax(_appearanceUi->autoCursorColorButton->minimumSizeHint().height(),
                                       _appearanceUi->customColorSelectButton->minimumSizeHint().height());
     _appearanceUi->autoCursorColorButton->setMinimumHeight(cursorColorRadioHeight);
     _appearanceUi->customCursorColorButton->setMinimumHeight(cursorColorRadioHeight);
 
     const ButtonGroupOptions cursorShapeOptions = {
         _appearanceUi->cursorShape, // group
         Profile::CursorShape,       // profileProperty
         true,                       // preview
         {                           // buttons
             {_appearanceUi->cursorShapeBlock,       Enum::BlockCursor},
             {_appearanceUi->cursorShapeIBeam,       Enum::IBeamCursor},
             {_appearanceUi->cursorShapeUnderline,   Enum::UnderlineCursor},
         },
     };
     setupButtonGroup(cursorShapeOptions, profile);
 
     _appearanceUi->marginsSpinner->setValue(profile->terminalMargin());
     connect(_appearanceUi->marginsSpinner,
             QOverload<int>::of(&QSpinBox::valueChanged), this,
             &Konsole::EditProfileDialog::terminalMarginChanged);
 
     _appearanceUi->lineSpacingSpinner->setValue(profile->lineSpacing());
     connect(_appearanceUi->lineSpacingSpinner,
             QOverload<int>::of(&QSpinBox::valueChanged), this,
             &Konsole::EditProfileDialog::lineSpacingChanged);
 
     _appearanceUi->alignToCenterButton->setChecked(profile->terminalCenter());
     connect(_appearanceUi->alignToCenterButton, &QCheckBox::toggled, this,
             &Konsole::EditProfileDialog::setTerminalCenter);
 
     _appearanceUi->showTerminalSizeHintButton->setChecked(profile->showTerminalSizeHint());
     connect(_appearanceUi->showTerminalSizeHintButton, &QCheckBox::toggled, this,
             &Konsole::EditProfileDialog::showTerminalSizeHint);
 
     _appearanceUi->dimWhenInactiveCheckbox->setChecked(profile->dimWhenInactive());
     connect(_appearanceUi->dimWhenInactiveCheckbox, &QCheckBox::toggled, this,
             &Konsole::EditProfileDialog::setDimWhenInactive);
 }
 
 void EditProfileDialog::setAntialiasText(bool enable)
 {
     preview(Profile::AntiAliasFonts, enable);
     updateTempProfileProperty(Profile::AntiAliasFonts, enable);
 
     const QFont font = _profile->font();
     updateFontPreview(font);
 }
 
 void EditProfileDialog::setBoldIntense(bool enable)
 {
     preview(Profile::BoldIntense, enable);
     updateTempProfileProperty(Profile::BoldIntense, enable);
 }
 
 void EditProfileDialog::useFontLineCharacters(bool enable)
 {
     preview(Profile::UseFontLineCharacters, enable);
     updateTempProfileProperty(Profile::UseFontLineCharacters, enable);
 }
 
 void EditProfileDialog::toggleBlinkingCursor(bool enable)
 {
     preview(Profile::BlinkingCursorEnabled, enable);
     updateTempProfileProperty(Profile::BlinkingCursorEnabled, enable);
 }
 
 void EditProfileDialog::setCursorShape(int index)
 {
     preview(Profile::CursorShape, index);
     updateTempProfileProperty(Profile::CursorShape, index);
 }
 
 void EditProfileDialog::autoCursorColor()
 {
     preview(Profile::UseCustomCursorColor, false);
     updateTempProfileProperty(Profile::UseCustomCursorColor, false);
 }
 
 void EditProfileDialog::customCursorColor()
 {
     preview(Profile::UseCustomCursorColor, true);
     updateTempProfileProperty(Profile::UseCustomCursorColor, true);
 }
 
 void EditProfileDialog::customCursorColorChanged(const QColor &color)
 {
     preview(Profile::CustomCursorColor, color);
     updateTempProfileProperty(Profile::CustomCursorColor, color);
 
     // ensure that custom cursor colors are enabled
     _appearanceUi->customCursorColorButton->click();
 }
 
 void EditProfileDialog::terminalMarginChanged(int margin)
 {
     preview(Profile::TerminalMargin, margin);
     updateTempProfileProperty(Profile::TerminalMargin, margin);
 }
 
 void EditProfileDialog::lineSpacingChanged(int spacing)
 {
     preview(Profile::LineSpacing, spacing);
     updateTempProfileProperty(Profile::LineSpacing, spacing);
 }
 
 void EditProfileDialog::setTerminalCenter(bool enable)
 {
     preview(Profile::TerminalCenter, enable);
     updateTempProfileProperty(Profile::TerminalCenter, enable);
 }
 
 void EditProfileDialog::toggleMouseWheelZoom(bool enable)
 {
     updateTempProfileProperty(Profile::MouseWheelZoomEnabled, enable);
 }
 
 void EditProfileDialog::toggleAlternateScrolling(bool enable)
 {
     updateTempProfileProperty(Profile::AlternateScrolling, enable);
 }
 
 void EditProfileDialog::updateColorSchemeList(const QString &selectedColorSchemeName)
 {
     if (_appearanceUi->colorSchemeList->model() == nullptr) {
         _appearanceUi->colorSchemeList->setModel(new QStandardItemModel(this));
     }
 
     const ColorScheme *selectedColorScheme = ColorSchemeManager::instance()->findColorScheme(selectedColorSchemeName);
 
     auto *model = qobject_cast<QStandardItemModel *>(_appearanceUi->colorSchemeList->model());
 
     Q_ASSERT(model);
 
     model->clear();
 
     QStandardItem *selectedItem = nullptr;
 
-    QList<const ColorScheme *> schemeList = ColorSchemeManager::instance()->allColorSchemes();
+   const QList<const ColorScheme *> schemeList = ColorSchemeManager::instance()->allColorSchemes();
 
-    foreach (const ColorScheme *scheme, schemeList) {
+    for (const ColorScheme *scheme : schemeList) {
         QStandardItem *item = new QStandardItem(scheme->description());
         item->setData(QVariant::fromValue(scheme), Qt::UserRole + 1);
         item->setData(QVariant::fromValue(_profile->font()), Qt::UserRole + 2);
         item->setFlags(item->flags());
 
         // if selectedColorSchemeName is not empty then select that scheme
         // after saving the changes in the colorScheme editor
         if (selectedColorScheme == scheme) {
             selectedItem = item;
         }
 
         model->appendRow(item);
     }
 
     model->sort(0);
 
     if (selectedItem != nullptr) {
         _appearanceUi->colorSchemeList->updateGeometry();
         _appearanceUi->colorSchemeList->selectionModel()->setCurrentIndex(selectedItem->index(),
                                                                 QItemSelectionModel::Select);
 
         // update transparency warning label
         updateTransparencyWarning();
     }
 }
 
 void EditProfileDialog::updateKeyBindingsList(const QString &selectKeyBindingsName)
 {
     if (_keyboardUi->keyBindingList->model() == nullptr) {
         _keyboardUi->keyBindingList->setModel(new QStandardItemModel(this));
     }
 
     auto *model = qobject_cast<QStandardItemModel *>(_keyboardUi->keyBindingList->model());
 
     Q_ASSERT(model);
 
     model->clear();
 
     QStandardItem *selectedItem = nullptr;
 
     const QStringList &translatorNames = _keyManager->allTranslators();
     for (const QString &translatorName : translatorNames) {
         const KeyboardTranslator *translator = _keyManager->findTranslator(translatorName);
         if (translator == nullptr) {
             continue;
         }
 
         QStandardItem *item = new QStandardItem(translator->description());
         item->setEditable(false);
         item->setData(QVariant::fromValue(translator), Qt::UserRole + 1);
         item->setData(QVariant::fromValue(_keyManager->findTranslatorPath(translatorName)), Qt::ToolTipRole);
         item->setData(QVariant::fromValue(_profile->font()), Qt::UserRole + 2);
         item->setIcon(QIcon::fromTheme(QStringLiteral("preferences-desktop-keyboard")));
 
         if (selectKeyBindingsName == translatorName) {
             selectedItem = item;
         }
 
         model->appendRow(item);
     }
 
     model->sort(0);
 
     if (selectedItem != nullptr) {
         _keyboardUi->keyBindingList->selectionModel()->setCurrentIndex(selectedItem->index(),
                                                                QItemSelectionModel::Select);
     }
 }
 
 bool EditProfileDialog::eventFilter(QObject *watched, QEvent *event)
 {
     if (watched == _appearanceUi->colorSchemeList && event->type() == QEvent::Leave) {
         if (_tempProfile->isPropertySet(Profile::ColorScheme)) {
             preview(Profile::ColorScheme, _tempProfile->colorScheme());
         } else {
             unpreview(Profile::ColorScheme);
         }
     }
 
     return QDialog::eventFilter(watched, event);
 }
 
 QSize EditProfileDialog::sizeHint() const
 {
     QFontMetrics fm(font());
     const int ch = fm.boundingRect(QLatin1Char('0')).width();
 
     // By default minimum size is used. Increase it to make text inputs
     // on "tabs" page wider and to add some whitespace on right side
     // of other pages. The window will not be wider than 2/3 of
     // the screen width (unless necessary to fit everything)
     return QDialog::sizeHint() + QSize(10*ch, 0);
 }
 
 void EditProfileDialog::unpreviewAll()
 {
     _delayedPreviewTimer->stop();
     _delayedPreviewProperties.clear();
 
     QHash<Profile::Property, QVariant> map;
     QHashIterator<int, QVariant> iter(_previewedProperties);
     while (iter.hasNext()) {
         iter.next();
         map.insert(static_cast<Profile::Property>(iter.key()), iter.value());
     }
 
     // undo any preview changes
     if (!map.isEmpty()) {
         ProfileManager::instance()->changeProfile(_profile, map, false);
     }
 }
 
 void EditProfileDialog::unpreview(int property)
 {
     _delayedPreviewProperties.remove(property);
 
     if (!_previewedProperties.contains(property)) {
         return;
     }
 
     QHash<Profile::Property, QVariant> map;
     map.insert(static_cast<Profile::Property>(property), _previewedProperties[property]);
     ProfileManager::instance()->changeProfile(_profile, map, false);
 
     _previewedProperties.remove(property);
 }
 
 void EditProfileDialog::delayedPreview(int property, const QVariant &value)
 {
     _delayedPreviewProperties.insert(property, value);
 
     _delayedPreviewTimer->stop();
     _delayedPreviewTimer->start(300);
 }
 
 void EditProfileDialog::delayedPreviewActivate()
 {
     Q_ASSERT(qobject_cast<QTimer *>(sender()));
 
     QMutableHashIterator<int, QVariant> iter(_delayedPreviewProperties);
     if (iter.hasNext()) {
         iter.next();
         preview(iter.key(), iter.value());
     }
 }
 
 void EditProfileDialog::preview(int property, const QVariant &value)
 {
     QHash<Profile::Property, QVariant> map;
     map.insert(static_cast<Profile::Property>(property), value);
 
     _delayedPreviewProperties.remove(property);
 
     const Profile::Ptr original = lookupProfile();
 
     // skip previews for profile groups if the profiles in the group
     // have conflicting original values for the property
     //
     // TODO - Save the original values for each profile and use to unpreview properties
     ProfileGroup::Ptr group = original->asGroup();
     if (group && group->profiles().count() > 1
         && original->property<QVariant>(static_cast<Profile::Property>(property)).isNull()) {
         return;
     }
 
     if (!_previewedProperties.contains(property)) {
         _previewedProperties.insert(property,
                                     original->property<QVariant>(static_cast<Profile::Property>(property)));
     }
 
     // temporary change to color scheme
     ProfileManager::instance()->changeProfile(_profile, map, false);
 }
 
 void EditProfileDialog::previewColorScheme(const QModelIndex &index)
 {
     const QString &name = index.data(Qt::UserRole + 1).value<const ColorScheme *>()->name();
     delayedPreview(Profile::ColorScheme, name);
 }
 
 void EditProfileDialog::showFontDialog()
 {
     if (_fontDialog == nullptr) {
         _fontDialog = new FontDialog(this);
         connect(_fontDialog, &FontDialog::fontChanged, this, [this](const QFont &font) {
             preview(Profile::Font, font);
             updateFontPreview(font);
         });
         connect(_fontDialog, &FontDialog::accepted, this, [this]() {
             const QFont font = _fontDialog->font();
             preview(Profile::Font, font);
             updateTempProfileProperty(Profile::Font, font);
             updateFontPreview(font);
         });
         connect(_fontDialog, &FontDialog::rejected, this, [this]() {
             unpreview(Profile::Font);
             const QFont font = _profile->font();
             updateFontPreview(font);
         });
     }
     const QFont font = _profile->font();
     _fontDialog->setFont(font);
     _fontDialog->exec();
 }
 
 void EditProfileDialog::updateFontPreview(QFont font)
 {
     bool aa = _profile->antiAliasFonts();
     font.setStyleStrategy(aa ? QFont::PreferAntialias : QFont::NoAntialias);
 
     _appearanceUi->fontPreview->setFont(font);
     _appearanceUi->fontPreview->setText(QStringLiteral("%1 %2pt").arg(font.family()).arg(font.pointSize()));
 }
 
 void EditProfileDialog::removeColorScheme()
 {
     QModelIndexList selected = _appearanceUi->colorSchemeList->selectionModel()->selectedIndexes();
     if (selected.isEmpty()) {
         return;
     }
 
     // The actual delete runs async because we need to on-demand query
     // files managed by KNS. Deleting files managed by KNS screws up the
     // KNS states (entry gets shown as installed when in fact we deleted it).
     auto *manager = new KNSCore::DownloadManager(QStringLiteral("konsole.knsrc"), this);
     connect(manager, &KNSCore::DownloadManager::searchResult,
             this, [=](const KNSCore::EntryInternal::List &entries) {
         const QString &name = selected.first().data(Qt::UserRole + 1).value<const ColorScheme *>()->name();
         Q_ASSERT(!name.isEmpty());
         bool uninstalled = false;
         // Check if the theme was installed by KNS, if so uninstall it through
         // there and unload it.
         for (auto &entry : entries) {
             for (const auto &file : entry.installedFiles()) {
                 if (ColorSchemeManager::colorSchemeNameFromPath(file) != name) {
                     continue;
                 }
                 // Make sure the manager can unload it before uninstalling it.
                 if (ColorSchemeManager::instance()->unloadColorScheme(file)) {
                     manager->uninstallEntry(entry);
                     uninstalled = true;
                 }
             }
             if (uninstalled) {
                 break;
             }
         }
 
         // If KNS wasn't able to remove it is a custom theme and we'll drop
         // it manually.
         if (!uninstalled) {
             uninstalled = ColorSchemeManager::instance()->deleteColorScheme(name);
         }
 
         if (uninstalled) {
             _appearanceUi->colorSchemeList->model()->removeRow(selected.first().row());
         }
 
         manager->deleteLater();
     });
     manager->checkForInstalled();
 }
 
 void EditProfileDialog::gotNewColorSchemes(const KNS3::Entry::List &changedEntries)
 {
     int failures = 0;
     for (auto &entry : qAsConst(changedEntries)) {
         switch (entry.status()) {
         case KNS3::Entry::Installed:
             for (const auto &file : entry.installedFiles()) {
                 if (ColorSchemeManager::instance()->loadColorScheme(file)) {
                     continue;
                 }
                 qWarning() << "Failed to load file" << file;
                 ++failures;
             }
             if (failures == entry.installedFiles().size()) {
                 _appearanceUi->colorSchemeMessageWidget->setText(
                             xi18nc("@info",
                                    "Scheme <resource>%1</resource> failed to load.",
                                    entry.name()));
                 _appearanceUi->colorSchemeMessageWidget->animatedShow();
                 QTimer::singleShot(8000,
                                    _appearanceUi->colorSchemeMessageWidget,
                                    &KMessageWidget::animatedHide);
             }
             break;
         case KNS3::Entry::Deleted:
             for (const auto &file : entry.uninstalledFiles()) {
                 if (ColorSchemeManager::instance()->unloadColorScheme(file)) {
                     continue;
                 }
                 qWarning() << "Failed to unload file" << file;
                 // If unloading fails we do not care. Iff the scheme failed here
                 // it either wasn't loaded or was invalid to begin with.
             }
             break;
         case KNS3::Entry::Invalid:
         case KNS3::Entry::Installing:
         case KNS3::Entry::Downloadable:
         case KNS3::Entry::Updateable:
         case KNS3::Entry::Updating:
             // Not interesting.
             break;
         }
     }
     updateColorSchemeList(currentColorSchemeName());
 }
 
 void EditProfileDialog::resetColorScheme()
 {
 
     QModelIndexList selected = _appearanceUi->colorSchemeList->selectionModel()->selectedIndexes();
 
     if (!selected.isEmpty()) {
         const QString &name = selected.first().data(Qt::UserRole + 1).value<const ColorScheme *>()->name();
 
         ColorSchemeManager::instance()->deleteColorScheme(name);
 
         // select the colorScheme used in the current profile
         updateColorSchemeList(currentColorSchemeName());
     }
 }
 
 void EditProfileDialog::showColorSchemeEditor(bool isNewScheme)
 {
     // Finding selected ColorScheme
     QModelIndexList selected = _appearanceUi->colorSchemeList->selectionModel()->selectedIndexes();
     QAbstractItemModel *model = _appearanceUi->colorSchemeList->model();
     const ColorScheme *colors = nullptr;
     if (!selected.isEmpty()) {
         colors = model->data(selected.first(), Qt::UserRole + 1).value<const ColorScheme *>();
     } else {
         colors = ColorSchemeManager::instance()->defaultColorScheme();
     }
 
     Q_ASSERT(colors);
 
     // Setting up ColorSchemeEditor ui
     // close any running ColorSchemeEditor
     if (_colorDialog != nullptr) {
         closeColorSchemeEditor();
     }
     _colorDialog = new ColorSchemeEditor(this);
 
     connect(_colorDialog, &Konsole::ColorSchemeEditor::colorSchemeSaveRequested, this,
             &Konsole::EditProfileDialog::saveColorScheme);
     _colorDialog->setup(colors, isNewScheme);
 
     _colorDialog->show();
 }
 
 void EditProfileDialog::closeColorSchemeEditor()
 {
     if (_colorDialog != nullptr) {
         _colorDialog->close();
         delete _colorDialog;
     }
 }
 
 void EditProfileDialog::newColorScheme()
 {
     showColorSchemeEditor(true);
 }
 
 void EditProfileDialog::editColorScheme()
 {
     showColorSchemeEditor(false);
 }
 
 void EditProfileDialog::saveColorScheme(const ColorScheme &scheme, bool isNewScheme)
 {
     auto newScheme = new ColorScheme(scheme);
 
     // if this is a new color scheme, pick a name based on the description
     if (isNewScheme) {
         newScheme->setName(newScheme->description());
     }
 
     ColorSchemeManager::instance()->addColorScheme(newScheme);
 
     const QString &selectedColorSchemeName = newScheme->name();
 
     // select the edited or the new colorScheme after saving the changes
     updateColorSchemeList(selectedColorSchemeName);
 
     preview(Profile::ColorScheme, newScheme->name());
 }
 
 void EditProfileDialog::colorSchemeSelected()
 {
     QModelIndexList selected = _appearanceUi->colorSchemeList->selectionModel()->selectedIndexes();
 
     if (!selected.isEmpty()) {
         QAbstractItemModel *model = _appearanceUi->colorSchemeList->model();
         const auto *colors = model->data(selected.first(), Qt::UserRole + 1).value<const ColorScheme *>();
         if (colors != nullptr) {
             updateTempProfileProperty(Profile::ColorScheme, colors->name());
             previewColorScheme(selected.first());
 
             updateTransparencyWarning();
         }
     }
 
     updateColorSchemeButtons();
 }
 
 void EditProfileDialog::updateColorSchemeButtons()
 {
     enableIfNonEmptySelection(_appearanceUi->editColorSchemeButton, _appearanceUi->colorSchemeList->selectionModel());
 
     QModelIndexList selected = _appearanceUi->colorSchemeList->selectionModel()->selectedIndexes();
 
     if (!selected.isEmpty()) {
         const QString &name = selected.first().data(Qt::UserRole + 1).value<const ColorScheme *>()->name();
 
         bool isResettable = ColorSchemeManager::instance()->canResetColorScheme(name);
         _appearanceUi->resetColorSchemeButton->setEnabled(isResettable);
 
         bool isDeletable = ColorSchemeManager::instance()->isColorSchemeDeletable(name);
         // if a colorScheme can be restored then it can't be deleted
         _appearanceUi->removeColorSchemeButton->setEnabled(isDeletable && !isResettable);
     } else {
         _appearanceUi->removeColorSchemeButton->setEnabled(false);
         _appearanceUi->resetColorSchemeButton->setEnabled(false);
     }
 
 }
 
 void EditProfileDialog::updateKeyBindingsButtons()
 {
     QModelIndexList selected = _keyboardUi->keyBindingList->selectionModel()->selectedIndexes();
 
     if (!selected.isEmpty()) {
         _keyboardUi->editKeyBindingsButton->setEnabled(true);
 
         const QString &name = selected.first().data(Qt::UserRole + 1).value<const KeyboardTranslator *>()->name();
 
         bool isResettable = _keyManager->isTranslatorResettable(name);
         _keyboardUi->resetKeyBindingsButton->setEnabled(isResettable);
 
         bool isDeletable = _keyManager->isTranslatorDeletable(name);
 
         // if a key bindings scheme can be reset then it can't be deleted
         _keyboardUi->removeKeyBindingsButton->setEnabled(isDeletable && !isResettable);
     }
 }
 
 void EditProfileDialog::enableIfNonEmptySelection(QWidget *widget, QItemSelectionModel *selectionModel)
 {
     widget->setEnabled(selectionModel->hasSelection());
 }
 
 void EditProfileDialog::updateTransparencyWarning()
 {
     // zero or one indexes can be selected
-    foreach (const QModelIndex &index, _appearanceUi->colorSchemeList->selectionModel()->selectedIndexes()) {
+    const QModelIndexList selected = _appearanceUi->colorSchemeList->selectionModel()->selectedIndexes();
+    for (const QModelIndex &index : selected) {
         bool needTransparency = index.data(Qt::UserRole + 1).value<const ColorScheme *>()->opacity() < 1.0;
 
         if (!needTransparency) {
             _appearanceUi->transparencyWarningWidget->setHidden(true);
         } else if (!KWindowSystem::compositingActive()) {
             _appearanceUi->transparencyWarningWidget->setText(i18n(
                                                         "This color scheme uses a transparent background"
                                                         " which does not appear to be supported on your"
                                                         " desktop"));
             _appearanceUi->transparencyWarningWidget->setHidden(false);
         } else if (!WindowSystemInfo::HAVE_TRANSPARENCY) {
             _appearanceUi->transparencyWarningWidget->setText(i18n(
                                                         "Konsole was started before desktop effects were enabled."
                                                         " You need to restart Konsole to see transparent background."));
             _appearanceUi->transparencyWarningWidget->setHidden(false);
         }
     }
 }
 
 void EditProfileDialog::createTempProfile()
 {
     _tempProfile = Profile::Ptr(new Profile);
     _tempProfile->setHidden(true);
 }
 
 void EditProfileDialog::updateTempProfileProperty(Profile::Property property, const QVariant &value)
 {
     _tempProfile->setProperty(property, value);
     updateButtonApply();
 }
 
 void EditProfileDialog::updateButtonApply()
 {
     bool userModified = false;
 
     QHashIterator<Profile::Property, QVariant> iter(_tempProfile->setProperties());
     while (iter.hasNext()) {
         iter.next();
 
         Profile::Property property = iter.key();
         QVariant value = iter.value();
 
         // for previewed property
         if (_previewedProperties.contains(static_cast<int>(property))) {
             if (value != _previewedProperties.value(static_cast<int>(property))) {
                 userModified = true;
                 break;
             }
         // for not-previewed property
         //
         // for the Profile::KeyBindings property, if it's set in the _tempProfile
         // then the user opened the edit key bindings dialog and clicked
         // OK, and could have add/removed a key bindings rule
         } else if (property == Profile::KeyBindings || (value != _profile->property<QVariant>(property))) {
             userModified = true;
             break;
         }
     }
 
     _buttonBox->button(QDialogButtonBox::Apply)->setEnabled(userModified);
 }
 
 void EditProfileDialog::setupKeyboardPage(const Profile::Ptr &/* profile */)
 {
     // setup translator list
     updateKeyBindingsList(lookupProfile()->keyBindings());
 
     connect(_keyboardUi->keyBindingList->selectionModel(),
             &QItemSelectionModel::selectionChanged, this,
             &Konsole::EditProfileDialog::keyBindingSelected);
     connect(_keyboardUi->newKeyBindingsButton, &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::newKeyBinding);
 
     _keyboardUi->editKeyBindingsButton->setEnabled(false);
     _keyboardUi->removeKeyBindingsButton->setEnabled(false);
     _keyboardUi->resetKeyBindingsButton->setEnabled(false);
 
     updateKeyBindingsButtons();
 
     connect(_keyboardUi->editKeyBindingsButton, &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::editKeyBinding);
     connect(_keyboardUi->removeKeyBindingsButton, &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::removeKeyBinding);
     connect(_keyboardUi->resetKeyBindingsButton, &QPushButton::clicked, this,
             &Konsole::EditProfileDialog::resetKeyBindings);
 }
 
 void EditProfileDialog::keyBindingSelected()
 {
     QModelIndexList selected = _keyboardUi->keyBindingList->selectionModel()->selectedIndexes();
 
     if (!selected.isEmpty()) {
         QAbstractItemModel *model = _keyboardUi->keyBindingList->model();
         const auto *translator = model->data(selected.first(), Qt::UserRole + 1)
                                                .value<const KeyboardTranslator *>();
         if (translator != nullptr) {
             updateTempProfileProperty(Profile::KeyBindings, translator->name());
         }
     }
 
     updateKeyBindingsButtons();
 }
 
 void EditProfileDialog::removeKeyBinding()
 {
     QModelIndexList selected = _keyboardUi->keyBindingList->selectionModel()->selectedIndexes();
 
     if (!selected.isEmpty()) {
         const QString &name = selected.first().data(Qt::UserRole + 1).value<const KeyboardTranslator *>()->name();
         if (KeyboardTranslatorManager::instance()->deleteTranslator(name)) {
             _keyboardUi->keyBindingList->model()->removeRow(selected.first().row());
         }
     }
 }
 
 void EditProfileDialog::showKeyBindingEditor(bool isNewTranslator)
 {
     QModelIndexList selected = _keyboardUi->keyBindingList->selectionModel()->selectedIndexes();
     QAbstractItemModel *model = _keyboardUi->keyBindingList->model();
 
     const KeyboardTranslator *translator = nullptr;
     if (!selected.isEmpty()) {
         translator = model->data(selected.first(), Qt::UserRole + 1).value<const KeyboardTranslator *>();
     } else {
         translator = _keyManager->defaultTranslator();
     }
 
     Q_ASSERT(translator);
 
     auto editor = new KeyBindingEditor(this);
 
     if (translator != nullptr) {
         editor->setup(translator, lookupProfile()->keyBindings(), isNewTranslator);
     }
 
     connect(editor, &Konsole::KeyBindingEditor::updateKeyBindingsListRequest,
             this, &Konsole::EditProfileDialog::updateKeyBindingsList);
 
     connect(editor, &Konsole::KeyBindingEditor::updateTempProfileKeyBindingsRequest,
             this, &Konsole::EditProfileDialog::updateTempProfileProperty);
 
     editor->exec();
 }
 
 void EditProfileDialog::newKeyBinding()
 {
     showKeyBindingEditor(true);
 }
 
 void EditProfileDialog::editKeyBinding()
 {
     showKeyBindingEditor(false);
 }
 
 void EditProfileDialog::resetKeyBindings()
 {
     QModelIndexList selected = _keyboardUi->keyBindingList->selectionModel()->selectedIndexes();
 
     if (!selected.isEmpty()) {
         const QString &name = selected.first().data(Qt::UserRole + 1).value<const KeyboardTranslator *>()->name();
 
         _keyManager->deleteTranslator(name);
         // find and load the translator
         _keyManager->findTranslator(name);
 
         updateKeyBindingsList(name);
     }
 }
 
 void EditProfileDialog::setupCheckBoxes(const QVector<BooleanOption>& options, const Profile::Ptr &profile)
 {
     for(const auto& option : options) {
         option.button->setChecked(profile->property<bool>(option.property));
         connect(option.button, SIGNAL(toggled(bool)), this, option.slot);
     }
 }
 
 void EditProfileDialog::setupRadio(const QVector<RadioOption>& possibilities, int actual)
 {
     for(const auto& possibility : possibilities) {
         possibility.button->setChecked(possibility.value == actual);
         connect(possibility.button, SIGNAL(clicked()), this, possibility.slot);
     }
 }
 
 void EditProfileDialog::setupButtonGroup(const ButtonGroupOptions &options, const Profile::Ptr &profile)
 {
     auto currentValue = profile->property<int>(options.profileProperty);
 
     for (auto option: options.buttons) {
         options.group->setId(option.button, option.value);
     }
 
     Q_ASSERT(options.buttons.count() > 0);
     auto *activeButton = options.group->button(currentValue);
     if (activeButton == nullptr) {
         activeButton = options.buttons[0].button;
     }
     activeButton->setChecked(true);
 
     connect(options.group, QOverload<int>::of(&QButtonGroup::buttonClicked),
             this, [this, options](int value) {
         if (options.preview) {
             preview(options.profileProperty, value);
         }
         updateTempProfileProperty(options.profileProperty, value);
     });
 }
 
 void EditProfileDialog::setupScrollingPage(const Profile::Ptr &profile)
 {
     // setup scrollbar radio
     const ButtonGroupOptions scrollBarPositionOptions = {
         _scrollingUi->scrollBarPosition,    // group
         Profile::ScrollBarPosition,         // profileProperty
         false,                              // preview
         {                                   // buttons
             {_scrollingUi->scrollBarRightButton,    Enum::ScrollBarRight},
             {_scrollingUi->scrollBarLeftButton,     Enum::ScrollBarLeft},
             {_scrollingUi->scrollBarHiddenButton,   Enum::ScrollBarHidden},
         },
     };
     setupButtonGroup(scrollBarPositionOptions, profile);
 
     // setup scrollback type radio
     auto scrollBackType = profile->property<int>(Profile::HistoryMode);
     _scrollingUi->historySizeWidget->setMode(Enum::HistoryModeEnum(scrollBackType));
     connect(_scrollingUi->historySizeWidget, &Konsole::HistorySizeWidget::historyModeChanged, this,
             &Konsole::EditProfileDialog::historyModeChanged);
 
     // setup scrollback line count spinner
     const int historySize = profile->historySize();
     _scrollingUi->historySizeWidget->setLineCount(historySize);
 
     // setup scrollpageamount type radio
     auto scrollFullPage = profile->property<int>(Profile::ScrollFullPage);
 
     const auto pageamounts = QVector<RadioOption>{
         {_scrollingUi->scrollHalfPage, Enum::ScrollPageHalf, SLOT(scrollHalfPage())},
         {_scrollingUi->scrollFullPage, Enum::ScrollPageFull, SLOT(scrollFullPage())}
     };
 
     setupRadio(pageamounts, scrollFullPage);
 
     // signals and slots
     connect(_scrollingUi->historySizeWidget, &Konsole::HistorySizeWidget::historySizeChanged, this,
             &Konsole::EditProfileDialog::historySizeChanged);
 }
 
 void EditProfileDialog::historySizeChanged(int lineCount)
 {
     updateTempProfileProperty(Profile::HistorySize, lineCount);
 }
 
 void EditProfileDialog::historyModeChanged(Enum::HistoryModeEnum mode)
 {
     updateTempProfileProperty(Profile::HistoryMode, mode);
 }
 
 void EditProfileDialog::scrollFullPage()
 {
     updateTempProfileProperty(Profile::ScrollFullPage, Enum::ScrollPageFull);
 }
 
 void EditProfileDialog::scrollHalfPage()
 {
     updateTempProfileProperty(Profile::ScrollFullPage, Enum::ScrollPageHalf);
 }
 
 void EditProfileDialog::setupMousePage(const Profile::Ptr &profile)
 {
     const auto options = QVector<BooleanOption>{
         {
             _mouseUi->underlineLinksButton, Profile::UnderlineLinksEnabled,
             SLOT(toggleUnderlineLinks(bool))
         },
         {
             _mouseUi->underlineFilesButton, Profile::UnderlineFilesEnabled,
             SLOT(toggleUnderlineFiles(bool))
         },
         {
             _mouseUi->ctrlRequiredForDragButton, Profile::CtrlRequiredForDrag,
             SLOT(toggleCtrlRequiredForDrag(bool))
         },
         {
             _mouseUi->copyTextAsHTMLButton, Profile::CopyTextAsHTML,
             SLOT(toggleCopyTextAsHTML(bool))
         },
         {
             _mouseUi->copyTextToClipboardButton, Profile::AutoCopySelectedText,
             SLOT(toggleCopyTextToClipboard(bool))
         },
         {
             _mouseUi->trimLeadingSpacesButton, Profile::TrimLeadingSpacesInSelectedText,
             SLOT(toggleTrimLeadingSpacesInSelectedText(bool))
         },
         {
             _mouseUi->trimTrailingSpacesButton, Profile::TrimTrailingSpacesInSelectedText,
             SLOT(toggleTrimTrailingSpacesInSelectedText(bool))
         },
         {
             _mouseUi->openLinksByDirectClickButton, Profile::OpenLinksByDirectClickEnabled,
             SLOT(toggleOpenLinksByDirectClick(bool))
         },
         {
             _mouseUi->dropUrlsAsText, Profile::DropUrlsAsText,
             SLOT(toggleDropUrlsAsText(bool))
         },
         {
             _mouseUi->enableAlternateScrollingButton, Profile::AlternateScrolling,
             SLOT(toggleAlternateScrolling(bool))
         }
     };
     setupCheckBoxes(options, profile);
 
     // setup middle click paste mode
     const auto middleClickPasteMode = profile->property<int>(Profile::MiddleClickPasteMode);
     const auto pasteModes = QVector<RadioOption> {
         {_mouseUi->pasteFromX11SelectionButton, Enum::PasteFromX11Selection, SLOT(pasteFromX11Selection())},
         {_mouseUi->pasteFromClipboardButton, Enum::PasteFromClipboard, SLOT(pasteFromClipboard())}    };
     setupRadio(pasteModes, middleClickPasteMode);
 
     // interaction options
     _mouseUi->wordCharacterEdit->setText(profile->wordCharacters());
 
     connect(_mouseUi->wordCharacterEdit, &QLineEdit::textChanged, this, &Konsole::EditProfileDialog::wordCharactersChanged);
 
     const ButtonGroupOptions tripleClickModeOptions = {
         _mouseUi->tripleClickMode,  // group
         Profile::TripleClickMode,   // profileProperty
         false,                      // preview
         {                           // buttons
             {_mouseUi->tripleClickSelectsTheWholeLine,      Enum::SelectWholeLine},
             {_mouseUi->tripleClickSelectsFromMousePosition, Enum::SelectForwardsFromCursor},
         },
     };
     setupButtonGroup(tripleClickModeOptions, profile);
 
     _mouseUi->openLinksByDirectClickButton->setEnabled(_mouseUi->underlineLinksButton->isChecked() || _mouseUi->underlineFilesButton->isChecked());
 
     _mouseUi->enableMouseWheelZoomButton->setChecked(profile->mouseWheelZoomEnabled());
     connect(_mouseUi->enableMouseWheelZoomButton, &QCheckBox::toggled, this, &Konsole::EditProfileDialog::toggleMouseWheelZoom);
 }
 
 void EditProfileDialog::setupAdvancedPage(const Profile::Ptr &profile)
 {
     const auto options = QVector<BooleanOption>{
         {
             _advancedUi->enableBlinkingTextButton, Profile::BlinkingTextEnabled,
             SLOT(toggleBlinkingText(bool))
         },
         {
             _advancedUi->enableFlowControlButton, Profile::FlowControlEnabled,
             SLOT(toggleFlowControl(bool))
         },
         {
             _appearanceUi->enableBlinkingCursorButton, Profile::BlinkingCursorEnabled,
             SLOT(toggleBlinkingCursor(bool))
         },
         {
             _advancedUi->enableBidiRenderingButton, Profile::BidiRenderingEnabled,
             SLOT(togglebidiRendering(bool))
         },
         {
             _advancedUi->enableReverseUrlHints, Profile::ReverseUrlHints,
             SLOT(toggleReverseUrlHints(bool))
         }
     };
     setupCheckBoxes(options, profile);
 
     // Setup the URL hints modifier checkboxes
     {
         auto modifiers = profile->property<int>(Profile::UrlHintsModifiers);
         _advancedUi->urlHintsModifierShift->setChecked((modifiers &Qt::ShiftModifier) != 0u);
         _advancedUi->urlHintsModifierCtrl->setChecked((modifiers &Qt::ControlModifier) != 0u);
         _advancedUi->urlHintsModifierAlt->setChecked((modifiers &Qt::AltModifier) != 0u);
         _advancedUi->urlHintsModifierMeta->setChecked((modifiers &Qt::MetaModifier) != 0u);
         connect(_advancedUi->urlHintsModifierShift, &QCheckBox::toggled, this, &EditProfileDialog::updateUrlHintsModifier);
         connect(_advancedUi->urlHintsModifierCtrl, &QCheckBox::toggled, this, &EditProfileDialog::updateUrlHintsModifier);
         connect(_advancedUi->urlHintsModifierAlt, &QCheckBox::toggled, this, &EditProfileDialog::updateUrlHintsModifier);
         connect(_advancedUi->urlHintsModifierMeta, &QCheckBox::toggled, this, &EditProfileDialog::updateUrlHintsModifier);
     }
 
     // encoding options
     auto codecAction = new KCodecAction(this);
     _advancedUi->selectEncodingButton->setMenu(codecAction->menu());
     connect(codecAction,
             QOverload<QTextCodec *>::of(&KCodecAction::triggered), this,
             &Konsole::EditProfileDialog::setDefaultCodec);
 
     _advancedUi->selectEncodingButton->setText(profile->defaultEncoding());
 }
 
 int EditProfileDialog::maxSpinBoxWidth(const KPluralHandlingSpinBox *spinBox, const KLocalizedString &suffix)
 {
     static const int cursorWidth = 2;
 
     const QFontMetrics fm(spinBox->fontMetrics());
     const QString plural    = suffix.subs(2).toString();
     const QString singular  = suffix.subs(1).toString();
     const QString min       = QString::number(spinBox->minimum());
     const QString max       = QString::number(spinBox->maximum());
     const int pluralWidth   = fm.boundingRect(plural).width();
     const int singularWidth = fm.boundingRect(singular).width();
     const int minWidth      = fm.boundingRect(min).width();
     const int maxWidth      = fm.boundingRect(max).width();
     const int width         = qMax(pluralWidth, singularWidth) + qMax(minWidth, maxWidth) + cursorWidth;
 
     // Based on QAbstractSpinBox::initStyleOption() from Qt
     QStyleOptionSpinBox opt;
     opt.initFrom(spinBox);
     opt.activeSubControls   = QStyle::SC_None;
     opt.buttonSymbols       = spinBox->buttonSymbols();
     // Assume all spinboxes have buttons
     opt.subControls         = QStyle::SC_SpinBoxFrame | QStyle::SC_SpinBoxEditField
                             | QStyle::SC_SpinBoxUp | QStyle::SC_SpinBoxDown;
     opt.frame               = spinBox->hasFrame();
 
     const QSize hint(width, spinBox->sizeHint().height());
     const QSize spinBoxSize = style()->sizeFromContents(QStyle::CT_SpinBox, &opt, hint, spinBox)
                               .expandedTo(QApplication::globalStrut());
 
     return spinBoxSize.width();
 }
 
 void EditProfileDialog::setDefaultCodec(QTextCodec *codec)
 {
     QString name = QString::fromLocal8Bit(codec->name());
 
     updateTempProfileProperty(Profile::DefaultEncoding, name);
     _advancedUi->selectEncodingButton->setText(name);
 }
 
 void EditProfileDialog::wordCharactersChanged(const QString &text)
 {
     updateTempProfileProperty(Profile::WordCharacters, text);
 }
 
 void EditProfileDialog::togglebidiRendering(bool enable)
 {
     updateTempProfileProperty(Profile::BidiRenderingEnabled, enable);
 }
 
 void EditProfileDialog::toggleUnderlineLinks(bool enable)
 {
     updateTempProfileProperty(Profile::UnderlineLinksEnabled, enable);
 
     bool enableClick = _mouseUi->underlineFilesButton->isChecked() || enable;
     _mouseUi->openLinksByDirectClickButton->setEnabled(enableClick);
 }
 
 void EditProfileDialog::toggleUnderlineFiles(bool enable)
 {
     updateTempProfileProperty(Profile::UnderlineFilesEnabled, enable);
 
     bool enableClick = _mouseUi->underlineLinksButton->isChecked() || enable;
     _mouseUi->openLinksByDirectClickButton->setEnabled(enableClick);
 }
 
 void EditProfileDialog::toggleCtrlRequiredForDrag(bool enable)
 {
     updateTempProfileProperty(Profile::CtrlRequiredForDrag, enable);
 }
 
 void EditProfileDialog::toggleDropUrlsAsText(bool enable)
 {
     updateTempProfileProperty(Profile::DropUrlsAsText, enable);
 }
 
 void EditProfileDialog::toggleOpenLinksByDirectClick(bool enable)
 {
     updateTempProfileProperty(Profile::OpenLinksByDirectClickEnabled, enable);
 }
 
 void EditProfileDialog::toggleCopyTextAsHTML(bool enable)
 {
     updateTempProfileProperty(Profile::CopyTextAsHTML, enable);
 }
 
 void EditProfileDialog::toggleCopyTextToClipboard(bool enable)
 {
     updateTempProfileProperty(Profile::AutoCopySelectedText, enable);
 }
 
 void EditProfileDialog::toggleTrimLeadingSpacesInSelectedText(bool enable)
 {
     updateTempProfileProperty(Profile::TrimLeadingSpacesInSelectedText, enable);
 }
 
 void EditProfileDialog::toggleTrimTrailingSpacesInSelectedText(bool enable)
 {
     updateTempProfileProperty(Profile::TrimTrailingSpacesInSelectedText, enable);
 }
 
 void EditProfileDialog::pasteFromX11Selection()
 {
     updateTempProfileProperty(Profile::MiddleClickPasteMode, Enum::PasteFromX11Selection);
 }
 
 void EditProfileDialog::pasteFromClipboard()
 {
     updateTempProfileProperty(Profile::MiddleClickPasteMode, Enum::PasteFromClipboard);
 }
 
 void EditProfileDialog::TripleClickModeChanged(int newValue)
 {
     updateTempProfileProperty(Profile::TripleClickMode, newValue);
 }
 
 void EditProfileDialog::updateUrlHintsModifier(bool)
 {
     Qt::KeyboardModifiers modifiers;
     if (_advancedUi->urlHintsModifierShift->isChecked()) {
         modifiers |= Qt::ShiftModifier;
     }
     if (_advancedUi->urlHintsModifierCtrl->isChecked()) {
         modifiers |= Qt::ControlModifier;
     }
     if (_advancedUi->urlHintsModifierAlt->isChecked()) {
         modifiers |= Qt::AltModifier;
     }
     if (_advancedUi->urlHintsModifierMeta->isChecked()) {
         modifiers |= Qt::MetaModifier;
     }
     updateTempProfileProperty(Profile::UrlHintsModifiers, int(modifiers));
 }
 
 void EditProfileDialog::toggleReverseUrlHints(bool enable)
 {
     updateTempProfileProperty(Profile::ReverseUrlHints, enable);
 }
 
 void EditProfileDialog::toggleBlinkingText(bool enable)
 {
     updateTempProfileProperty(Profile::BlinkingTextEnabled, enable);
 }
 
 void EditProfileDialog::toggleFlowControl(bool enable)
 {
     updateTempProfileProperty(Profile::FlowControlEnabled, enable);
 }
 
 ColorSchemeViewDelegate::ColorSchemeViewDelegate(QObject *parent) :
     QAbstractItemDelegate(parent)
 {
 }
 
 void ColorSchemeViewDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     const auto *scheme = index.data(Qt::UserRole + 1).value<const ColorScheme *>();
     QFont profileFont = index.data(Qt::UserRole + 2).value<QFont>();
     Q_ASSERT(scheme);
     if (scheme == nullptr) {
         return;
     }
 
     painter->setRenderHint(QPainter::Antialiasing);
 
     // Draw background
     QStyle *style = option.widget != nullptr ? option.widget->style() : QApplication::style();
     style->drawPrimitive(QStyle::PE_PanelItemViewItem, &option, painter, option.widget);
 
     // Draw name
     QPalette::ColorRole textColor = ((option.state & QStyle::State_Selected) != 0)
                                     ? QPalette::HighlightedText : QPalette::Text;
     painter->setPen(option.palette.color(textColor));
     painter->setFont(option.font);
 
     // Determine width of sample text using profile's font
     const QString sampleText = i18n("AaZz09...");
     QFontMetrics profileFontMetrics(profileFont);
     const int sampleTextWidth = profileFontMetrics.boundingRect(sampleText).width();
 
     painter->drawText(option.rect.adjusted(sampleTextWidth + 15, 0, 0, 0),
                       Qt::AlignLeft | Qt::AlignVCenter,
                       index.data(Qt::DisplayRole).toString());
 
     // Draw the preview
     const int x = option.rect.left();
     const int y = option.rect.top();
 
     QRect previewRect(x + 4, y + 4, sampleTextWidth + 8, option.rect.height() - 8);
 
     bool transparencyAvailable = KWindowSystem::compositingActive();
 
     if (transparencyAvailable) {
         painter->save();
         QColor color = scheme->backgroundColor();
         color.setAlphaF(scheme->opacity());
         painter->setPen(Qt::NoPen);
         painter->setCompositionMode(QPainter::CompositionMode_Source);
         painter->setBrush(color);
         painter->drawRect(previewRect);
         painter->restore();
     } else {
         painter->setPen(Qt::NoPen);
         painter->setBrush(scheme->backgroundColor());
         painter->drawRect(previewRect);
     }
 
     // draw color scheme name using scheme's foreground color
     QPen pen(scheme->foregroundColor());
     painter->setPen(pen);
 
     // TODO: respect antialias setting
     painter->setFont(profileFont);
     painter->drawText(previewRect, Qt::AlignCenter, sampleText);
 }
 
 QSize ColorSchemeViewDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex & /*index*/) const
 {
     const int width = 200;
     const int margin = 5;
     const int colorWidth = width / TABLE_COLORS;
     const int heightForWidth = (colorWidth * 2) + option.fontMetrics.height() + margin;
 
     // temporary
     return {width, heightForWidth};
 }
diff --git a/src/Emulation.cpp b/src/Emulation.cpp
index fab70f25..612ea350 100644
--- a/src/Emulation.cpp
+++ b/src/Emulation.cpp
@@ -1,346 +1,346 @@
 /*
     Copyright 2007-2008 Robert Knight <robertknight@gmail.com>
     Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
     Copyright 1996 by Matthias Ettrich <ettrich@kde.org>
 
     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 "Emulation.h"
 
 // Qt
 #include <QKeyEvent>
 
 // Konsole
 #include "KeyboardTranslator.h"
 #include "KeyboardTranslatorManager.h"
 #include "Screen.h"
 #include "ScreenWindow.h"
 
 using namespace Konsole;
 
 Emulation::Emulation() :
     _windows(QList<ScreenWindow *>()),
     _currentScreen(nullptr),
     _codec(nullptr),
     _decoder(nullptr),
     _keyTranslator(nullptr),
     _usesMouseTracking(false),
     _bracketedPasteMode(false),
     _bulkTimer1(new QTimer(this)),
     _bulkTimer2(new QTimer(this)),
     _imageSizeInitialized(false)
 {
     // create screens with a default size
     _screen[0] = new Screen(40, 80);
     _screen[1] = new Screen(40, 80);
     _currentScreen = _screen[0];
 
     QObject::connect(&_bulkTimer1, &QTimer::timeout, this, &Konsole::Emulation::showBulk);
     QObject::connect(&_bulkTimer2, &QTimer::timeout, this, &Konsole::Emulation::showBulk);
 
     // listen for mouse status changes
     connect(this, &Konsole::Emulation::programRequestsMouseTracking, this,
             &Konsole::Emulation::setUsesMouseTracking);
     connect(this, &Konsole::Emulation::programBracketedPasteModeChanged, this,
             &Konsole::Emulation::bracketedPasteModeChanged);
 }
 
 bool Emulation::programUsesMouseTracking() const
 {
     return _usesMouseTracking;
 }
 
 void Emulation::setUsesMouseTracking(bool usesMouseTracking)
 {
     _usesMouseTracking = usesMouseTracking;
 }
 
 bool Emulation::programBracketedPasteMode() const
 {
     return _bracketedPasteMode;
 }
 
 void Emulation::bracketedPasteModeChanged(bool bracketedPasteMode)
 {
     _bracketedPasteMode = bracketedPasteMode;
 }
 
 ScreenWindow *Emulation::createWindow()
 {
     auto window = new ScreenWindow(_currentScreen);
     _windows << window;
 
     connect(window, &Konsole::ScreenWindow::selectionChanged, this,
             &Konsole::Emulation::bufferedUpdate);
     connect(window, &Konsole::ScreenWindow::selectionChanged, this,
             &Konsole::Emulation::checkSelectedText);
 
     connect(this, &Konsole::Emulation::outputChanged, window,
             &Konsole::ScreenWindow::notifyOutputChanged);
 
     return window;
 }
 
 void Emulation::checkScreenInUse()
 {
     emit primaryScreenInUse(_currentScreen == _screen[0]);
 }
 
 void Emulation::checkSelectedText()
 {
     QString text = _currentScreen->selectedText(Screen::PreserveLineBreaks);
     emit selectionChanged(text);
 }
 
 Emulation::~Emulation()
 {
-    foreach (ScreenWindow *window, _windows) {
+    for (ScreenWindow *window : qAsConst(_windows)) {
         delete window;
     }
 
     delete _screen[0];
     delete _screen[1];
     delete _decoder;
 }
 
 void Emulation::setScreen(int index)
 {
     Screen *oldScreen = _currentScreen;
     _currentScreen = _screen[index & 1];
     if (_currentScreen != oldScreen) {
         // tell all windows onto this emulation to switch to the newly active screen
-        foreach (ScreenWindow *window, _windows) {
+        for (ScreenWindow *window : qAsConst(_windows)) {
             window->setScreen(_currentScreen);
         }
 
         checkScreenInUse();
         checkSelectedText();
     }
 }
 
 void Emulation::clearHistory()
 {
     _screen[0]->setScroll(_screen[0]->getScroll(), false);
 }
 
 void Emulation::setHistory(const HistoryType &history)
 {
     _screen[0]->setScroll(history);
 
     showBulk();
 }
 
 const HistoryType &Emulation::history() const
 {
     return _screen[0]->getScroll();
 }
 
 void Emulation::setCodec(const QTextCodec *codec)
 {
     if (codec != nullptr) {
         _codec = codec;
 
         delete _decoder;
         _decoder = _codec->makeDecoder();
 
         emit useUtf8Request(utf8());
     } else {
         setCodec(LocaleCodec);
     }
 }
 
 void Emulation::setCodec(EmulationCodec codec)
 {
     if (codec == Utf8Codec) {
         setCodec(QTextCodec::codecForName("utf8"));
     } else if (codec == LocaleCodec) {
         setCodec(QTextCodec::codecForLocale());
     }
 }
 
 void Emulation::setKeyBindings(const QString &name)
 {
     _keyTranslator = KeyboardTranslatorManager::instance()->findTranslator(name);
     if (_keyTranslator == nullptr) {
         _keyTranslator = KeyboardTranslatorManager::instance()->defaultTranslator();
     }
 }
 
 QString Emulation::keyBindings() const
 {
     return _keyTranslator->name();
 }
 
 // process application unicode input to terminal
 // this is a trivial scanner
 void Emulation::receiveChar(uint c)
 {
     c &= 0xff;
     switch (c) {
     case '\b':
         _currentScreen->backspace();
         break;
     case '\t':
         _currentScreen->tab();
         break;
     case '\n':
         _currentScreen->newLine();
         break;
     case '\r':
         _currentScreen->toStartOfLine();
         break;
     case 0x07:
         emit stateSet(NOTIFYBELL);
         break;
     default:
         _currentScreen->displayCharacter(c);
         break;
     }
 }
 
 void Emulation::sendKeyEvent(QKeyEvent *ev)
 {
     emit stateSet(NOTIFYNORMAL);
 
     if (!ev->text().isEmpty()) {
         // A block of text
         // Note that the text is proper unicode.
         // We should do a conversion here
         emit sendData(ev->text().toLocal8Bit());
     }
 }
 
 void Emulation::sendMouseEvent(int /*buttons*/, int /*column*/, int /*row*/, int /*eventType*/)
 {
     // default implementation does nothing
 }
 
 /*
    We are doing code conversion from locale to unicode first.
 */
 
 void Emulation::receiveData(const char *text, int length)
 {
     emit stateSet(NOTIFYACTIVITY);
 
     bufferedUpdate();
 
     QVector<uint> unicodeText = _decoder->toUnicode(text, length).toUcs4();
 
     //send characters to terminal emulator
     for (auto &&i : unicodeText) {
         receiveChar(i);
     }
 
     //look for z-modem indicator
     //-- someone who understands more about z-modems that I do may be able to move
     //this check into the above for loop?
     for (int i = 0; i < length; i++) {
         if (text[i] == '\030') {
             if (length - i - 1 > 3) {
                 if (qstrncmp(text + i + 1, "B00", 3) == 0) {
                     emit zmodemDownloadDetected();
                 } else if (qstrncmp(text + i + 1, "B01", 3) == 0) {
                     emit zmodemUploadDetected();
                 }
             }
         }
     }
 }
 
 void Emulation::writeToStream(TerminalCharacterDecoder *decoder, int startLine, int endLine)
 {
     _currentScreen->writeLinesToStream(decoder, startLine, endLine);
 }
 
 int Emulation::lineCount() const
 {
     // sum number of lines currently on _screen plus number of lines in history
     return _currentScreen->getLines() + _currentScreen->getHistLines();
 }
 
 void Emulation::showBulk()
 {
     _bulkTimer1.stop();
     _bulkTimer2.stop();
 
     emit outputChanged();
 
     _currentScreen->resetScrolledLines();
     _currentScreen->resetDroppedLines();
 }
 
 void Emulation::bufferedUpdate()
 {
     static const int BULK_TIMEOUT1 = 10;
     static const int BULK_TIMEOUT2 = 40;
 
     _bulkTimer1.setSingleShot(true);
     _bulkTimer1.start(BULK_TIMEOUT1);
     if (!_bulkTimer2.isActive()) {
         _bulkTimer2.setSingleShot(true);
         _bulkTimer2.start(BULK_TIMEOUT2);
     }
 }
 
 char Emulation::eraseChar() const
 {
     return '\b';
 }
 
 void Emulation::setImageSize(int lines, int columns)
 {
     if ((lines < 1) || (columns < 1)) {
         return;
     }
 
     QSize screenSize[2] = {
         QSize(_screen[0]->getColumns(),
               _screen[0]->getLines()),
         QSize(_screen[1]->getColumns(),
               _screen[1]->getLines())
     };
     QSize newSize(columns, lines);
 
     if (newSize == screenSize[0] && newSize == screenSize[1]) {
         // If this method is called for the first time, always emit
         // SIGNAL(imageSizeChange()), even if the new size is the same as the
         // current size.  See #176902
         if (!_imageSizeInitialized) {
             emit imageSizeChanged(lines, columns);
         }
     } else {
         _screen[0]->resizeImage(lines, columns);
         _screen[1]->resizeImage(lines, columns);
 
         emit imageSizeChanged(lines, columns);
 
         bufferedUpdate();
     }
 
     if (!_imageSizeInitialized) {
         _imageSizeInitialized = true;
 
         emit imageSizeInitialized();
     }
 }
 
 QSize Emulation::imageSize() const
 {
     return {_currentScreen->getColumns(), _currentScreen->getLines()};
 }
diff --git a/src/ExtendedCharTable.cpp b/src/ExtendedCharTable.cpp
index 181eca60..c209c7a1 100644
--- a/src/ExtendedCharTable.cpp
+++ b/src/ExtendedCharTable.cpp
@@ -1,156 +1,157 @@
 /*
     This file is part of Konsole, an X terminal.
 
     Copyright 2007-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 "ExtendedCharTable.h"
 
 #include "konsoledebug.h"
 
 // Konsole
 #include "TerminalDisplay.h"
 #include "SessionManager.h"
 #include "Session.h"
 #include "Screen.h"
 
 using namespace Konsole;
 
 ExtendedCharTable::ExtendedCharTable() :
     _extendedCharTable(QHash<uint, uint *>())
 {
 }
 
 ExtendedCharTable::~ExtendedCharTable()
 {
     // free all allocated character buffers
     QHashIterator<uint, uint *> iter(_extendedCharTable);
     while (iter.hasNext()) {
         iter.next();
         delete[] iter.value();
     }
 }
 
 // global instance
 ExtendedCharTable ExtendedCharTable::instance;
 
 uint ExtendedCharTable::createExtendedChar(const uint *unicodePoints, ushort length)
 {
     // look for this sequence of points in the table
     uint hash = extendedCharHash(unicodePoints, length);
     const uint initialHash = hash;
     bool triedCleaningSolution = false;
 
     // check existing entry for match
     while (_extendedCharTable.contains(hash) && hash != 0) { // 0 has a special meaning for chars so we don't use it
         if (extendedCharMatch(hash, unicodePoints, length)) {
             // this sequence already has an entry in the table,
             // return its hash
             return hash;
         } else {
             // if hash is already used by another, different sequence of unicode character
             // points then try next hash
             hash++;
 
             if (hash == initialHash) {
                 if (!triedCleaningSolution) {
                     triedCleaningSolution = true;
                     // All the hashes are full, go to all Screens and try to free any
                     // This is slow but should happen very rarely
                     QSet<uint> usedExtendedChars;
-                    const SessionManager *sm = SessionManager::instance();
-                    foreach (const Session *s, sm->sessions()) {
-                        foreach (const TerminalDisplay *td, s->views()) {
-                            usedExtendedChars += td->screenWindow()->screen()->usedExtendedChars();
+                    const QList<Session *> list = SessionManager::instance()->sessions();
+                    for (const Session *s : list) {
+                        const QList<TerminalDisplay *> displayList = s->views();
+                        for (const TerminalDisplay *display : displayList) {
+                            usedExtendedChars += display->screenWindow()->screen()->usedExtendedChars();
                         }
                     }
 
                     QHash<uint, uint *>::iterator it = _extendedCharTable.begin();
                     QHash<uint, uint *>::iterator itEnd = _extendedCharTable.end();
                     while (it != itEnd) {
                         if (usedExtendedChars.contains(it.key())) {
                             ++it;
                         } else {
                             it = _extendedCharTable.erase(it);
                         }
                     }
                 } else {
                     qCDebug(KonsoleDebug) << "Using all the extended char hashes, going to miss this extended character";
                     return 0;
                 }
             }
         }
     }
 
     // add the new sequence to the table and
     // return that index
     auto buffer = new uint[length + 1];
     buffer[0] = length;
     for (int i = 0; i < length; i++) {
         buffer[i + 1] = unicodePoints[i];
     }
 
     _extendedCharTable.insert(hash, buffer);
 
     return hash;
 }
 
 uint *ExtendedCharTable::lookupExtendedChar(uint hash, ushort &length) const
 {
     // look up index in table and if found, set the length
     // argument and return a pointer to the character sequence
 
     uint *buffer = _extendedCharTable[hash];
     if (buffer != nullptr) {
         length = ushort(buffer[0]);
         return buffer + 1;
     } else {
         length = 0;
         return nullptr;
     }
 }
 
 uint ExtendedCharTable::extendedCharHash(const uint *unicodePoints, ushort length) const
 {
     uint hash = 0;
     for (ushort i = 0; i < length; i++) {
         hash = 31 * hash + unicodePoints[i];
     }
     return hash;
 }
 
 bool ExtendedCharTable::extendedCharMatch(uint hash, const uint *unicodePoints,
                                           ushort length) const
 {
     uint *entry = _extendedCharTable[hash];
 
     // compare given length with stored sequence length ( given as the first ushort in the
     // stored buffer )
     if (entry == nullptr || entry[0] != length) {
         return false;
     }
     // if the lengths match, each character must be checked.  the stored buffer starts at
     // entry[1]
     for (int i = 0; i < length; i++) {
         if (entry[i + 1] != unicodePoints[i]) {
             return false;
         }
     }
     return true;
 }
diff --git a/src/Filter.cpp b/src/Filter.cpp
index f889534f..fb52b6dc 100644
--- a/src/Filter.cpp
+++ b/src/Filter.cpp
@@ -1,637 +1,637 @@
 /*
     Copyright 2007-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 "Filter.h"
 
 #include "konsoledebug.h"
 
 // Qt
 #include <QAction>
 #include <QApplication>
 #include <QClipboard>
 #include <QDir>
 #include <QMimeDatabase>
 #include <QString>
 #include <QTextStream>
 #include <QUrl>
 
 // KDE
 #include <KLocalizedString>
 #include <KRun>
 
 // Konsole
 #include "Session.h"
 #include "TerminalCharacterDecoder.h"
 
 using namespace Konsole;
 
 FilterChain::~FilterChain()
 {
     QMutableListIterator<Filter *> iter(*this);
 
     while (iter.hasNext()) {
         Filter *filter = iter.next();
         iter.remove();
         delete filter;
     }
 }
 
 void FilterChain::addFilter(Filter *filter)
 {
     append(filter);
 }
 
 void FilterChain::removeFilter(Filter *filter)
 {
     removeAll(filter);
 }
 
 void FilterChain::reset()
 {
     QListIterator<Filter *> iter(*this);
     while (iter.hasNext()) {
         iter.next()->reset();
     }
 }
 
 void FilterChain::setBuffer(const QString *buffer, const QList<int> *linePositions)
 {
     QListIterator<Filter *> iter(*this);
     while (iter.hasNext()) {
         iter.next()->setBuffer(buffer, linePositions);
     }
 }
 
 void FilterChain::process()
 {
     QListIterator<Filter *> iter(*this);
     while (iter.hasNext()) {
         iter.next()->process();
     }
 }
 
 void FilterChain::clear()
 {
     QList<Filter *>::clear();
 }
 
 Filter::HotSpot *FilterChain::hotSpotAt(int line, int column) const
 {
     QListIterator<Filter *> iter(*this);
     while (iter.hasNext()) {
         Filter *filter = iter.next();
         Filter::HotSpot *spot = filter->hotSpotAt(line, column);
         if (spot != nullptr) {
             return spot;
         }
     }
 
     return nullptr;
 }
 
 QList<Filter::HotSpot *> FilterChain::hotSpots() const
 {
     QList<Filter::HotSpot *> list;
     QListIterator<Filter *> iter(*this);
     while (iter.hasNext()) {
         Filter *filter = iter.next();
         list << filter->hotSpots();
     }
     return list;
 }
 
 TerminalImageFilterChain::TerminalImageFilterChain() :
     _buffer(nullptr),
     _linePositions(nullptr)
 {
 }
 
 TerminalImageFilterChain::~TerminalImageFilterChain()
 {
     delete _buffer;
     delete _linePositions;
 }
 
 void TerminalImageFilterChain::setImage(const Character * const image, int lines, int columns,
                                         const QVector<LineProperty> &lineProperties)
 {
     if (empty()) {
         return;
     }
 
     // reset all filters and hotspots
     reset();
 
     PlainTextDecoder decoder;
     decoder.setLeadingWhitespace(true);
     decoder.setTrailingWhitespace(true);
 
     // setup new shared buffers for the filters to process on
     auto newBuffer = new QString();
     auto newLinePositions = new QList<int>();
     setBuffer(newBuffer, newLinePositions);
 
     // free the old buffers
     delete _buffer;
     delete _linePositions;
 
     _buffer = newBuffer;
     _linePositions = newLinePositions;
 
     QTextStream lineStream(_buffer);
     decoder.begin(&lineStream);
 
     for (int i = 0; i < lines; i++) {
         _linePositions->append(_buffer->length());
         decoder.decodeLine(image + i * columns, columns, LINE_DEFAULT);
 
         // pretend that each line ends with a newline character.
         // this prevents a link that occurs at the end of one line
         // being treated as part of a link that occurs at the start of the next line
         //
         // the downside is that links which are spread over more than one line are not
         // highlighted.
         //
         // TODO - Use the "line wrapped" attribute associated with lines in a
         // terminal image to avoid adding this imaginary character for wrapped
         // lines
         if ((lineProperties.value(i, LINE_DEFAULT) & LINE_WRAPPED) == 0) {
             lineStream << QLatin1Char('\n');
         }
     }
     decoder.end();
 }
 
 Filter::Filter() :
     _hotspots(QMultiHash<int, HotSpot *>()),
     _hotspotList(QList<HotSpot *>()),
     _linePositions(nullptr),
     _buffer(nullptr)
 {
 }
 
 Filter::~Filter()
 {
     reset();
 }
 
 void Filter::reset()
 {
     _hotspots.clear();
     QListIterator<HotSpot *> iter(_hotspotList);
     while (iter.hasNext()) {
         delete iter.next();
     }
     _hotspotList.clear();
 }
 
 void Filter::setBuffer(const QString *buffer, const QList<int> *linePositions)
 {
     _buffer = buffer;
     _linePositions = linePositions;
 }
 
 void Filter::getLineColumn(int position, int &startLine, int &startColumn)
 {
     Q_ASSERT(_linePositions);
     Q_ASSERT(_buffer);
 
     for (int i = 0; i < _linePositions->count(); i++) {
         int nextLine = 0;
 
         if (i == _linePositions->count() - 1) {
             nextLine = _buffer->length() + 1;
         } else {
             nextLine = _linePositions->value(i + 1);
         }
 
         if (_linePositions->value(i) <= position && position < nextLine) {
             startLine = i;
             startColumn = Character::stringWidth(buffer()->mid(_linePositions->value(i),
                                                      position - _linePositions->value(i)));
             return;
         }
     }
 }
 
 const QString *Filter::buffer()
 {
     return _buffer;
 }
 
 Filter::HotSpot::~HotSpot() = default;
 
 void Filter::addHotSpot(HotSpot *spot)
 {
     _hotspotList << spot;
 
     for (int line = spot->startLine(); line <= spot->endLine(); line++) {
         _hotspots.insert(line, spot);
     }
 }
 
 QList<Filter::HotSpot *> Filter::hotSpots() const
 {
     return _hotspotList;
 }
 
 Filter::HotSpot *Filter::hotSpotAt(int line, int column) const
 {
-    QList<HotSpot *> hotspots = _hotspots.values(line);
+    const QList<HotSpot *> hotspots = _hotspots.values(line);
 
-    foreach (HotSpot *spot, hotspots) {
+    for (HotSpot *spot : hotspots) {
         if (spot->startLine() == line && spot->startColumn() > column) {
             continue;
         }
         if (spot->endLine() == line && spot->endColumn() < column) {
             continue;
         }
 
         return spot;
     }
 
     return nullptr;
 }
 
 Filter::HotSpot::HotSpot(int startLine, int startColumn, int endLine, int endColumn) :
     _startLine(startLine),
     _startColumn(startColumn),
     _endLine(endLine),
     _endColumn(endColumn),
     _type(NotSpecified)
 {
 }
 
 QList<QAction *> Filter::HotSpot::actions()
 {
     return QList<QAction *>();
 }
 
 int Filter::HotSpot::startLine() const
 {
     return _startLine;
 }
 
 int Filter::HotSpot::endLine() const
 {
     return _endLine;
 }
 
 int Filter::HotSpot::startColumn() const
 {
     return _startColumn;
 }
 
 int Filter::HotSpot::endColumn() const
 {
     return _endColumn;
 }
 
 Filter::HotSpot::Type Filter::HotSpot::type() const
 {
     return _type;
 }
 
 void Filter::HotSpot::setType(Type type)
 {
     _type = type;
 }
 
 RegExpFilter::RegExpFilter() :
     _searchText(QRegularExpression())
 {
 }
 
 RegExpFilter::HotSpot::HotSpot(int startLine, int startColumn, int endLine, int endColumn,
                                const QStringList &capturedTexts) :
     Filter::HotSpot(startLine, startColumn, endLine, endColumn),
     _capturedTexts(capturedTexts)
 {
     setType(Marker);
 }
 
 void RegExpFilter::HotSpot::activate(QObject *)
 {
 }
 
 QStringList RegExpFilter::HotSpot::capturedTexts() const
 {
     return _capturedTexts;
 }
 
 void RegExpFilter::setRegExp(const QRegularExpression &regExp)
 {
     _searchText = regExp;
     _searchText.optimize();
 }
 
 QRegularExpression RegExpFilter::regExp() const
 {
     return _searchText;
 }
 
 void RegExpFilter::process()
 {
     const QString *text = buffer();
 
     Q_ASSERT(text);
 
     if (!_searchText.isValid() || _searchText.pattern().isEmpty()) {
         return;
     }
 
     QRegularExpressionMatchIterator iterator(_searchText.globalMatch(*text));
     while (iterator.hasNext()) {
         QRegularExpressionMatch match(iterator.next());
 
         int startLine = 0;
         int endLine = 0;
         int startColumn = 0;
         int endColumn = 0;
 
         getLineColumn(match.capturedStart(), startLine, startColumn);
         getLineColumn(match.capturedEnd(), endLine, endColumn);
 
         RegExpFilter::HotSpot *spot = newHotSpot(startLine, startColumn,
                                                  endLine, endColumn, match.capturedTexts());
         if (spot == nullptr) {
             continue;
         }
 
         addHotSpot(spot);
     }
 }
 
 RegExpFilter::HotSpot *RegExpFilter::newHotSpot(int startLine, int startColumn, int endLine,
                                                 int endColumn, const QStringList &capturedTexts)
 {
     return new RegExpFilter::HotSpot(startLine, startColumn,
                                      endLine, endColumn, capturedTexts);
 }
 
 RegExpFilter::HotSpot *UrlFilter::newHotSpot(int startLine, int startColumn, int endLine,
                                              int endColumn, const QStringList &capturedTexts)
 {
     return new UrlFilter::HotSpot(startLine, startColumn,
                                   endLine, endColumn, capturedTexts);
 }
 
 UrlFilter::HotSpot::HotSpot(int startLine, int startColumn, int endLine, int endColumn,
                             const QStringList &capturedTexts) :
     RegExpFilter::HotSpot(startLine, startColumn, endLine, endColumn, capturedTexts),
     _urlObject(new FilterObject(this))
 {
     setType(Link);
 }
 
 UrlFilter::HotSpot::UrlType UrlFilter::HotSpot::urlType() const
 {
     const QString url = capturedTexts().at(0);
 
     if (FullUrlRegExp.match(url).hasMatch()) {
         return StandardUrl;
     } else if (EmailAddressRegExp.match(url).hasMatch()) {
         return Email;
     } else {
         return Unknown;
     }
 }
 
 void UrlFilter::HotSpot::activate(QObject *object)
 {
     QString url = capturedTexts().at(0);
 
     const UrlType kind = urlType();
 
     const QString &actionName = object != nullptr ? object->objectName() : QString();
 
     if (actionName == QLatin1String("copy-action")) {
         QApplication::clipboard()->setText(url);
         return;
     }
 
     if ((object == nullptr) || actionName == QLatin1String("open-action")) {
         if (kind == StandardUrl) {
             // if the URL path does not include the protocol ( eg. "www.kde.org" ) then
             // prepend http:// ( eg. "www.kde.org" --> "http://www.kde.org" )
             if (!url.contains(QLatin1String("://"))) {
                 url.prepend(QLatin1String("http://"));
             }
         } else if (kind == Email) {
             url.prepend(QLatin1String("mailto:"));
         }
 
         new KRun(QUrl(url), QApplication::activeWindow());
     }
 }
 
 // Note:  Altering these regular expressions can have a major effect on the performance of the filters
 // used for finding URLs in the text, especially if they are very general and could match very long
 // pieces of text.
 // Please be careful when altering them.
 
 //regexp matches:
 // full url:
 // protocolname:// or www. followed by anything other than whitespaces, <, >, ' or ", and ends before whitespaces, <, >, ', ", ], !, ), :, comma and dot
 const QRegularExpression UrlFilter::FullUrlRegExp(QStringLiteral("(www\\.(?!\\.)|[a-z][a-z0-9+.-]*://)[^\\s<>'\"]+[^!,\\.\\s<>'\"\\]\\)\\:]"),
                                                   QRegularExpression::OptimizeOnFirstUsageOption);
 // email address:
 // [word chars, dots or dashes]@[word chars, dots or dashes].[word chars]
 const QRegularExpression UrlFilter::EmailAddressRegExp(QStringLiteral("\\b(\\w|\\.|-|\\+)+@(\\w|\\.|-)+\\.\\w+\\b"),
                                                        QRegularExpression::OptimizeOnFirstUsageOption);
 
 // matches full url or email address
 const QRegularExpression UrlFilter::CompleteUrlRegExp(QLatin1Char('(') + FullUrlRegExp.pattern() + QLatin1Char('|')
                                                       + EmailAddressRegExp.pattern() + QLatin1Char(')'),
                                                       QRegularExpression::OptimizeOnFirstUsageOption);
 
 UrlFilter::UrlFilter()
 {
     setRegExp(CompleteUrlRegExp);
 }
 
 UrlFilter::HotSpot::~HotSpot()
 {
     delete _urlObject;
 }
 
 void FilterObject::activated()
 {
     _filter->activate(sender());
 }
 
 QList<QAction *> UrlFilter::HotSpot::actions()
 {
     auto openAction = new QAction(_urlObject);
     auto copyAction = new QAction(_urlObject);
 
     const UrlType kind = urlType();
     Q_ASSERT(kind == StandardUrl || kind == Email);
 
     if (kind == StandardUrl) {
         openAction->setText(i18n("Open Link"));
         copyAction->setText(i18n("Copy Link Address"));
     } else if (kind == Email) {
         openAction->setText(i18n("Send Email To..."));
         copyAction->setText(i18n("Copy Email Address"));
     }
 
     // object names are set here so that the hotspot performs the
     // correct action when activated() is called with the triggered
     // action passed as a parameter.
     openAction->setObjectName(QStringLiteral("open-action"));
     copyAction->setObjectName(QStringLiteral("copy-action"));
 
     QObject::connect(openAction, &QAction::triggered, _urlObject,
                      &Konsole::FilterObject::activated);
     QObject::connect(copyAction, &QAction::triggered, _urlObject,
                      &Konsole::FilterObject::activated);
 
     QList<QAction *> actions;
     actions << openAction;
     actions << copyAction;
 
     return actions;
 }
 
 /**
   * File Filter - Construct a filter that works on local file paths using the
   * posix portable filename character set combined with KDE's mimetype filename
   * extension blob patterns.
   * https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_267
   */
 
 RegExpFilter::HotSpot *FileFilter::newHotSpot(int startLine, int startColumn, int endLine,
                                               int endColumn, const QStringList &capturedTexts)
 {
     if (_session.isNull()) {
         qCDebug(KonsoleDebug) << "Trying to create new hot spot without session!";
         return nullptr;
     }
 
     QString filename = capturedTexts.first();
     if (filename.startsWith(QLatin1Char('\'')) && filename.endsWith(QLatin1Char('\''))) {
         filename.remove(0, 1);
         filename.chop(1);
     }
 
     if (!_currentFiles.contains(filename)) {
         return nullptr;
     }
 
     return new FileFilter::HotSpot(startLine, startColumn, endLine, endColumn, capturedTexts, _dirPath + filename);
 }
 
 void FileFilter::process()
 {
     const QDir dir(_session->currentWorkingDirectory());
     _dirPath = dir.canonicalPath() + QLatin1Char('/');
     _currentFiles = dir.entryList(QDir::Files).toSet();
 
     RegExpFilter::process();
 }
 
 FileFilter::HotSpot::HotSpot(int startLine, int startColumn, int endLine, int endColumn,
                              const QStringList &capturedTexts, const QString &filePath) :
     RegExpFilter::HotSpot(startLine, startColumn, endLine, endColumn, capturedTexts),
     _fileObject(new FilterObject(this)),
     _filePath(filePath)
 {
     setType(Link);
 }
 
 void FileFilter::HotSpot::activate(QObject *)
 {
     new KRun(QUrl::fromLocalFile(_filePath), QApplication::activeWindow());
 }
 
 static QString createFileRegex(const QStringList &patterns, const QString &filePattern, const QString &pathPattern)
 {
     QStringList suffixes = patterns.filter(QRegularExpression(QStringLiteral("^\\*") + filePattern + QStringLiteral("$")));
     QStringList prefixes = patterns.filter(QRegularExpression(QStringLiteral("^") + filePattern + QStringLiteral("+\\*$")));
     QStringList fullNames = patterns.filter(QRegularExpression(QStringLiteral("^") + filePattern + QStringLiteral("$")));
 
     suffixes.replaceInStrings(QStringLiteral("*"), QString());
     suffixes.replaceInStrings(QStringLiteral("."), QStringLiteral("\\."));
     prefixes.replaceInStrings(QStringLiteral("*"), QString());
     prefixes.replaceInStrings(QStringLiteral("."), QStringLiteral("\\."));
 
     return QString(
                 // Optional path in front
                 pathPattern + QLatin1Char('?') +
                 // Files with known suffixes
                 QLatin1Char('(') +
                   filePattern +
                     QLatin1String("(") +
                       suffixes.join(QLatin1Char('|')) +
                     QLatin1String(")") +
                 // Files with known prefixes
                 QLatin1String("|") +
                     QLatin1String("(") +
                       prefixes.join(QLatin1Char('|')) +
                     QLatin1String(")") +
                     filePattern +
                 // Files with known full names
                 QLatin1String("|") +
                     fullNames.join(QLatin1Char('|')) +
                 QLatin1String(")")
     );
 }
 
 FileFilter::FileFilter(Session *session) :
     _session(session)
     , _dirPath(QString())
     , _currentFiles(QSet<QString>())
 {
     QStringList patterns;
     QMimeDatabase mimeDatabase;
     const QList<QMimeType> allMimeTypes = mimeDatabase.allMimeTypes();
     for (const QMimeType &mimeType : allMimeTypes) {
         patterns.append(mimeType.globPatterns());
     }
 
     patterns.removeDuplicates();
 
     QString validFilename(QStringLiteral("[A-Za-z0-9\\._\\-]+"));
     QString pathRegex(QStringLiteral("([A-Za-z0-9\\._\\-/]+/)"));
     QString noSpaceRegex = QLatin1String("\\b") + createFileRegex(patterns, validFilename, pathRegex) + QLatin1String("\\b");
 
     QString spaceRegex = QLatin1String("'") + createFileRegex(patterns, validFilename, pathRegex) + QLatin1String("'");
 
     QString regex = QLatin1String("(") + noSpaceRegex + QLatin1String(")|(") + spaceRegex + QLatin1String(")");
 
     setRegExp(QRegularExpression(regex, QRegularExpression::DontCaptureOption));
 }
 
 FileFilter::HotSpot::~HotSpot()
 {
     delete _fileObject;
 }
 
 QList<QAction *> FileFilter::HotSpot::actions()
 {
     auto openAction = new QAction(_fileObject);
     openAction->setText(i18n("Open File"));
     QObject::connect(openAction, &QAction::triggered, _fileObject,
                      &Konsole::FilterObject::activated);
     QList<QAction *> actions;
     actions << openAction;
     return actions;
 }
diff --git a/src/KeyBindingEditor.cpp b/src/KeyBindingEditor.cpp
index db885556..eca72a04 100644
--- a/src/KeyBindingEditor.cpp
+++ b/src/KeyBindingEditor.cpp
@@ -1,339 +1,339 @@
 /*
     Copyright 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 "KeyBindingEditor.h"
 
 // Qt
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <QKeyEvent>
 #include <QIcon>
 
 // KDE
 #include <KLocalizedString>
 #include <KMessageBox>
 
 // Konsole
 #include "ui_KeyBindingEditor.h"
 #include "EditProfileDialog.h"
 #include "KeyboardTranslator.h"
 #include "KeyboardTranslatorManager.h"
 
 using namespace Konsole;
 
 KeyBindingEditor::KeyBindingEditor(QWidget *parent) :
     QDialog(parent),
     _ui(nullptr),
     _translator(new KeyboardTranslator(QString())),
     _isNewTranslator(false)
 {
     auto layout = new QVBoxLayout;
 
     auto mainWidget = new QWidget(this);
     layout->addWidget(mainWidget);
 
     auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     buttonBox->button(QDialogButtonBox::Cancel)->setDefault(true);
     layout->addWidget(buttonBox);
 
     setLayout(layout);
 
     connect(buttonBox, &QDialogButtonBox::accepted, this, &Konsole::KeyBindingEditor::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
     setAttribute(Qt::WA_DeleteOnClose);
 
     _ui = new Ui::KeyBindingEditor();
     _ui->setupUi(mainWidget);
 
     // description edit
     _ui->descriptionEdit->setPlaceholderText(i18nc("@label:textbox", "Enter descriptive label"));
     connect(_ui->descriptionEdit, &QLineEdit::textChanged, this,
             &Konsole::KeyBindingEditor::setTranslatorDescription);
     // filter edit
     connect(_ui->filterEdit, &QLineEdit::textChanged, this,
             &Konsole::KeyBindingEditor::filterRows);
 
     // key bindings table
     _ui->keyBindingTable->setColumnCount(2);
 
     QStringList labels;
     labels << i18n("Key Combination") << i18n("Output");
 
     _ui->keyBindingTable->setHorizontalHeaderLabels(labels);
     _ui->keyBindingTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
 
     _ui->keyBindingTable->verticalHeader()->hide();
     _ui->keyBindingTable->setSelectionBehavior(QAbstractItemView::SelectRows);
 
     // add and remove buttons
     _ui->addEntryButton->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
     _ui->removeEntryButton->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
 
     connect(_ui->removeEntryButton, &QPushButton::clicked, this,
             &Konsole::KeyBindingEditor::removeSelectedEntry);
     connect(_ui->addEntryButton, &QPushButton::clicked, this,
             &Konsole::KeyBindingEditor::addNewEntry);
 
     // test area
     _ui->testAreaInputEdit->installEventFilter(this);
 }
 
 KeyBindingEditor::~KeyBindingEditor()
 {
     delete _ui;
     delete _translator;
 }
 
 void KeyBindingEditor::filterRows(const QString &text)
 {
     const int rows = _ui->keyBindingTable->rowCount();
 
     QList<int> matchedRows;
 
     for (QTableWidgetItem *matchedItem : _ui->keyBindingTable->findItems(text, Qt::MatchContains)) {
         matchedRows.append(matchedItem->row());
     }
 
     for (int i = 0; i < rows; i++) {
         if (matchedRows.contains(i) && _ui->keyBindingTable->isRowHidden(i)) {
             _ui->keyBindingTable->showRow(i);
         } else if (!matchedRows.contains(i)) {
             _ui->keyBindingTable->hideRow(i);
         }
     }
 }
 
 void KeyBindingEditor::removeSelectedEntry()
 {
     QList<QTableWidgetItem *> uniqueList;
-
-    foreach (QTableWidgetItem *item, _ui->keyBindingTable->selectedItems()) {
+    const QList<QTableWidgetItem *> list = _ui->keyBindingTable->selectedItems();
+    for (QTableWidgetItem *item : list) {
         if (item->column() == 1) { //Select item at the first column
             item = _ui->keyBindingTable->item(item->row(), 0);
         }
 
         if (!uniqueList.contains(item)) {
             uniqueList.append(item);
         }
     }
 
-    foreach (QTableWidgetItem *item, uniqueList) {
+    for (QTableWidgetItem *item : qAsConst(uniqueList)) {
         // get the first item in the row which has the entry
 
         KeyboardTranslator::Entry existing = item->data(Qt::UserRole).
                                              value<KeyboardTranslator::Entry>();
 
         _translator->removeEntry(existing);
 
         _ui->keyBindingTable->removeRow(item->row());
     }
 }
 
 void KeyBindingEditor::addNewEntry()
 {
     _ui->keyBindingTable->insertRow(_ui->keyBindingTable->rowCount());
 
     int newRowCount = _ui->keyBindingTable->rowCount();
 
     // block signals here to avoid triggering bindingTableItemChanged() slot call
     _ui->keyBindingTable->blockSignals(true);
 
     _ui->keyBindingTable->setItem(newRowCount - 1, 0, new QTableWidgetItem());
     _ui->keyBindingTable->setItem(newRowCount - 1, 1, new QTableWidgetItem());
 
     _ui->keyBindingTable->blockSignals(false);
 
     // make sure user can see new row
     _ui->keyBindingTable->scrollToItem(_ui->keyBindingTable->item(newRowCount - 1, 0));
 }
 
 bool KeyBindingEditor::eventFilter(QObject *watched, QEvent *event)
 {
     if (watched == _ui->testAreaInputEdit) {
         if (event->type() == QEvent::KeyPress) {
             auto *keyEvent = static_cast<QKeyEvent *>(event);
 
             // The state here is currently set to the state that a newly started
             // terminal in Konsole will be in ( which is also the same as the
             // state just after a reset ), this has 'ANSI' turned on and all other
             // states off.
             //
             // TODO: It may be useful to be able to specify the state in the 'test input'
             // area, but preferably not in a way which clutters the UI with lots of
             // checkboxes.
             //
             const KeyboardTranslator::States states = KeyboardTranslator::AnsiState;
 
             KeyboardTranslator::Entry entry = _translator->findEntry(keyEvent->key(),
                                                                      keyEvent->modifiers(),
                                                                      states);
 
             if (!entry.isNull()) {
                 _ui->testAreaInputEdit->setText(entry.conditionToString());
                 _ui->testAreaOutputEdit->setText(entry.resultToString(true, keyEvent->modifiers()));
             } else {
                 _ui->testAreaInputEdit->setText(keyEvent->text());
                 _ui->testAreaOutputEdit->setText(keyEvent->text());
             }
 
             keyEvent->accept();
             return true;
         }
     }
     return QDialog::eventFilter(watched, event);
 }
 
 void KeyBindingEditor::setDescription(const QString &description)
 {
     _ui->descriptionEdit->setText(description);
 
     setTranslatorDescription(description);
 }
 
 void KeyBindingEditor::setTranslatorDescription(const QString &description)
 {
     if (_translator != nullptr) {
         _translator->setDescription(description);
     }
 }
 
 QString KeyBindingEditor::description() const
 {
     return _ui->descriptionEdit->text();
 }
 
 void KeyBindingEditor::setup(const KeyboardTranslator *translator,
                              const QString &currentProfileTranslator, bool isNewTranslator)
 {
     delete _translator;
 
     _isNewTranslator = isNewTranslator;
 
     _currentProfileTranslator  = currentProfileTranslator;
 
     _translator = new KeyboardTranslator(*translator);
 
     // setup description edit line
     _ui->descriptionEdit->setClearButtonEnabled(true);
     // setup filter edit line
     _ui->filterEdit->setClearButtonEnabled(true);
 
     if (_isNewTranslator) {
         setDescription(i18n("New Key Binding List"));
         setWindowTitle(i18n("New Key Binding List"));
     } else {
         _ui->descriptionEdit->setText(translator->description());
         setWindowTitle(i18n("Edit Key Binding List"));
     }
 
     // setup key binding table
     setupKeyBindingTable(translator);
 }
 
 KeyboardTranslator *KeyBindingEditor::translator() const
 {
     return _translator;
 }
 
 void KeyBindingEditor::bindingTableItemChanged(QTableWidgetItem *item)
 {
     QTableWidgetItem *key = _ui->keyBindingTable->item(item->row(), 0);
     KeyboardTranslator::Entry existing = key->data(Qt::UserRole).value<KeyboardTranslator::Entry>();
 
     QString condition = key->text();
     QString result = _ui->keyBindingTable->item(item->row(), 1)->text();
 
     KeyboardTranslator::Entry entry = KeyboardTranslatorReader::createEntry(condition, result);
     _translator->replaceEntry(existing, entry);
 
     // block signals to prevent this slot from being called repeatedly
     _ui->keyBindingTable->blockSignals(true);
 
     key->setData(Qt::UserRole, QVariant::fromValue(entry));
 
     _ui->keyBindingTable->blockSignals(false);
 }
 
 void KeyBindingEditor::setupKeyBindingTable(const KeyboardTranslator *translator)
 {
     disconnect(_ui->keyBindingTable, &QTableWidget::itemChanged, this,
                &Konsole::KeyBindingEditor::bindingTableItemChanged);
 
     QList<KeyboardTranslator::Entry> entries = translator->entries();
     _ui->keyBindingTable->setRowCount(entries.count());
 
     for (int row = 0; row < entries.count(); row++) {
         const KeyboardTranslator::Entry &entry = entries.at(row);
 
         QTableWidgetItem *keyItem = new QTableWidgetItem(entry.conditionToString());
         keyItem->setData(Qt::UserRole, QVariant::fromValue(entry));
 
         QTableWidgetItem *textItem = new QTableWidgetItem(entry.resultToString());
 
         _ui->keyBindingTable->setItem(row, 0, keyItem);
         _ui->keyBindingTable->setItem(row, 1, textItem);
     }
     _ui->keyBindingTable->sortItems(0);
 
     connect(_ui->keyBindingTable, &QTableWidget::itemChanged, this,
             &Konsole::KeyBindingEditor::bindingTableItemChanged);
 }
 
 void KeyBindingEditor::accept()
 {
     if (_translator == nullptr) {
         return;
     }
 
     const auto newTranslator = new KeyboardTranslator(*_translator);
 
     if (newTranslator->description().isEmpty()) {
         KMessageBox::sorry(this, i18n("A key bindings scheme cannot be saved with an empty description."));
         delete newTranslator;
         return;
     }
 
     if (_isNewTranslator) {
         newTranslator->setName(newTranslator->description());
     }
 
     KeyboardTranslatorManager::instance()->addTranslator(newTranslator);
 
     const QString &currentTranslatorName = newTranslator->name();
 
     emit updateKeyBindingsListRequest(currentTranslatorName);
 
     if (currentTranslatorName == _currentProfileTranslator) {
         emit updateTempProfileKeyBindingsRequest(Profile::KeyBindings, currentTranslatorName);
     }
 
     QDialog::accept();
 }
 
 QSize KeyBindingEditor::sizeHint() const
 {
     const auto parent = parentWidget();
     if (parent != nullptr) {
         return {static_cast<int>(parent->width() * 0.9),
                 static_cast<int>(parent->height() * 0.95)};
     }
 
     return {};
 }
diff --git a/src/KeyboardTranslatorManager.cpp b/src/KeyboardTranslatorManager.cpp
index ac70f44e..9a90b4bc 100644
--- a/src/KeyboardTranslatorManager.cpp
+++ b/src/KeyboardTranslatorManager.cpp
@@ -1,227 +1,227 @@
 /*
     This source file is part of Konsole, a terminal emulator.
 
     Copyright 2007-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 "KeyboardTranslatorManager.h"
 
 #include "konsoledebug.h"
 
 // Qt
 #include <QFile>
 #include <QFileInfo>
 #include <QDir>
 #include <QStandardPaths>
 
 using namespace Konsole;
 
 KeyboardTranslatorManager::KeyboardTranslatorManager() :
     _haveLoadedAll(false),
     _fallbackTranslator(nullptr),
     _translators(QHash<QString, KeyboardTranslator *>())
 {
     _fallbackTranslator = new FallbackKeyboardTranslator();
 }
 
 KeyboardTranslatorManager::~KeyboardTranslatorManager()
 {
     qDeleteAll(_translators);
     delete _fallbackTranslator;
 }
 
 Q_GLOBAL_STATIC(KeyboardTranslatorManager, theKeyboardTranslatorManager)
 KeyboardTranslatorManager* KeyboardTranslatorManager::instance()
 {
     return theKeyboardTranslatorManager;
 }
 
 void KeyboardTranslatorManager::addTranslator(KeyboardTranslator *translator)
 {
     _translators.insert(translator->name(), translator);
 
     if (!saveTranslator(translator)) {
         qCDebug(KonsoleDebug) << "Unable to save translator" << translator->name()
                               << "to disk.";
     }
 }
 
 bool KeyboardTranslatorManager::deleteTranslator(const QString &name)
 {
     Q_ASSERT(_translators.contains(name));
 
     // locate and delete
     QString path = findTranslatorPath(name);
     if (QFile::remove(path)) {
         _translators.remove(name);
         return true;
     } else {
         qCDebug(KonsoleDebug) << "Failed to remove translator - " << path;
         return false;
     }
 }
 
 bool KeyboardTranslatorManager::isTranslatorDeletable(const QString &name) const
 {
     const QString &dir = QFileInfo(findTranslatorPath(name)).path();
     return QFileInfo(dir).isWritable();
 }
 
 bool KeyboardTranslatorManager::isTranslatorResettable(const QString &name) const
 {
     const QStringList &paths = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QLatin1String("konsole/") + name + QLatin1String(".keytab"));
 
     return (paths.count() > 1);
 }
 
 const QString KeyboardTranslatorManager::findTranslatorPath(const QString &name) const
 {
     return QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("konsole/") + name + QStringLiteral(".keytab"));
 }
 
 void KeyboardTranslatorManager::findTranslators()
 {
     QStringList list;
     const QStringList dirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("konsole"),
                                                        QStandardPaths::LocateDirectory);
     list.reserve(dirs.size());
 
     for (const QString &dir : dirs) {
         const QStringList fileNames = QDir(dir).entryList(QStringList() << QStringLiteral("*.keytab"));
         for (const QString &file : fileNames) {
             list.append(dir + QLatin1Char('/') + file);
         }
     }
 
     // add the name of each translator to the list and associated
     // the name with a null pointer to indicate that the translator
     // has not yet been loaded from disk
-    foreach (const QString &translatorPath, list) {
+    for (const QString &translatorPath : qAsConst(list)) {
         QString name = QFileInfo(translatorPath).completeBaseName();
 
         if (!_translators.contains(name)) {
             _translators.insert(name, nullptr);
         }
     }
 
     _haveLoadedAll = true;
 }
 
 const KeyboardTranslator *KeyboardTranslatorManager::findTranslator(const QString &name)
 {
     if (name.isEmpty()) {
         return defaultTranslator();
     }
 
     if (_translators.contains(name) && _translators[name] != nullptr) {
         return _translators[name];
     }
 
     KeyboardTranslator *translator = loadTranslator(name);
 
     if (translator != nullptr) {
         _translators[name] = translator;
     } else if (!name.isEmpty()) {
         qCDebug(KonsoleDebug) << "Unable to load translator" << name;
     }
 
     return translator;
 }
 
 bool KeyboardTranslatorManager::saveTranslator(const KeyboardTranslator *translator)
 {
     const QString dir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation)
                         + QStringLiteral("/konsole/");
     QDir().mkpath(dir);
     const QString path = dir + translator->name() + QStringLiteral(".keytab");
 
     ////qDebug() << "Saving translator to" << path;
 
     QFile destination(path);
     if (!destination.open(QIODevice::WriteOnly | QIODevice::Text)) {
         qCDebug(KonsoleDebug) << "Unable to save keyboard translation:"
                               << destination.errorString();
         return false;
     }
 
     {
         KeyboardTranslatorWriter writer(&destination);
         writer.writeHeader(translator->description());
-
-        foreach (const KeyboardTranslator::Entry &entry, translator->entries()) {
+        const QList<KeyboardTranslator::Entry> list = translator->entries();
+        for (const KeyboardTranslator::Entry &entry : list) {
             writer.writeEntry(entry);
         }
     }
 
     destination.close();
 
     return true;
 }
 
 KeyboardTranslator *KeyboardTranslatorManager::loadTranslator(const QString &name)
 {
     const QString &path = findTranslatorPath(name);
 
     QFile source(path);
     if (name.isEmpty() || !source.open(QIODevice::ReadOnly | QIODevice::Text)) {
         return nullptr;
     }
 
     return loadTranslator(&source, name);
 }
 
 KeyboardTranslator *KeyboardTranslatorManager::loadTranslator(QIODevice *source,
                                                               const QString &name)
 {
     auto translator = new KeyboardTranslator(name);
     KeyboardTranslatorReader reader(source);
     translator->setDescription(reader.description());
     while (reader.hasNextEntry()) {
         translator->addEntry(reader.nextEntry());
     }
 
     source->close();
 
     if (!reader.parseError()) {
         return translator;
     } else {
         delete translator;
         return nullptr;
     }
 }
 
 const KeyboardTranslator *KeyboardTranslatorManager::defaultTranslator()
 {
     // Try to find the default.keytab file if it exists, otherwise
     // fall back to the internal hard-coded fallback translator
     const KeyboardTranslator *translator = findTranslator(QStringLiteral("default"));
     if (translator == nullptr) {
         translator = _fallbackTranslator;
     }
     return translator;
 }
 
 const QStringList KeyboardTranslatorManager::allTranslators()
 {
     if (!_haveLoadedAll) {
         findTranslators();
     }
 
     return _translators.keys();
 }
diff --git a/src/Session.cpp b/src/Session.cpp
index c3f85102..e4d6a716 100644
--- a/src/Session.cpp
+++ b/src/Session.cpp
@@ -1,1795 +1,1795 @@
 /*
     This file is part of Konsole
 
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
     Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
     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 "Session.h"
 
 // Standard
 #include <cstdlib>
 #include <csignal>
 #include <unistd.h>
 
 // Qt
 #include <QApplication>
 #include <QColor>
 #include <QDir>
 #include <QFile>
 #include <QStringList>
 #include <QKeyEvent>
 
 // KDE
 #include <KLocalizedString>
 #include <KNotification>
 #include <KRun>
 #include <KShell>
 #include <KProcess>
 #include <KConfigGroup>
 #include <KIO/DesktopExecParser>
 
 // Konsole
 #include <sessionadaptor.h>
 
 #include "ProcessInfo.h"
 #include "Pty.h"
 #include "TerminalDisplay.h"
 #include "ShellCommand.h"
 #include "Vt102Emulation.h"
 #include "ZModemDialog.h"
 #include "History.h"
 #include "konsoledebug.h"
 #include "SessionManager.h"
 #include "ProfileManager.h"
 #include "Profile.h"
 
 using namespace Konsole;
 
 int Session::lastSessionId = 0;
 static bool show_disallow_certain_dbus_methods_message = true;
 
 static const int ZMODEM_BUFFER_SIZE = 1048576; // 1 Mb
 
 Session::Session(QObject* parent) :
     QObject(parent)
     , _uniqueIdentifier(QUuid())
     , _shellProcess(nullptr)
     , _emulation(nullptr)
     , _views(QList<TerminalDisplay *>())
     , _monitorActivity(false)
     , _monitorSilence(false)
     , _notifiedActivity(false)
     , _silenceSeconds(10)
     , _silenceTimer(nullptr)
     , _activityTimer(nullptr)
     , _autoClose(true)
     , _closePerUserRequest(false)
     , _nameTitle(QString())
     , _displayTitle(QString())
     , _userTitle(QString())
     , _localTabTitleFormat(QString())
     , _remoteTabTitleFormat(QString())
     , _tabTitleSetByUser(false)
     , _iconName(QString())
     , _iconText(QString())
     , _addToUtmp(true)
     , _flowControlEnabled(true)
     , _program(QString())
     , _arguments(QStringList())
     , _environment(QStringList())
     , _sessionId(0)
     , _initialWorkingDir(QString())
     , _currentWorkingDir(QString())
     , _reportedWorkingUrl(QUrl())
     , _sessionProcessInfo(nullptr)
     , _foregroundProcessInfo(nullptr)
     , _foregroundPid(0)
     , _zmodemBusy(false)
     , _zmodemProc(nullptr)
     , _zmodemProgress(nullptr)
     , _hasDarkBackground(false)
     , _preferredSize(QSize())
     , _readOnly(false)
     , _isPrimaryScreen(true)
 {
     _uniqueIdentifier = QUuid::createUuid();
 
     //prepare DBus communication
     new SessionAdaptor(this);
     _sessionId = ++lastSessionId;
     QDBusConnection::sessionBus().registerObject(QLatin1String("/Sessions/") + QString::number(_sessionId), this);
 
     //create emulation backend
     _emulation = new Vt102Emulation();
 
     connect(_emulation, &Konsole::Emulation::sessionAttributeChanged, this, &Konsole::Session::setSessionAttribute);
     connect(_emulation, &Konsole::Emulation::stateSet, this, &Konsole::Session::activityStateSet);
     connect(_emulation, &Konsole::Emulation::zmodemDownloadDetected, this, &Konsole::Session::fireZModemDownloadDetected);
     connect(_emulation, &Konsole::Emulation::zmodemUploadDetected, this, &Konsole::Session::fireZModemUploadDetected);
     connect(_emulation, &Konsole::Emulation::changeTabTextColorRequest, this, &Konsole::Session::changeTabTextColor);
     connect(_emulation, &Konsole::Emulation::profileChangeCommandReceived, this, &Konsole::Session::profileChangeCommandReceived);
     connect(_emulation, &Konsole::Emulation::flowControlKeyPressed, this, &Konsole::Session::updateFlowControlState);
     connect(_emulation, &Konsole::Emulation::primaryScreenInUse, this, &Konsole::Session::onPrimaryScreenInUse);
     connect(_emulation, &Konsole::Emulation::selectionChanged, this, &Konsole::Session::selectionChanged);
     connect(_emulation, &Konsole::Emulation::imageResizeRequest, this, &Konsole::Session::resizeRequest);
     connect(_emulation, &Konsole::Emulation::sessionAttributeRequest, this, &Konsole::Session::sessionAttributeRequest);
 
     //create new teletype for I/O with shell process
     openTeletype(-1);
 
     //setup timer for monitoring session activity & silence
     _silenceTimer = new QTimer(this);
     _silenceTimer->setSingleShot(true);
     connect(_silenceTimer, &QTimer::timeout, this, &Konsole::Session::silenceTimerDone);
 
     _activityTimer = new QTimer(this);
     _activityTimer->setSingleShot(true);
     connect(_activityTimer, &QTimer::timeout, this, &Konsole::Session::activityTimerDone);
 }
 
 Session::~Session()
 {
     delete _foregroundProcessInfo;
     delete _sessionProcessInfo;
     delete _emulation;
     delete _shellProcess;
     delete _zmodemProc;
 }
 
 void Session::openTeletype(int fd)
 {
     if (isRunning()) {
         qWarning() << "Attempted to open teletype in a running session.";
         return;
     }
 
     delete _shellProcess;
 
     if (fd < 0) {
         _shellProcess = new Pty();
     } else {
         _shellProcess = new Pty(fd);
     }
 
     _shellProcess->setUtf8Mode(_emulation->utf8());
 
     // connect the I/O between emulator and pty process
     connect(_shellProcess, &Konsole::Pty::receivedData, this, &Konsole::Session::onReceiveBlock);
     connect(_emulation, &Konsole::Emulation::sendData, _shellProcess, &Konsole::Pty::sendData);
 
     // UTF8 mode
     connect(_emulation, &Konsole::Emulation::useUtf8Request, _shellProcess, &Konsole::Pty::setUtf8Mode);
 
     // get notified when the pty process is finished
     connect(_shellProcess,
             QOverload<int,QProcess::ExitStatus>::of(&Konsole::Pty::finished),
             this, &Konsole::Session::done);
 
     // emulator size
     // Use a direct connection to ensure that the window size is set before it runs
     connect(_emulation, &Konsole::Emulation::imageSizeChanged, this, &Konsole::Session::updateWindowSize, Qt::DirectConnection);
     connect(_emulation, &Konsole::Emulation::imageSizeInitialized, this, &Konsole::Session::run);
 }
 
 WId Session::windowId() const
 {
     // Returns a window ID for this session which is used
     // to set the WINDOWID environment variable in the shell
     // process.
     //
     // Sessions can have multiple views or no views, which means
     // that a single ID is not always going to be accurate.
     //
     // If there are no views, the window ID is just 0.  If
     // there are multiple views, then the window ID for the
     // top-level window which contains the first view is
     // returned
 
     if (_views.count() == 0) {
         return 0;
     } else {
         /**
          * compute the windows id to use
          * doesn't call winId on some widget, as this might lead
          * to rendering artifacts as this will trigger the
          * creation of a native window, see https://doc.qt.io/qt-5/qwidget.html#winId
          * instead, use https://doc.qt.io/qt-5/qwidget.html#effectiveWinId
          */
         QWidget* widget = _views.first();
         Q_ASSERT(widget);
         return widget->effectiveWinId();
     }
 }
 
 void Session::setDarkBackground(bool darkBackground)
 {
     _hasDarkBackground = darkBackground;
 }
 
 bool Session::isRunning() const
 {
     return (_shellProcess != nullptr) && (_shellProcess->state() == QProcess::Running);
 }
 
 void Session::setCodec(QTextCodec* codec)
 {
     if (isReadOnly()) {
         return;
     }
 
     emulation()->setCodec(codec);
 }
 
 bool Session::setCodec(const QByteArray& name)
 {
     QTextCodec* codec = QTextCodec::codecForName(name);
 
     if (codec != nullptr) {
         setCodec(codec);
         return true;
     } else {
         return false;
     }
 }
 
 QByteArray Session::codec()
 {
     return _emulation->codec()->name();
 }
 
 void Session::setProgram(const QString& program)
 {
     _program = ShellCommand::expand(program);
 }
 
 void Session::setArguments(const QStringList& arguments)
 {
     _arguments = ShellCommand::expand(arguments);
 }
 
 void Session::setInitialWorkingDirectory(const QString& dir)
 {
     _initialWorkingDir = validDirectory(KShell::tildeExpand(ShellCommand::expand(dir)));
 }
 
 QString Session::currentWorkingDirectory()
 {
     if (_reportedWorkingUrl.isValid() && _reportedWorkingUrl.isLocalFile()) {
         return _reportedWorkingUrl.path();
     }
 
     // only returned cached value
     if (_currentWorkingDir.isEmpty()) {
         updateWorkingDirectory();
     }
 
     return _currentWorkingDir;
 }
 void Session::updateWorkingDirectory()
 {
     updateSessionProcessInfo();
 
     const QString currentDir = _sessionProcessInfo->validCurrentDir();
     if (currentDir != _currentWorkingDir) {
         _currentWorkingDir = currentDir;
         emit currentDirectoryChanged(_currentWorkingDir);
     }
 }
 
 QList<TerminalDisplay*> Session::views() const
 {
     return _views;
 }
 
 void Session::addView(TerminalDisplay* widget)
 {
     Q_ASSERT(!_views.contains(widget));
 
     _views.append(widget);
 
     // connect emulation - view signals and slots
     connect(widget, &Konsole::TerminalDisplay::keyPressedSignal, _emulation, &Konsole::Emulation::sendKeyEvent);
     connect(widget, &Konsole::TerminalDisplay::mouseSignal, _emulation, &Konsole::Emulation::sendMouseEvent);
     connect(widget, &Konsole::TerminalDisplay::sendStringToEmu, _emulation, &Konsole::Emulation::sendString);
 
     // allow emulation to notify the view when the foreground process
     // indicates whether or not it is interested in Mouse Tracking events
     connect(_emulation, &Konsole::Emulation::programRequestsMouseTracking, widget, &Konsole::TerminalDisplay::setUsesMouseTracking);
 
     widget->setUsesMouseTracking(_emulation->programUsesMouseTracking());
 
     connect(_emulation, &Konsole::Emulation::enableAlternateScrolling, widget, &Konsole::TerminalDisplay::setAlternateScrolling);
 
     connect(_emulation, &Konsole::Emulation::programBracketedPasteModeChanged, widget, &Konsole::TerminalDisplay::setBracketedPasteMode);
 
     widget->setBracketedPasteMode(_emulation->programBracketedPasteMode());
 
     widget->setScreenWindow(_emulation->createWindow());
 
     //connect view signals and slots
     connect(widget, &Konsole::TerminalDisplay::changedContentSizeSignal, this, &Konsole::Session::onViewSizeChange);
 
     connect(widget, &Konsole::TerminalDisplay::destroyed, this, &Konsole::Session::viewDestroyed);
 
     connect(widget, &Konsole::TerminalDisplay::focusLost, _emulation, &Konsole::Emulation::focusLost);
     connect(widget, &Konsole::TerminalDisplay::focusGained, _emulation, &Konsole::Emulation::focusGained);
 
     connect(_emulation, &Konsole::Emulation::setCursorStyleRequest, widget, &Konsole::TerminalDisplay::setCursorStyle);
     connect(_emulation, &Konsole::Emulation::resetCursorStyleRequest, widget, &Konsole::TerminalDisplay::resetCursorStyle);
 }
 
 void Session::viewDestroyed(QObject* view)
 {
     auto* display = reinterpret_cast<TerminalDisplay*>(view);
 
     Q_ASSERT(_views.contains(display));
 
     removeView(display);
 }
 
 void Session::removeView(TerminalDisplay* widget)
 {
     _views.removeAll(widget);
 
     disconnect(widget, nullptr, this, nullptr);
 
     // disconnect
     //  - key presses signals from widget
     //  - mouse activity signals from widget
     //  - string sending signals from widget
     //
     //  ... and any other signals connected in addView()
     disconnect(widget, nullptr, _emulation, nullptr);
 
     // disconnect state change signals emitted by emulation
     disconnect(_emulation, nullptr, widget, nullptr);
 
     // close the session automatically when the last view is removed
     if (_views.count() == 0) {
         close();
     }
 }
 
 // Upon a KPty error, there is no description on what that error was...
 // Check to see if the given program is executable.
 QString Session::checkProgram(const QString& program)
 {
     QString exec = program;
 
     if (exec.isEmpty()) {
         return QString();
     }
 
     QFileInfo info(exec);
     if (info.isAbsolute() && info.exists() && info.isExecutable()) {
         return exec;
     }
 
     exec = KIO::DesktopExecParser::executablePath(exec);
     exec = KShell::tildeExpand(exec);
     const QString pexec = QStandardPaths::findExecutable(exec);
     if (pexec.isEmpty()) {
         qCritical() << i18n("Could not find binary: ") << exec;
         return QString();
     }
 
     return exec;
 }
 
 void Session::terminalWarning(const QString& message)
 {
     static const QByteArray warningText = i18nc("@info:shell Alert the user with red color text", "Warning: ").toLocal8Bit();
     QByteArray messageText = message.toLocal8Bit();
 
     static const char redPenOn[] = "\033[1m\033[31m";
     static const char redPenOff[] = "\033[0m";
 
     _emulation->receiveData(redPenOn, qstrlen(redPenOn));
     _emulation->receiveData("\n\r\n\r", 4);
     _emulation->receiveData(warningText.constData(), qstrlen(warningText.constData()));
     _emulation->receiveData(messageText.constData(), qstrlen(messageText.constData()));
     _emulation->receiveData("\n\r\n\r", 4);
     _emulation->receiveData(redPenOff, qstrlen(redPenOff));
 }
 
 QString Session::shellSessionId() const
 {
     QString friendlyUuid(_uniqueIdentifier.toString());
     friendlyUuid.remove(QLatin1Char('-')).remove(QLatin1Char('{')).remove(QLatin1Char('}'));
 
     return friendlyUuid;
 }
 
 void Session::run()
 {
     // FIXME: run() is called twice in some instances
     if (isRunning()) {
         qCDebug(KonsoleDebug) << "Attempted to re-run an already running session (" << _shellProcess->pid() << ")";
         return;
     }
 
     //check that everything is in place to run the session
     if (_program.isEmpty()) {
         qWarning() << "Program to run not set.";
     }
     if (_arguments.isEmpty()) {
         qWarning() << "No command line arguments specified.";
     }
     if (_uniqueIdentifier.isNull()) {
         _uniqueIdentifier = QUuid::createUuid();
     }
 
     const int CHOICE_COUNT = 3;
     // if '_program' is empty , fall back to default shell. If that is not set
     // then fall back to /bin/sh
     QString programs[CHOICE_COUNT] = {_program, QString::fromUtf8(qgetenv("SHELL")), QStringLiteral("/bin/sh")};
     QString exec;
     int choice = 0;
     while (choice < CHOICE_COUNT) {
         exec = checkProgram(programs[choice]);
         if (exec.isEmpty()) {
             choice++;
         } else {
             break;
         }
     }
 
     // if a program was specified via setProgram(), but it couldn't be found, print a warning
     if (choice != 0 && choice < CHOICE_COUNT && !_program.isEmpty()) {
         terminalWarning(i18n("Could not find '%1', starting '%2' instead.  Please check your profile settings.", _program, exec));
         // if none of the choices are available, print a warning
     } else if (choice == CHOICE_COUNT) {
         terminalWarning(i18n("Could not find an interactive shell to start."));
         return;
     }
 
     // if no arguments are specified, fall back to program name
     QStringList arguments = _arguments.join(QLatin1Char(' ')).isEmpty() ?
                             QStringList() << exec :
                             _arguments;
 
     if (!_initialWorkingDir.isEmpty()) {
         _shellProcess->setInitialWorkingDirectory(_initialWorkingDir);
     } else {
         _shellProcess->setInitialWorkingDirectory(QDir::currentPath());
     }
 
     _shellProcess->setFlowControlEnabled(_flowControlEnabled);
     _shellProcess->setEraseChar(_emulation->eraseChar());
     _shellProcess->setUseUtmp(_addToUtmp);
 
     // this is not strictly accurate use of the COLORFGBG variable.  This does not
     // tell the terminal exactly which colors are being used, but instead approximates
     // the color scheme as "black on white" or "white on black" depending on whether
     // the background color is deemed dark or not
     const QString backgroundColorHint = _hasDarkBackground ? QStringLiteral("COLORFGBG=15;0") : QStringLiteral("COLORFGBG=0;15");
     addEnvironmentEntry(backgroundColorHint);
 
     addEnvironmentEntry(QStringLiteral("SHELL_SESSION_ID=%1").arg(shellSessionId()));
 
     addEnvironmentEntry(QStringLiteral("WINDOWID=%1").arg(QString::number(windowId())));
 
     const QString dbusService = QDBusConnection::sessionBus().baseService();
     addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_SERVICE=%1").arg(dbusService));
 
     const QString dbusObject = QStringLiteral("/Sessions/%1").arg(QString::number(_sessionId));
     addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_SESSION=%1").arg(dbusObject));
 
     int result = _shellProcess->start(exec, arguments, _environment);
     if (result < 0) {
         terminalWarning(i18n("Could not start program '%1' with arguments '%2'.", exec, arguments.join(QLatin1Char(' '))));
         terminalWarning(_shellProcess->errorString());
         return;
     }
 
     _shellProcess->setWriteable(false);  // We are reachable via kwrited.
 
     emit started();
 }
 
 void Session::setSessionAttribute(int what, const QString& caption)
 {
     // set to true if anything has actually changed
     // eg. old _nameTitle != new _nameTitle
     bool modified = false;
 
     if ((what == IconNameAndWindowTitle) || (what == WindowTitle)) {
         if (_userTitle != caption) {
             _userTitle = caption;
             modified = true;
         }
     }
 
     if ((what == IconNameAndWindowTitle) || (what == IconName)) {
         if (_iconText != caption) {
             _iconText = caption;
             modified = true;
         }
     }
 
     if (what == TextColor || what == BackgroundColor) {
         QString colorString = caption.section(QLatin1Char(';'), 0, 0);
         QColor color = QColor(colorString);
         if (color.isValid()) {
             if (what == TextColor) {
                 emit changeForegroundColorRequest(color);
             } else {
                 emit changeBackgroundColorRequest(color);
             }
         }
     }
 
     if (what == SessionName) {
         if (_localTabTitleFormat != caption) {
             _localTabTitleFormat = caption;
             setTitle(Session::DisplayedTitleRole, caption);
             modified = true;
         }
     }
 
     /* The below use of 32 works but appears to non-standard.
        It is from a commit from 2004 c20973eca8776f9b4f15bee5fdcb5a3205aa69de
      */
     // change icon via \033]32;Icon\007
     if (what == SessionIcon) {
         if (_iconName != caption) {
             _iconName = caption;
 
             modified = true;
         }
     }
 
     if (what == CurrentDirectory) {
         _reportedWorkingUrl = QUrl::fromUserInput(caption);
         emit currentDirectoryChanged(currentWorkingDirectory());
         modified = true;
     }
 
     if (what == ProfileChange) {
         emit profileChangeCommandReceived(caption);
         return;
     }
 
     if (modified) {
         emit sessionAttributeChanged();
     }
 }
 
 QString Session::userTitle() const
 {
     return _userTitle;
 }
 void Session::setTabTitleFormat(TabTitleContext context , const QString& format)
 {
     if (context == LocalTabTitle) {
         _localTabTitleFormat = format;
         ProcessInfo* process = getProcessInfo();
         process->setUserNameRequired(format.contains(QLatin1String("%u")));
     } else if (context == RemoteTabTitle) {
         _remoteTabTitleFormat = format;
     }
 }
 QString Session::tabTitleFormat(TabTitleContext context) const
 {
     if (context == LocalTabTitle) {
         return _localTabTitleFormat;
     } else if (context == RemoteTabTitle) {
         return _remoteTabTitleFormat;
     }
 
     return QString();
 }
 
 void Session::tabTitleSetByUser(bool set)
 {
     _tabTitleSetByUser = set;
 }
 
 bool Session::isTabTitleSetByUser() const
 {
     return _tabTitleSetByUser;
 }
 
 void Session::silenceTimerDone()
 {
     //FIXME: The idea here is that the notification popup will appear to tell the user than output from
     //the terminal has stopped and the popup will disappear when the user activates the session.
     //
     //This breaks with the addition of multiple views of a session.  The popup should disappear
     //when any of the views of the session becomes active
 
     //FIXME: Make message text for this notification and the activity notification more descriptive.
     if (!_monitorSilence) {
         emit stateChanged(NOTIFYNORMAL);
         return;
     }
 
     bool hasFocus = false;
-    foreach(TerminalDisplay *display, _views) {
+    for (const TerminalDisplay *display : qAsConst(_views)) {
         if (display->hasFocus()) {
             hasFocus = true;
             break;
         }
     }
 
     KNotification::event(hasFocus ? QStringLiteral("Silence") : QStringLiteral("SilenceHidden"),
             i18n("Silence in session '%1'", _nameTitle), QPixmap(),
             QApplication::activeWindow(),
             KNotification::CloseWhenWidgetActivated);
     emit stateChanged(NOTIFYSILENCE);
 }
 
 void Session::activityTimerDone()
 {
     _notifiedActivity = false;
 }
 
 void Session::updateFlowControlState(bool suspended)
 {
     if (suspended) {
         if (flowControlEnabled()) {
-            foreach(TerminalDisplay * display, _views) {
+            for (TerminalDisplay *display : qAsConst(_views)) {
                 if (display->flowControlWarningEnabled()) {
                     display->outputSuspended(true);
                 }
             }
         }
     } else {
-        foreach(TerminalDisplay * display, _views) {
+        for (TerminalDisplay *display : qAsConst(_views)) {
             display->outputSuspended(false);
         }
     }
 }
 
 void Session::changeTabTextColor(int i)
 {
     qCDebug(KonsoleDebug) << "Changing tab text color is not implemented "<<i;
 }
 
 void Session::onPrimaryScreenInUse(bool use)
 {
 
     _isPrimaryScreen = use;
     emit primaryScreenInUse(use);
 }
 bool Session::isPrimaryScreen()
 {
     return _isPrimaryScreen;
 }
 
 void Session::sessionAttributeRequest(int id)
 {
     switch (id) {
         case BackgroundColor:
             // Get 'TerminalDisplay' (_view) background color
             emit getBackgroundColor();
             break;
     }
 }
 
 void Session::activityStateSet(int state)
 {
     // TODO: should this hardcoded interval be user configurable?
     const int activityMaskInSeconds = 15;
 
     if (state == NOTIFYBELL) {
         emit bellRequest(i18n("Bell in session '%1'", _nameTitle));
     } else if (state == NOTIFYACTIVITY) {
         // Don't notify if the terminal is active
         bool hasFocus = false;
-        foreach(TerminalDisplay *display, _views) {
+        for (const TerminalDisplay *display : qAsConst(_views)) {
             if (display->hasFocus()) {
                 hasFocus = true;
                 break;
             }
         }
 
         if (_monitorActivity  && !_notifiedActivity) {
             KNotification::event(hasFocus ? QStringLiteral("Activity") : QStringLiteral("ActivityHidden"),
                                  i18n("Activity in session '%1'", _nameTitle), QPixmap(),
                                  QApplication::activeWindow(),
                                  KNotification::CloseWhenWidgetActivated);
 
             // mask activity notification for a while to avoid flooding
             _notifiedActivity = true;
             _activityTimer->start(activityMaskInSeconds * 1000);
         }
 
         // reset the counter for monitoring continuous silence since there is activity
         if (_monitorSilence) {
             _silenceTimer->start(_silenceSeconds * 1000);
         }
     }
 
     if (state == NOTIFYACTIVITY && !_monitorActivity) {
         state = NOTIFYNORMAL;
     }
     if (state == NOTIFYSILENCE && !_monitorSilence) {
         state = NOTIFYNORMAL;
     }
 
     emit stateChanged(state);
 }
 
 void Session::onViewSizeChange(int /*height*/, int /*width*/)
 {
     updateTerminalSize();
 }
 
 void Session::updateTerminalSize()
 {
     int minLines = -1;
     int minColumns = -1;
 
     // minimum number of lines and columns that views require for
     // their size to be taken into consideration ( to avoid problems
     // with new view widgets which haven't yet been set to their correct size )
     const int VIEW_LINES_THRESHOLD = 2;
     const int VIEW_COLUMNS_THRESHOLD = 2;
 
     //select largest number of lines and columns that will fit in all visible views
-    foreach(TerminalDisplay* view, _views) {
+    for (TerminalDisplay *view : qAsConst(_views)) {
         if (!view->isHidden() &&
                 view->lines() >= VIEW_LINES_THRESHOLD &&
                 view->columns() >= VIEW_COLUMNS_THRESHOLD) {
             minLines = (minLines == -1) ? view->lines() : qMin(minLines , view->lines());
             minColumns = (minColumns == -1) ? view->columns() : qMin(minColumns , view->columns());
             view->processFilters();
         }
     }
 
     // backend emulation must have a _terminal of at least 1 column x 1 line in size
     if (minLines > 0 && minColumns > 0) {
         _emulation->setImageSize(minLines , minColumns);
     }
 }
 void Session::updateWindowSize(int lines, int columns)
 {
     Q_ASSERT(lines > 0 && columns > 0);
     _shellProcess->setWindowSize(columns, lines);
 }
 void Session::refresh()
 {
     // attempt to get the shell process to redraw the display
     //
     // this requires the program running in the shell
     // to cooperate by sending an update in response to
     // a window size change
     //
     // the window size is changed twice, first made slightly larger and then
     // resized back to its normal size so that there is actually a change
     // in the window size (some shells do nothing if the
     // new and old sizes are the same)
     //
     // if there is a more 'correct' way to do this, please
     // send an email with method or patches to konsole-devel@kde.org
 
     const QSize existingSize = _shellProcess->windowSize();
     _shellProcess->setWindowSize(existingSize.width() + 1, existingSize.height());
     // introduce small delay to avoid changing size too quickly
     QThread::usleep(500);
     _shellProcess->setWindowSize(existingSize.width(), existingSize.height());
 }
 
 void Session::sendSignal(int signal)
 {
     const ProcessInfo* process = getProcessInfo();
     bool ok = false;
     int pid;
     pid = process->foregroundPid(&ok);
 
     if (ok) {
         ::kill(pid, signal);
     }
 }
 
 void Session::reportBackgroundColor(const QColor& c)
 {
     #define to65k(a) (QStringLiteral("%1").arg(int(((a)*0xFFFF)), 4, 16, QLatin1Char('0')))
     QString msg = QStringLiteral("\033]11;rgb:")
                 + to65k(c.redF())   + QLatin1Char('/')
                 + to65k(c.greenF()) + QLatin1Char('/')
                 + to65k(c.blueF())  + QLatin1Char('\a');
     _emulation->sendString(msg.toUtf8());
     #undef to65k
 }
 
 bool Session::kill(int signal)
 {
     if (_shellProcess->pid() <= 0) {
         return false;
     }
 
     int result = ::kill(_shellProcess->pid(), signal);
 
     if (result == 0) {
         return _shellProcess->waitForFinished(1000);
     } else {
         return false;
     }
 }
 
 void Session::close()
 {
     if (isRunning()) {
         if (!closeInNormalWay()) {
             closeInForceWay();
         }
     } else {
         // terminal process has finished, just close the session
         QTimer::singleShot(1, this, &Konsole::Session::finished);
     }
 }
 
 bool Session::closeInNormalWay()
 {
     _autoClose    = true;
     _closePerUserRequest = true;
 
     // for the possible case where following events happen in sequence:
     //
     // 1). the terminal process crashes
     // 2). the tab stays open and displays warning message
     // 3). the user closes the tab explicitly
     //
     if (!isRunning()) {
         emit finished();
         return true;
     }
 
     static QSet<QString> knownShells({QStringLiteral("ash"), QStringLiteral("bash"), QStringLiteral("csh"), QStringLiteral("dash"), QStringLiteral("fish"), QStringLiteral("hush"), QStringLiteral("ksh"), QStringLiteral("mksh"), QStringLiteral("pdksh"), QStringLiteral("tcsh"), QStringLiteral("zsh")});
 
     // If only the session's shell is running, try sending an EOF for a clean exit
     if (!isForegroundProcessActive() && knownShells.contains(QFileInfo(_program).fileName())) {
         _shellProcess->sendEof();
 
         if (_shellProcess->waitForFinished(1000)) {
             return true;
         }
         qWarning() << "shell did not close, sending SIGHUP";
     }
 
 
     // We tried asking nicely, ask a bit less nicely
     if (kill(SIGHUP)) {
         return true;
     } else {
         qWarning() << "Process " << _shellProcess->pid() << " did not die with SIGHUP";
         _shellProcess->closePty();
         return (_shellProcess->waitForFinished(1000));
     }
 }
 
 bool Session::closeInForceWay()
 {
     _autoClose    = true;
     _closePerUserRequest = true;
 
     if (kill(SIGKILL)) {
         return true;
     } else {
         qWarning() << "Process " << _shellProcess->pid() << " did not die with SIGKILL";
         return false;
     }
 }
 
 void Session::sendTextToTerminal(const QString& text, const QChar& eol) const
 {
     if (isReadOnly()) {
         return;
     }
 
     if (eol.isNull()) {
         _emulation->sendText(text);
     } else {
         _emulation->sendText(text + eol);
     }
 }
 
 // Only D-Bus calls this function (via SendText or runCommand)
 void Session::sendText(const QString& text) const
 {
     if (isReadOnly()) {
         return;
     }
 
 #if !defined(REMOVE_SENDTEXT_RUNCOMMAND_DBUS_METHODS)
     if (show_disallow_certain_dbus_methods_message) {
 
         KNotification::event(KNotification::Warning, QStringLiteral("Konsole D-Bus Warning"),
             i18n("The D-Bus methods sendText/runCommand were just used.  There are security concerns about allowing these methods to be public.  If desired, these methods can be changed to internal use only by re-compiling Konsole. <p>This warning will only show once for this Konsole instance.</p>"));
 
         show_disallow_certain_dbus_methods_message = false;
     }
 #endif
 
     _emulation->sendText(text);
 }
 
 // Only D-Bus calls this function
 void Session::runCommand(const QString& command) const
 {
     sendText(command + QLatin1Char('\n'));
 }
 
 void Session::sendMouseEvent(int buttons, int column, int line, int eventType)
 {
     _emulation->sendMouseEvent(buttons, column, line, eventType);
 }
 
 void Session::done(int exitCode, QProcess::ExitStatus exitStatus)
 {
     // This slot should be triggered only one time
     disconnect(_shellProcess,
                QOverload<int,QProcess::ExitStatus>::of(&Konsole::Pty::finished),
                this, &Konsole::Session::done);
 
     if (!_autoClose) {
         _userTitle = i18nc("@info:shell This session is done", "Finished");
         emit sessionAttributeChanged();
         return;
     }
 
     if (_closePerUserRequest) {
         emit finished();
         return;
     }
 
     QString message;
 
     if (exitCode != 0) {
         if (exitStatus != QProcess::NormalExit) {
             message = i18n("Program '%1' crashed.", _program);
         } else {
             message = i18n("Program '%1' exited with status %2.", _program, exitCode);
         }
 
         //FIXME: See comments in Session::silenceTimerDone()
         KNotification::event(QStringLiteral("Finished"), message , QPixmap(),
                              QApplication::activeWindow(),
                              KNotification::CloseWhenWidgetActivated);
     }
 
     if (exitStatus != QProcess::NormalExit) {
         // this seeming duplicated line is for the case when exitCode is 0
         message = i18n("Program '%1' crashed.", _program);
         terminalWarning(message);
     } else {
         emit finished();
     }
 }
 
 Emulation* Session::emulation() const
 {
     return _emulation;
 }
 
 QString Session::keyBindings() const
 {
     return _emulation->keyBindings();
 }
 
 QStringList Session::environment() const
 {
     return _environment;
 }
 
 void Session::setEnvironment(const QStringList& environment)
 {
     if (isReadOnly()) {
         return;
     }
 
     _environment = environment;
 }
 
 void Session::addEnvironmentEntry(const QString& entry)
 {
     _environment << entry;
 }
 
 int Session::sessionId() const
 {
     return _sessionId;
 }
 
 void Session::setKeyBindings(const QString& name)
 {
     _emulation->setKeyBindings(name);
 }
 
 void Session::setTitle(TitleRole role , const QString& newTitle)
 {
     if (title(role) != newTitle) {
         if (role == NameRole) {
             _nameTitle = newTitle;
         } else if (role == DisplayedTitleRole) {
             _displayTitle = newTitle;
         }
 
         emit sessionAttributeChanged();
     }
 }
 
 QString Session::title(TitleRole role) const
 {
     if (role == NameRole) {
         return _nameTitle;
     } else if (role == DisplayedTitleRole) {
         return _displayTitle;
     } else {
         return QString();
     }
 }
 
 ProcessInfo* Session::getProcessInfo()
 {
     ProcessInfo* process = nullptr;
 
     if (isForegroundProcessActive() && updateForegroundProcessInfo()) {
         process = _foregroundProcessInfo;
     } else {
         updateSessionProcessInfo();
         process = _sessionProcessInfo;
     }
 
     return process;
 }
 
 void Session::updateSessionProcessInfo()
 {
     Q_ASSERT(_shellProcess);
 
     bool ok;
     // The checking for pid changing looks stupid, but it is needed
     // at the moment to workaround the problem that processId() might
     // return 0
     if ((_sessionProcessInfo == nullptr) ||
             (processId() != 0 && processId() != _sessionProcessInfo->pid(&ok))) {
         delete _sessionProcessInfo;
         _sessionProcessInfo = ProcessInfo::newInstance(processId());
         _sessionProcessInfo->setUserHomeDir();
     }
     _sessionProcessInfo->update();
 }
 
 bool Session::updateForegroundProcessInfo()
 {
     Q_ASSERT(_shellProcess);
 
     const int foregroundPid = _shellProcess->foregroundProcessGroup();
     if (foregroundPid != _foregroundPid) {
         delete _foregroundProcessInfo;
         _foregroundProcessInfo = ProcessInfo::newInstance(foregroundPid);
         _foregroundPid = foregroundPid;
     }
 
     if (_foregroundProcessInfo != nullptr) {
         _foregroundProcessInfo->update();
         return _foregroundProcessInfo->isValid();
     } else {
         return false;
     }
 }
 
 bool Session::isRemote()
 {
     ProcessInfo* process = getProcessInfo();
 
     bool ok = false;
     return (process->name(&ok) == QLatin1String("ssh") && ok);
 }
 
 QString Session::getDynamicTitle()
 {
 
     ProcessInfo* process = getProcessInfo();
 
     // format tab titles using process info
     bool ok = false;
     if (process->name(&ok) == QLatin1String("ssh") && ok) {
         SSHProcessInfo sshInfo(*process);
         return sshInfo.format(tabTitleFormat(Session::RemoteTabTitle));
     }
 
     /*
      * Parses an input string, looking for markers beginning with a '%'
      * character and returns a string with the markers replaced
      * with information from this process description.
      * <br>
      * The markers recognized are:
      * <ul>
      * <li> %B - User's Bourne prompt sigil ($, or # for superuser). </li>
      * <li> %u - Name of the user which owns the process. </li>
      * <li> %n - Replaced with the name of the process.   </li>
      * <li> %d - Replaced with the last part of the path name of the
      *      process' current working directory.
      *
      *      (eg. if the current directory is '/home/bob' then
      *      'bob' would be returned)
      * </li>
      * <li> %D - Replaced with the current working directory of the process. </li>
      * </ul>
      */
     QString title = tabTitleFormat(Session::LocalTabTitle);
     // search for and replace known marker
 
     int UID = process->userId(&ok);
     if(!ok) {
         title.replace(QLatin1String("%B"), QStringLiteral("-"));
     } else {
         //title.replace(QLatin1String("%I"), QString::number(UID));
         if (UID == 0) {
             title.replace(QLatin1String("%B"), QStringLiteral("#"));
         } else {
             title.replace(QLatin1String("%B"), QStringLiteral("$"));
         }
     }
 
 
     title.replace(QLatin1String("%u"), process->userName());
     title.replace(QLatin1String("%h"), Konsole::ProcessInfo::localHost());
     title.replace(QLatin1String("%n"), process->name(&ok));
 
     QString dir = _reportedWorkingUrl.toLocalFile();
     ok = true;
     if (dir.isEmpty()) {
         // update current directory from process
         updateWorkingDirectory();
         dir = process->currentDir(&ok);
     }
     if(!ok) {
         title.replace(QLatin1String("%d"), QStringLiteral("-"));
         title.replace(QLatin1String("%D"), QStringLiteral("-"));
     } else {
         // allow for shortname to have the ~ as homeDir
         const QString homeDir = process->userHomeDir();
         if (!homeDir.isEmpty()) {
             if (dir.startsWith(homeDir)) {
                 dir.remove(0, homeDir.length());
                 dir.prepend(QLatin1Char('~'));
             }
         }
         title.replace(QLatin1String("%D"), dir);
         title.replace(QLatin1String("%d"), process->formatShortDir(dir));
     }
 
     return title;
 }
 
 QUrl Session::getUrl()
 {
     if (_reportedWorkingUrl.isValid()) {
         return _reportedWorkingUrl;
     }
 
     QString path;
 
     updateSessionProcessInfo();
     if (_sessionProcessInfo->isValid()) {
         bool ok = false;
 
         // check if foreground process is bookmark-able
         if (isForegroundProcessActive() && _foregroundProcessInfo->isValid()) {
             // for remote connections, save the user and host
             // bright ideas to get the directory at the other end are welcome :)
             if (_foregroundProcessInfo->name(&ok) == QLatin1String("ssh") && ok) {
                 SSHProcessInfo sshInfo(*_foregroundProcessInfo);
 
                 QUrl url;
                 url.setScheme(QStringLiteral("ssh"));
                 url.setUserName(sshInfo.userName());
                 url.setHost(sshInfo.host());
 
                 const QString port = sshInfo.port();
                 if (!port.isEmpty() && port != QLatin1String("22")) {
                     url.setPort(port.toInt());
                 }
                 return url;
             } else {
                 path = _foregroundProcessInfo->currentDir(&ok);
                 if (!ok) {
                     path.clear();
                 }
             }
         } else { // otherwise use the current working directory of the shell process
             path = _sessionProcessInfo->currentDir(&ok);
             if (!ok) {
                 path.clear();
             }
         }
     }
 
     return QUrl::fromLocalFile(path);
 }
 
 void Session::setIconName(const QString& iconName)
 {
     if (iconName != _iconName) {
         _iconName = iconName;
         emit sessionAttributeChanged();
     }
 }
 
 void Session::setIconText(const QString& iconText)
 {
     _iconText = iconText;
 }
 
 QString Session::iconName() const
 {
     return isReadOnly() ? QStringLiteral("object-locked") : _iconName;
 }
 
 QString Session::iconText() const
 {
     return _iconText;
 }
 
 void Session::setHistoryType(const HistoryType& hType)
 {
     _emulation->setHistory(hType);
 }
 
 const HistoryType& Session::historyType() const
 {
     return _emulation->history();
 }
 
 void Session::clearHistory()
 {
     _emulation->clearHistory();
 }
 
 QStringList Session::arguments() const
 {
     return _arguments;
 }
 
 QString Session::program() const
 {
     return _program;
 }
 
 bool Session::isMonitorActivity() const
 {
     return _monitorActivity;
 }
 bool Session::isMonitorSilence()  const
 {
     return _monitorSilence;
 }
 
 void Session::setMonitorActivity(bool monitor)
 {
     if (_monitorActivity == monitor) {
         return;
     }
 
     _monitorActivity  = monitor;
     _notifiedActivity = false;
 
     // This timer is meaningful only after activity has been notified
     _activityTimer->stop();
 
     activityStateSet(NOTIFYNORMAL);
 }
 
 void Session::setMonitorSilence(bool monitor)
 {
     if (_monitorSilence == monitor) {
         return;
     }
 
     _monitorSilence = monitor;
     if (_monitorSilence) {
         _silenceTimer->start(_silenceSeconds * 1000);
     } else {
         _silenceTimer->stop();
     }
 
     activityStateSet(NOTIFYNORMAL);
 }
 
 void Session::setMonitorSilenceSeconds(int seconds)
 {
     _silenceSeconds = seconds;
     if (_monitorSilence) {
         _silenceTimer->start(_silenceSeconds * 1000);
     }
 }
 
 void Session::setAddToUtmp(bool add)
 {
     _addToUtmp = add;
 }
 
 void Session::setAutoClose(bool close)
 {
     _autoClose = close;
 }
 
 bool Session::autoClose() const
 {
     return _autoClose;
 }
 
 void Session::setFlowControlEnabled(bool enabled)
 {
     if (isReadOnly()) {
         return;
     }
 
     _flowControlEnabled = enabled;
 
     if (_shellProcess != nullptr) {
         _shellProcess->setFlowControlEnabled(_flowControlEnabled);
     }
 
     emit flowControlEnabledChanged(enabled);
 }
 bool Session::flowControlEnabled() const
 {
     if (_shellProcess != nullptr) {
         return _shellProcess->flowControlEnabled();
     } else {
         return _flowControlEnabled;
     }
 }
 void Session::fireZModemDownloadDetected()
 {
     if (!_zmodemBusy) {
         QTimer::singleShot(10, this, &Konsole::Session::zmodemDownloadDetected);
         _zmodemBusy = true;
     }
 }
 
 void Session::fireZModemUploadDetected()
 {
     if (!_zmodemBusy) {
         QTimer::singleShot(10, this, &Konsole::Session::zmodemUploadDetected);
     }
 }
 
 void Session::cancelZModem()
 {
     _shellProcess->sendData(QByteArrayLiteral("\030\030\030\030")); // Abort
     _zmodemBusy = false;
 }
 
 void Session::startZModem(const QString& zmodem, const QString& dir, const QStringList& list)
 {
     _zmodemBusy = true;
     _zmodemProc = new KProcess();
     _zmodemProc->setOutputChannelMode(KProcess::SeparateChannels);
 
     *_zmodemProc << zmodem << QStringLiteral("-v") << QStringLiteral("-e") << list;
 
     if (!dir.isEmpty()) {
         _zmodemProc->setWorkingDirectory(dir);
     }
 
     connect(_zmodemProc, &KProcess::readyReadStandardOutput, this, &Konsole::Session::zmodemReadAndSendBlock);
     connect(_zmodemProc, &KProcess::readyReadStandardError, this, &Konsole::Session::zmodemReadStatus);
     connect(_zmodemProc,
             QOverload<int,QProcess::ExitStatus>::of(&KProcess::finished),
             this, &Konsole::Session::zmodemFinished);
 
     _zmodemProc->start();
 
     disconnect(_shellProcess, &Konsole::Pty::receivedData,
                this, &Konsole::Session::onReceiveBlock);
     connect(_shellProcess, &Konsole::Pty::receivedData, this, &Konsole::Session::zmodemReceiveBlock);
 
     _zmodemProgress = new ZModemDialog(QApplication::activeWindow(), false,
                                        i18n("ZModem Progress"));
 
     connect(_zmodemProgress, &Konsole::ZModemDialog::zmodemCancel, this, &Konsole::Session::zmodemFinished);
 
     _zmodemProgress->show();
 }
 
 void Session::zmodemReadAndSendBlock()
 {
     _zmodemProc->setReadChannel(QProcess::StandardOutput);
     QByteArray data = _zmodemProc->read(ZMODEM_BUFFER_SIZE);
 
     while (data.count() != 0) {
         _shellProcess->sendData(data);
         data = _zmodemProc->read(ZMODEM_BUFFER_SIZE);
     }
 }
 
 void Session::zmodemReadStatus()
 {
     _zmodemProc->setReadChannel(QProcess::StandardError);
     QByteArray msg = _zmodemProc->readAll();
     while (!msg.isEmpty()) {
         int i = msg.indexOf('\015');
         int j = msg.indexOf('\012');
         QByteArray txt;
         if ((i != -1) && ((j == -1) || (i < j))) {
             msg = msg.mid(i + 1);
         } else if (j != -1) {
             txt = msg.left(j);
             msg = msg.mid(j + 1);
         } else {
             txt = msg;
             msg.truncate(0);
         }
         if (!txt.isEmpty()) {
             _zmodemProgress->addText(QString::fromLocal8Bit(txt));
         }
     }
 }
 
 void Session::zmodemReceiveBlock(const char* data, int len)
 {
     static int steps = 0;
     QByteArray bytes(data, len);
 
     _zmodemProc->write(bytes);
 
     // Provide some feedback to dialog
     if (steps > 100) {
         _zmodemProgress->addProgressText(QStringLiteral("."));
         steps = 0;
     }
     steps++;
 }
 
 void Session::zmodemFinished()
 {
     /* zmodemFinished() is called by QProcess's finished() and
        ZModemDialog's user1Clicked(). Therefore, an invocation by
        user1Clicked() will recursively invoke this function again
        when the KProcess is deleted! */
     if (_zmodemProc != nullptr) {
         KProcess* process = _zmodemProc;
         _zmodemProc = nullptr;   // Set _zmodemProc to 0 avoid recursive invocations!
         _zmodemBusy = false;
         delete process;    // Now, the KProcess may be disposed safely.
 
         disconnect(_shellProcess, &Konsole::Pty::receivedData,
                    this , &Konsole::Session::zmodemReceiveBlock);
         connect(_shellProcess, &Konsole::Pty::receivedData, this, &Konsole::Session::onReceiveBlock);
 
         _shellProcess->sendData(QByteArrayLiteral("\030\030\030\030")); // Abort
         _shellProcess->sendData(QByteArrayLiteral("\001\013\n")); // Try to get prompt back
         _zmodemProgress->transferDone();
     }
 }
 
 void Session::onReceiveBlock(const char* buf, int len)
 {
     _emulation->receiveData(buf, len);
 }
 
 QSize Session::size()
 {
     return _emulation->imageSize();
 }
 
 void Session::setSize(const QSize& size)
 {
     if ((size.width() <= 1) || (size.height() <= 1)) {
         return;
     }
 
     emit resizeRequest(size);
 }
 
 QSize Session::preferredSize() const
 {
     return _preferredSize;
 }
 
 void Session::setPreferredSize(const QSize& size)
 {
     _preferredSize = size;
 }
 
 int Session::processId() const
 {
     return _shellProcess->pid();
 }
 
 void Session::setTitle(int role , const QString& title)
 {
     switch (role) {
     case 0:
         setTitle(Session::NameRole, title);
         break;
     case 1:
         setTitle(Session::DisplayedTitleRole, title);
 
         // without these, that title will be overridden by the expansion of
         // title format shortly after, which will confuses users.
         _localTabTitleFormat = title;
         _remoteTabTitleFormat = title;
 
         break;
     }
 }
 
 QString Session::title(int role) const
 {
     switch (role) {
     case 0:
         return title(Session::NameRole);
     case 1:
         return title(Session::DisplayedTitleRole);
     default:
         return QString();
     }
 }
 
 void Session::setTabTitleFormat(int context , const QString& format)
 {
     switch (context) {
     case 0:
         setTabTitleFormat(Session::LocalTabTitle, format);
         break;
     case 1:
         setTabTitleFormat(Session::RemoteTabTitle, format);
         break;
     }
 }
 
 QString Session::tabTitleFormat(int context) const
 {
     switch (context) {
     case 0:
         return tabTitleFormat(Session::LocalTabTitle);
     case 1:
         return tabTitleFormat(Session::RemoteTabTitle);
     default:
         return QString();
     }
 }
 
 void Session::setHistorySize(int lines)
 {
     if (isReadOnly()) {
         return;
     }
 
     if (lines < 0) {
         setHistoryType(HistoryTypeFile());
     } else if (lines == 0) {
         setHistoryType(HistoryTypeNone());
     } else {
         setHistoryType(CompactHistoryType(lines));
     }
 }
 
 int Session::historySize() const
 {
     const HistoryType& currentHistory = historyType();
 
     if (currentHistory.isEnabled()) {
         if (currentHistory.isUnlimited()) {
             return -1;
         } else {
             return currentHistory.maximumLineCount();
         }
     } else {
         return 0;
     }
 }
 
 QString Session::profile()
 {
     return SessionManager::instance()->sessionProfile(this)->name();
 }
 
 void Session::setProfile(const QString &profileName)
 {
   const QList<Profile::Ptr> profiles = ProfileManager::instance()->allProfiles();
-  foreach (const Profile::Ptr &profile, profiles) {
+  for (const Profile::Ptr &profile : profiles) {
     if (profile->name() == profileName) {
       SessionManager::instance()->setSessionProfile(this, profile);
     }
   }
 }
 
 int Session::foregroundProcessId()
 {
     int pid;
 
     bool ok = false;
     pid = getProcessInfo()->pid(&ok);
     if (!ok) {
         pid = -1;
     }
 
     return pid;
 }
 
 bool Session::isForegroundProcessActive()
 {
     // foreground process info is always updated after this
     return (_shellProcess->pid() != _shellProcess->foregroundProcessGroup());
 }
 
 QString Session::foregroundProcessName()
 {
     QString name;
 
     if (updateForegroundProcessInfo()) {
         bool ok = false;
         name = _foregroundProcessInfo->name(&ok);
         if (!ok) {
             name.clear();
         }
     }
 
     return name;
 }
 
 void Session::saveSession(KConfigGroup& group)
 {
     group.writePathEntry("WorkingDir", currentWorkingDirectory());
     group.writeEntry("LocalTab",       tabTitleFormat(LocalTabTitle));
     group.writeEntry("RemoteTab",      tabTitleFormat(RemoteTabTitle));
     group.writeEntry("SessionGuid",    _uniqueIdentifier.toString());
     group.writeEntry("Encoding",       QString::fromUtf8(codec()));
 }
 
 void Session::restoreSession(KConfigGroup& group)
 {
     QString value;
 
     value = group.readPathEntry("WorkingDir", QString());
     if (!value.isEmpty()) {
         setInitialWorkingDirectory(value);
     }
     value = group.readEntry("LocalTab");
     if (!value.isEmpty()) {
         setTabTitleFormat(LocalTabTitle, value);
     }
     value = group.readEntry("RemoteTab");
     if (!value.isEmpty()) {
         setTabTitleFormat(RemoteTabTitle, value);
     }
     value = group.readEntry("SessionGuid");
     if (!value.isEmpty()) {
         _uniqueIdentifier = QUuid(value);
     }
     value = group.readEntry("Encoding");
     if (!value.isEmpty()) {
         setCodec(value.toUtf8());
     }
 }
 
 QString Session::validDirectory(const QString& dir) const
 {
     QString validDir = dir;
     if (validDir.isEmpty()) {
         validDir = QDir::currentPath();
     }
 
     const QFileInfo fi(validDir);
     if (!fi.exists() || !fi.isDir()) {
         validDir = QDir::homePath();
     }
 
     return validDir;
 }
 
 bool Session::isReadOnly() const
 {
     return _readOnly;
 }
 
 void Session::setReadOnly(bool readOnly)
 {
     if (_readOnly != readOnly) {
         _readOnly = readOnly;
 
         // Needed to update the tab icons and all
         // attached views.
         emit readOnlyChanged();
     }
 }
 
 SessionGroup::SessionGroup(QObject* parent)
     : QObject(parent), _masterMode(0)
 {
 }
 SessionGroup::~SessionGroup() = default;
 
 int SessionGroup::masterMode() const
 {
     return _masterMode;
 }
 QList<Session*> SessionGroup::sessions() const
 {
     return _sessions.keys();
 }
 bool SessionGroup::masterStatus(Session* session) const
 {
     return _sessions[session];
 }
 
 void SessionGroup::addSession(Session* session)
 {
     connect(session, &Konsole::Session::finished, this, &Konsole::SessionGroup::sessionFinished);
     _sessions.insert(session, false);
 }
 void SessionGroup::removeSession(Session* session)
 {
     disconnect(session, &Konsole::Session::finished, this, &Konsole::SessionGroup::sessionFinished);
     setMasterStatus(session, false);
     _sessions.remove(session);
 }
 void SessionGroup::sessionFinished()
 {
     auto* session = qobject_cast<Session*>(sender());
     Q_ASSERT(session);
     removeSession(session);
 }
 void SessionGroup::setMasterMode(int mode)
 {
     _masterMode = mode;
 }
 QList<Session*> SessionGroup::masters() const
 {
     return _sessions.keys(true);
 }
 void SessionGroup::setMasterStatus(Session* session , bool master)
 {
     const bool wasMaster = _sessions[session];
 
     if (wasMaster == master) {
         // No status change -> nothing to do.
         return;
     }
     _sessions[session] = master;
 
     if (master) {
         connect(session->emulation(), &Konsole::Emulation::sendData, this, &Konsole::SessionGroup::forwardData);
     } else {
         disconnect(session->emulation(), &Konsole::Emulation::sendData,
                    this, &Konsole::SessionGroup::forwardData);
     }
 }
 void SessionGroup::forwardData(const QByteArray& data)
 {
     static bool _inForwardData = false;
     if (_inForwardData) {  // Avoid recursive calls among session groups!
         // A recursive call happens when a master in group A calls forwardData()
         // in group B. If one of the destination sessions in group B is also a
         // master of a group including the master session of group A, this would
         // again call forwardData() in group A, and so on.
         return;
     }
 
     _inForwardData = true;
     const QList<Session*> sessionsKeys = _sessions.keys();
-    foreach(Session* other, sessionsKeys) {
+    for (Session *other : sessionsKeys) {
         if (!_sessions[other]) {
             other->emulation()->sendString(data);
         }
     }
     _inForwardData = false;
 }
 
diff --git a/src/SessionManager.cpp b/src/SessionManager.cpp
index b82d629c..db89ceb6 100644
--- a/src/SessionManager.cpp
+++ b/src/SessionManager.cpp
@@ -1,390 +1,390 @@
 /*
     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 "SessionManager.h"
 
 #include "konsoledebug.h"
 
 // Qt
 #include <QStringList>
 #include <QTextCodec>
 
 // KDE
 #include <KConfig>
 #include <KConfigGroup>
 
 // Konsole
 #include "Session.h"
 #include "ProfileManager.h"
 #include "History.h"
 #include "Enumeration.h"
 #include "TerminalDisplay.h"
 
 using namespace Konsole;
 
 SessionManager::SessionManager() :
     _sessions(QList<Session *>()),
     _sessionProfiles(QHash<Session *, Profile::Ptr>()),
     _sessionRuntimeProfiles(QHash<Session *, Profile::Ptr>()),
     _restoreMapping(QHash<Session *, int>()),
     _isClosingAllSessions(false)
 {
     ProfileManager *profileMananger = ProfileManager::instance();
     connect(profileMananger, &Konsole::ProfileManager::profileChanged, this,
             &Konsole::SessionManager::profileChanged);
 }
 
 SessionManager::~SessionManager()
 {
     if (!_sessions.isEmpty()) {
         qCDebug(KonsoleDebug) << "Konsole SessionManager destroyed with"
                               << _sessions.count()
                               <<"session(s) still alive";
         // ensure that the Session doesn't later try to call back and do things to the
         // SessionManager
-        foreach (Session *session, _sessions) {
+        for (Session *session : qAsConst(_sessions)) {
             disconnect(session, nullptr, this, nullptr);
         }
     }
 }
 
 Q_GLOBAL_STATIC(SessionManager, theSessionManager)
 SessionManager* SessionManager::instance()
 {
     return theSessionManager;
 }
 
 bool SessionManager::isClosingAllSessions() const
 {
     return _isClosingAllSessions;
 }
 
 void SessionManager::closeAllSessions()
 {
     _isClosingAllSessions = true;
-    foreach (Session *session, _sessions) {
+    for (Session *session : qAsConst(_sessions)) {
         session->close();
     }
     _sessions.clear();
 }
 
 const QList<Session *> SessionManager::sessions() const
 {
     return _sessions;
 }
 
 Session *SessionManager::createSession(Profile::Ptr profile)
 {
     if (!profile) {
         profile = ProfileManager::instance()->defaultProfile();
     }
 
     // TODO: check whether this is really needed
     if (!ProfileManager::instance()->loadedProfiles().contains(profile)) {
         ProfileManager::instance()->addProfile(profile);
     }
 
     //configuration information found, create a new session based on this
     auto session = new Session();
     Q_ASSERT(session);
     applyProfile(session, profile, false);
 
     connect(session, &Konsole::Session::profileChangeCommandReceived, this,
             &Konsole::SessionManager::sessionProfileCommandReceived);
 
     //ask for notification when session dies
     connect(session, &Konsole::Session::finished, this,
             [this, session]() {
                 sessionTerminated(session);
             });
 
     //add session to active list
     _sessions << session;
     _sessionProfiles.insert(session, profile);
 
     return session;
 }
 
 void SessionManager::profileChanged(const Profile::Ptr &profile)
 {
     applyProfile(profile, true);
 }
 
 void SessionManager::sessionTerminated(Session *session)
 {
     Q_ASSERT(session);
 
     _sessions.removeAll(session);
     _sessionProfiles.remove(session);
     _sessionRuntimeProfiles.remove(session);
 
     session->deleteLater();
 }
 
 void SessionManager::applyProfile(const Profile::Ptr &profile, bool modifiedPropertiesOnly)
 {
-    foreach (Session *session, _sessions) {
+    for (Session *session : qAsConst(_sessions)) {
         if (_sessionProfiles[session] == profile) {
             applyProfile(session, profile, modifiedPropertiesOnly);
         }
     }
 }
 
 Profile::Ptr SessionManager::sessionProfile(Session *session) const
 {
     return _sessionProfiles[session];
 }
 
 void SessionManager::setSessionProfile(Session *session, Profile::Ptr profile)
 {
     if (!profile) {
         profile = ProfileManager::instance()->defaultProfile();
     }
 
     Q_ASSERT(profile);
 
     _sessionProfiles[session] = profile;
 
     applyProfile(session, profile, false);
 
     emit sessionUpdated(session);
 }
 
 void SessionManager::applyProfile(Session *session, const Profile::Ptr &profile,
                                   bool modifiedPropertiesOnly)
 {
     Q_ASSERT(profile);
 
     _sessionProfiles[session] = profile;
 
     ShouldApplyProperty apply(profile, modifiedPropertiesOnly);
 
     // Basic session settings
     if (apply.shouldApply(Profile::Name)) {
         session->setTitle(Session::NameRole, profile->name());
     }
 
     if (apply.shouldApply(Profile::Command)) {
         session->setProgram(profile->command());
     }
 
     if (apply.shouldApply(Profile::Arguments)) {
         session->setArguments(profile->arguments());
     }
 
     if (apply.shouldApply(Profile::Directory)) {
         session->setInitialWorkingDirectory(profile->defaultWorkingDirectory());
     }
 
     if (apply.shouldApply(Profile::Environment)) {
         // add environment variable containing home directory of current profile
         // (if specified)
 
         // prepend a 0 to the VERSION_MICRO part to make the version string
         // length consistent, so that conditions that depend on the exported
         // env var actually work
         // e.g. the second version should be higher than the first one:
         // 18.04.12 -> 180412
         // 18.08.0  -> 180800
         QStringList list = QStringLiteral(KONSOLE_VERSION).split(QLatin1Char('.'));
         if (list[2].length() < 2) {
                 list[2].prepend(QLatin1String("0"));
         }
         const QString &numericVersion = list.join(QString());
 
         QStringList environment = profile->environment();
         environment << QStringLiteral("PROFILEHOME=%1").arg(profile->defaultWorkingDirectory());
         environment << QStringLiteral("KONSOLE_VERSION=%1").arg(numericVersion);
 
         session->setEnvironment(environment);
     }
 
     if (apply.shouldApply(Profile::TerminalColumns)
         || apply.shouldApply(Profile::TerminalRows)) {
         const auto columns = profile->property<int>(Profile::TerminalColumns);
         const auto rows = profile->property<int>(Profile::TerminalRows);
         session->setPreferredSize(QSize(columns, rows));
     }
 
     if (apply.shouldApply(Profile::Icon)) {
         session->setIconName(profile->icon());
     }
 
     // Key bindings
     if (apply.shouldApply(Profile::KeyBindings)) {
         session->setKeyBindings(profile->keyBindings());
     }
 
     // Tab formats
     // Preserve tab title changes, made by the user, when applying profile
     // changes or previewing color schemes
     if (apply.shouldApply(Profile::LocalTabTitleFormat) && !session->isTabTitleSetByUser()) {
         session->setTabTitleFormat(Session::LocalTabTitle,
                                    profile->localTabTitleFormat());
     }
     if (apply.shouldApply(Profile::RemoteTabTitleFormat) && !session->isTabTitleSetByUser()) {
         session->setTabTitleFormat(Session::RemoteTabTitle,
                                    profile->remoteTabTitleFormat());
     }
 
     // History
     if (apply.shouldApply(Profile::HistoryMode) || apply.shouldApply(Profile::HistorySize)) {
         const auto mode = profile->property<int>(Profile::HistoryMode);
         switch (mode) {
         case Enum::NoHistory:
             session->setHistoryType(HistoryTypeNone());
             break;
 
         case Enum::FixedSizeHistory:
         {
             int lines = profile->historySize();
             session->setHistoryType(CompactHistoryType(lines));
             break;
         }
 
         case Enum::UnlimitedHistory:
             session->setHistoryType(HistoryTypeFile());
             break;
         }
     }
 
     // Terminal features
     if (apply.shouldApply(Profile::FlowControlEnabled)) {
         session->setFlowControlEnabled(profile->flowControlEnabled());
     }
 
     // Encoding
     if (apply.shouldApply(Profile::DefaultEncoding)) {
         QByteArray name = profile->defaultEncoding().toUtf8();
         session->setCodec(QTextCodec::codecForName(name));
     }
 
     // Monitor Silence
     if (apply.shouldApply(Profile::SilenceSeconds)) {
         session->setMonitorSilenceSeconds(profile->silenceSeconds());
     }
 }
 
 void SessionManager::sessionProfileCommandReceived(const QString &text)
 {
     auto *session = qobject_cast<Session *>(sender());
     Q_ASSERT(session);
 
     // store the font for each view if zoom was applied so that they can
     // be restored after applying the new profile
     QHash<TerminalDisplay *, QFont> zoomFontSizes;
-
-    foreach (TerminalDisplay *view, session->views()) {
+    const QList<TerminalDisplay *> views = session->views();
+    for (TerminalDisplay *view : views) {
         const QFont &viewCurFont = view->getVTFont();
         if (viewCurFont != _sessionProfiles[session]->font()) {
             zoomFontSizes.insert(view, viewCurFont);
         }
     }
 
     ProfileCommandParser parser;
     QHash<Profile::Property, QVariant> changes = parser.parse(text);
 
     Profile::Ptr newProfile;
     if (!_sessionRuntimeProfiles.contains(session)) {
         newProfile = new Profile(_sessionProfiles[session]);
         _sessionRuntimeProfiles.insert(session, newProfile);
     } else {
         newProfile = _sessionRuntimeProfiles[session];
     }
 
     QHashIterator<Profile::Property, QVariant> iter(changes);
     while (iter.hasNext()) {
         iter.next();
         newProfile->setProperty(iter.key(), iter.value());
     }
 
     _sessionProfiles[session] = newProfile;
     applyProfile(newProfile, true);
     emit sessionUpdated(session);
 
     if (!zoomFontSizes.isEmpty()) {
         QHashIterator<TerminalDisplay *, QFont> it(zoomFontSizes);
         while (it.hasNext()) {
             it.next();
             it.key()->setVTFont(it.value());
         }
     }
 }
 
 void SessionManager::saveSessions(KConfig *config)
 {
     // The session IDs can't be restored.
     // So we need to map the old ID to the future new ID.
     int n = 1;
     _restoreMapping.clear();
 
-    foreach (Session *session, _sessions) {
+    for (Session *session : qAsConst(_sessions)) {
         QString name = QLatin1String("Session") + QString::number(n);
         KConfigGroup group(config, name);
 
         group.writePathEntry("Profile",
                              _sessionProfiles.value(session)->path());
         session->saveSession(group);
         _restoreMapping.insert(session, n);
         n++;
     }
 
     KConfigGroup group(config, "Number");
     group.writeEntry("NumberOfSessions", _sessions.count());
 }
 
 int SessionManager::getRestoreId(Session *session)
 {
     return _restoreMapping.value(session);
 }
 
 void SessionManager::restoreSessions(KConfig *config)
 {
     KConfigGroup group(config, "Number");
     const int sessions = group.readEntry("NumberOfSessions", 0);
 
     // Any sessions saved?
     for (int n = 1; n <= sessions; n++) {
         const QString name = QLatin1String("Session") + QString::number(n);
         KConfigGroup sessionGroup(config, name);
 
         const QString profile = sessionGroup.readPathEntry("Profile", QString());
         Profile::Ptr ptr = ProfileManager::instance()->defaultProfile();
         if (!profile.isEmpty()) {
             ptr = ProfileManager::instance()->loadProfile(profile);
         }
         Session *session = createSession(ptr);
         session->restoreSession(sessionGroup);
     }
 }
 
 Session *SessionManager::idToSession(int id)
 {
-    foreach (Session *session, _sessions) {
+    for (Session *session : qAsConst(_sessions)) {
         if (session->sessionId() == id) {
             return session;
         }
     }
     // this should not happen
     qCDebug(KonsoleDebug) << "Failed to find session for ID" << id;
     return nullptr;
 }
diff --git a/src/TerminalDisplay.cpp b/src/TerminalDisplay.cpp
index 446bfe76..dca9c236 100644
--- a/src/TerminalDisplay.cpp
+++ b/src/TerminalDisplay.cpp
@@ -1,4002 +1,4004 @@
 /*
     This file is part of Konsole, a terminal emulator for KDE.
 
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
     Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.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 "TerminalDisplay.h"
 
 // Config
 #include "config-konsole.h"
 
 // Qt
 #include <QApplication>
 #include <QClipboard>
 #include <QKeyEvent>
 #include <QEvent>
 #include <QFileInfo>
 #include <QVBoxLayout>
 #include <QAction>
 #include <QLabel>
 #include <QMimeData>
 #include <QPainter>
 #include <QPixmap>
 #include <QScrollBar>
 #include <QStyle>
 #include <QTimer>
 #include <QDrag>
 #include <QDesktopServices>
 #include <QAccessible>
 #include <QtMath>
 
 // KDE
 #include <KShell>
 #include <KColorScheme>
 #include <KCursor>
 #include <KLocalizedString>
 #include <KNotification>
 #include <KIO/DropJob>
 #include <KJobWidgets>
 #include <KMessageBox>
 #include <KMessageWidget>
 #include <KIO/StatJob>
 
 // Konsole
 #include "Filter.h"
 #include "konsoledebug.h"
 #include "TerminalCharacterDecoder.h"
 #include "Screen.h"
 #include "SessionController.h"
 #include "ExtendedCharTable.h"
 #include "TerminalDisplayAccessible.h"
 #include "SessionManager.h"
 #include "Session.h"
 #include "WindowSystemInfo.h"
 #include "IncrementalSearchBar.h"
 #include "Profile.h"
 #include "ViewManager.h" // for colorSchemeForProfile. // TODO: Rewrite this.
 #include "LineBlockCharacters.h"
 
 using namespace Konsole;
 
 #define REPCHAR   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
     "abcdefgjijklmnopqrstuvwxyz" \
     "0123456789./+@"
 
 // we use this to force QPainter to display text in LTR mode
 // more information can be found in: https://unicode.org/reports/tr9/
 const QChar LTR_OVERRIDE_CHAR(0x202D);
 
 inline int TerminalDisplay::loc(int x, int y) const {
     Q_ASSERT(y >= 0 && y < _lines);
     Q_ASSERT(x >= 0 && x < _columns);
     x = qBound(0, x, _columns - 1);
     y = qBound(0, y, _lines - 1);
 
     return y * _columns + x;
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Colors                                     */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 /* Note that we use ANSI color order (bgr), while IBMPC color order is (rgb)
 
    Code        0       1       2       3       4       5       6       7
    ----------- ------- ------- ------- ------- ------- ------- ------- -------
    ANSI  (bgr) Black   Red     Green   Yellow  Blue    Magenta Cyan    White
    IBMPC (rgb) Black   Blue    Green   Cyan    Red     Magenta Yellow  White
 */
 
 ScreenWindow* TerminalDisplay::screenWindow() const
 {
     return _screenWindow;
 }
 void TerminalDisplay::setScreenWindow(ScreenWindow* window)
 {
     // disconnect existing screen window if any
     if (!_screenWindow.isNull()) {
         disconnect(_screenWindow , nullptr , this , nullptr);
     }
 
     _screenWindow = window;
 
     if (!_screenWindow.isNull()) {
         connect(_screenWindow.data() , &Konsole::ScreenWindow::outputChanged , this , &Konsole::TerminalDisplay::updateLineProperties);
         connect(_screenWindow.data() , &Konsole::ScreenWindow::outputChanged , this , &Konsole::TerminalDisplay::updateImage);
         connect(_screenWindow.data() , &Konsole::ScreenWindow::currentResultLineChanged , this , &Konsole::TerminalDisplay::updateImage);
         connect(_screenWindow.data(), &Konsole::ScreenWindow::outputChanged, this, [this]() {
             _filterUpdateRequired = true;
         });
         connect(_screenWindow.data(), &Konsole::ScreenWindow::scrolled, this, [this]() {
             _filterUpdateRequired = true;
         });
         _screenWindow->setWindowLines(_lines);
     }
 }
 
 const ColorEntry* TerminalDisplay::colorTable() const
 {
     return _colorTable;
 }
 
 void TerminalDisplay::onColorsChanged()
 {
     // Mostly just fix the scrollbar
     // this is a workaround to add some readability to old themes like Fusion
     // changing the light value for button a bit makes themes like fusion, windows and oxygen way more readable and pleasing
 
     QPalette p = QApplication::palette();
 
     QColor buttonTextColor = _colorTable[DEFAULT_FORE_COLOR];
     QColor backgroundColor = _colorTable[DEFAULT_BACK_COLOR];
     backgroundColor.setAlphaF(_opacity);
 
     QColor buttonColor = backgroundColor.toHsv();
     if (buttonColor.valueF() < 0.5) {
         buttonColor = buttonColor.lighter();
     } else {
         buttonColor = buttonColor.darker();
     }
     p.setColor(QPalette::Button, buttonColor);
     p.setColor(QPalette::Window, backgroundColor);
     p.setColor(QPalette::Base, backgroundColor);
     p.setColor(QPalette::WindowText, buttonTextColor);
     p.setColor(QPalette::ButtonText, buttonTextColor);
 
     setPalette(p);
 
     _scrollBar->setPalette(p);
 
     update();
 }
 
 void TerminalDisplay::setBackgroundColor(const QColor& color)
 {
     _colorTable[DEFAULT_BACK_COLOR] = color;
 
     onColorsChanged();
 }
 
 QColor TerminalDisplay::getBackgroundColor() const
 {
     return _colorTable[DEFAULT_BACK_COLOR];
 }
 
 void TerminalDisplay::setForegroundColor(const QColor& color)
 {
     _colorTable[DEFAULT_FORE_COLOR] = color;
 
     onColorsChanged();
 }
 
 void TerminalDisplay::setColorTable(const ColorEntry table[])
 {
     for (int i = 0; i < TABLE_COLORS; i++) {
         _colorTable[i] = table[i];
     }
 
     setBackgroundColor(_colorTable[DEFAULT_BACK_COLOR]);
 
     onColorsChanged();
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                   Font                                    */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 static inline bool isLineCharString(const QString& string)
 {
     if (string.length() == 0) {
         return false;
     }
 
     return LineBlockCharacters::canDraw(string.at(0).unicode());
 }
 
 void TerminalDisplay::fontChange(const QFont&)
 {
     QFontMetrics fm(font());
     _fontHeight = fm.height() + _lineSpacing;
 
     Q_ASSERT(_fontHeight > 0);
 
     /* TODO: When changing the three deprecated width() below
      *       consider the info in
      *       https://phabricator.kde.org/D23144 comments
      *       horizontalAdvance() was added in Qt 5.11 (which should be the
      *       minimum for 20.04 or 20.08 KDE Applications release)
      */
 
     // waba TerminalDisplay 1.123:
     // "Base character width on widest ASCII character. This prevents too wide
     //  characters in the presence of double wide (e.g. Japanese) characters."
     // Get the width from representative normal width characters
     _fontWidth = qRound((static_cast<double>(fm.width(QStringLiteral(REPCHAR))) / static_cast<double>(qstrlen(REPCHAR))));
 
     _fixedFont = true;
 
     const int fw = fm.width(QLatin1Char(REPCHAR[0]));
     for (unsigned int i = 1; i < qstrlen(REPCHAR); i++) {
         if (fw != fm.width(QLatin1Char(REPCHAR[i]))) {
             _fixedFont = false;
             break;
         }
     }
 
     if (_fontWidth < 1) {
         _fontWidth = 1;
     }
 
     _fontAscent = fm.ascent();
 
     emit changedFontMetricSignal(_fontHeight, _fontWidth);
     propagateSize();
     update();
 }
 
 void TerminalDisplay::setVTFont(const QFont& f)
 {
     QFont newFont(f);
     int strategy = 0;
 
     // hint that text should be drawn with- or without anti-aliasing.
     // depending on the user's font configuration, this may not be respected
     strategy |= _antialiasText ? QFont::PreferAntialias : QFont::NoAntialias;
 
     // Konsole cannot handle non-integer font metrics
     strategy |= QFont::ForceIntegerMetrics;
 
     // In case the provided font doesn't have some specific characters it should
     // fall back to a Monospace fonts.
     newFont.setStyleHint(QFont::TypeWriter, QFont::StyleStrategy(strategy));
 
     // Try to check that a good font has been loaded.
     // For some fonts, ForceIntegerMetrics causes height() == 0 which
     // will cause Konsole to crash later.
     QFontMetrics fontMetrics2(newFont);
     if (fontMetrics2.height() < 1) {
         qCDebug(KonsoleDebug)<<"The font "<<newFont.toString()<<" has an invalid height()";
         // Ask for a generic font so at least it is usable.
         // Font listed in profile's dialog will not be updated.
         newFont = QFont(QStringLiteral("Monospace"));
         // Set style strategy without ForceIntegerMetrics for the font
         strategy &= ~QFont::ForceIntegerMetrics;
         newFont.setStyleHint(QFont::TypeWriter, QFont::StyleStrategy(strategy));
         qCDebug(KonsoleDebug)<<"Font changed to "<<newFont.toString();
     }
 
     // experimental optimization.  Konsole assumes that the terminal is using a
     // mono-spaced font, in which case kerning information should have an effect.
     // Disabling kerning saves some computation when rendering text.
     newFont.setKerning(false);
 
     // "Draw intense colors in bold font" feature needs to use different font weights. StyleName
     // property, when set, doesn't allow weight changes. Since all properties (weight, stretch,
     // italic, etc) are stored in QFont independently, in almost all cases styleName is not needed.
     newFont.setStyleName(QString());
 
     if (newFont == font()) {
         // Do not process the same font again
         return;
     }
 
     QFontInfo fontInfo(newFont);
 
     // QFontInfo::fixedPitch() appears to not match QFont::fixedPitch() - do not test it.
     // related?  https://bugreports.qt.io/browse/QTBUG-34082
     if (fontInfo.family() != newFont.family()
             || !qFuzzyCompare(fontInfo.pointSizeF(), newFont.pointSizeF())
             || fontInfo.styleHint()  != newFont.styleHint()
             || fontInfo.weight()     != newFont.weight()
             || fontInfo.style()      != newFont.style()
             || fontInfo.underline()  != newFont.underline()
             || fontInfo.strikeOut()  != newFont.strikeOut()
             || fontInfo.rawMode()    != newFont.rawMode()) {
         const QString nonMatching = QString::asprintf("%s,%g,%d,%d,%d,%d,%d,%d,%d,%d",
                 qPrintable(fontInfo.family()),
                 fontInfo.pointSizeF(),
                 -1, // pixelSize is not used
                 static_cast<int>(fontInfo.styleHint()),
                 fontInfo.weight(),
                 static_cast<int>(fontInfo.style()),
                 static_cast<int>(fontInfo.underline()),
                 static_cast<int>(fontInfo.strikeOut()),
                 // Intentional newFont use - fixedPitch is bugged, see comment above
                 static_cast<int>(newFont.fixedPitch()),
                 static_cast<int>(fontInfo.rawMode()));
         qCDebug(KonsoleDebug) << "The font to use in the terminal can not be matched exactly on your system.";
         qCDebug(KonsoleDebug) << " Selected: " << newFont.toString();
         qCDebug(KonsoleDebug) << " System  : " << nonMatching;
     }
 
     QWidget::setFont(newFont);
     fontChange(newFont);
 }
 
 void TerminalDisplay::increaseFontSize()
 {
     QFont font = getVTFont();
     font.setPointSizeF(font.pointSizeF() + 1);
     setVTFont(font);
 }
 
 void TerminalDisplay::decreaseFontSize()
 {
     const qreal MinimumFontSize = 6;
 
     QFont font = getVTFont();
     font.setPointSizeF(qMax(font.pointSizeF() - 1, MinimumFontSize));
     setVTFont(font);
 }
 
 void TerminalDisplay::resetFontSize()
 {
     const qreal MinimumFontSize = 6;
 
     QFont font = getVTFont();
     Profile::Ptr currentProfile = SessionManager::instance()->sessionProfile(_sessionController->session());
     const qreal defaultFontSize = currentProfile->font().pointSizeF();
 
     font.setPointSizeF(qMax(defaultFontSize, MinimumFontSize));
     setVTFont(font);
 }
 
 uint TerminalDisplay::lineSpacing() const
 {
     return _lineSpacing;
 }
 
 void TerminalDisplay::setLineSpacing(uint i)
 {
     _lineSpacing = i;
     fontChange(font()); // Trigger an update.
 }
 
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                         Accessibility                                     */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 namespace Konsole
 {
 
 #ifndef QT_NO_ACCESSIBILITY
 /**
  * This function installs the factory function which lets Qt instantiate the QAccessibleInterface
  * for the TerminalDisplay.
  */
 QAccessibleInterface* accessibleInterfaceFactory(const QString &key, QObject *object)
 {
     Q_UNUSED(key)
     if (auto *display = qobject_cast<TerminalDisplay*>(object)) {
         return new TerminalDisplayAccessible(display);
     }
     return nullptr;
 }
 
 #endif
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                         Constructor / Destructor                          */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 TerminalDisplay::TerminalDisplay(QWidget* parent)
     : QWidget(parent)
     , _screenWindow(nullptr)
     , _bellMasked(false)
     , _verticalLayout(new QVBoxLayout(this))
     , _fixedFont(true)
     , _fontHeight(1)
     , _fontWidth(1)
     , _fontAscent(1)
     , _boldIntense(true)
     , _lines(1)
     , _columns(1)
     , _usedLines(1)
     , _usedColumns(1)
     , _contentRect(QRect())
     , _image(nullptr)
     , _imageSize(0)
     , _lineProperties(QVector<LineProperty>())
     , _randomSeed(0)
     , _resizing(false)
     , _showTerminalSizeHint(true)
     , _bidiEnabled(false)
     , _usesMouseTracking(false)
     , _alternateScrolling(true)
     , _bracketedPasteMode(false)
     , _iPntSel(QPoint())
     , _pntSel(QPoint())
     , _tripleSelBegin(QPoint())
     , _actSel(0)
     , _wordSelectionMode(false)
     , _lineSelectionMode(false)
     , _preserveLineBreaks(true)
     , _columnSelectionMode(false)
     , _autoCopySelectedText(false)
     , _copyTextAsHTML(true)
     , _middleClickPasteMode(Enum::PasteFromX11Selection)
     , _scrollBar(nullptr)
     , _scrollbarLocation(Enum::ScrollBarRight)
     , _scrollFullPage(false)
     , _wordCharacters(QStringLiteral(":@-./_~"))
     , _bellMode(Enum::NotifyBell)
     , _allowBlinkingText(true)
     , _allowBlinkingCursor(false)
     , _textBlinking(false)
     , _cursorBlinking(false)
     , _hasTextBlinker(false)
     , _urlHintsModifiers(Qt::NoModifier)
     , _showUrlHint(false)
     , _reverseUrlHints(false)
     , _openLinksByDirectClick(false)
     , _ctrlRequiredForDrag(true)
     , _dropUrlsAsText(false)
     , _tripleClickMode(Enum::SelectWholeLine)
     , _possibleTripleClick(false)
     , _resizeWidget(nullptr)
     , _resizeTimer(nullptr)
     , _flowControlWarningEnabled(false)
     , _outputSuspendedMessageWidget(nullptr)
     , _lineSpacing(0)
     , _size(QSize())
     , _blendColor(qRgba(0, 0, 0, 0xff))
     , _wallpaper(nullptr)
     , _filterChain(new TerminalImageFilterChain())
     , _mouseOverHotspotArea(QRegion())
     , _filterUpdateRequired(true)
     , _cursorShape(Enum::BlockCursor)
     , _cursorColor(QColor())
     , _antialiasText(true)
     , _useFontLineCharacters(false)
     , _printerFriendly(false)
     , _sessionController(nullptr)
     , _trimLeadingSpaces(false)
     , _trimTrailingSpaces(false)
     , _mouseWheelZoom(false)
     , _margin(1)
     , _centerContents(false)
     , _readOnlyMessageWidget(nullptr)
     , _readOnly(false)
     , _opacity(1.0)
     , _dimWhenInactive(false)
     , _scrollWheelState(ScrollState())
     , _searchBar(new IncrementalSearchBar(this))
     , _headerBar(new TerminalHeaderBar(this))
     , _searchResultRect(QRect())
     , _drawOverlay(false)
 {
     // terminal applications are not designed with Right-To-Left in mind,
     // so the layout is forced to Left-To-Right
     setLayoutDirection(Qt::LeftToRight);
 
     _contentRect = QRect(_margin, _margin, 1, 1);
 
     // create scroll bar for scrolling output up and down
     _scrollBar = new QScrollBar(this);
     _scrollBar->setAutoFillBackground(false);
     // set the scroll bar's slider to occupy the whole area of the scroll bar initially
     setScroll(0, 0);
     _scrollBar->setCursor(Qt::ArrowCursor);
     _headerBar->setCursor(Qt::ArrowCursor);
     connect(_headerBar, &TerminalHeaderBar::requestToggleExpansion, this, &Konsole::TerminalDisplay::requestToggleExpansion);
     connect(_scrollBar, &QScrollBar::valueChanged, this, &Konsole::TerminalDisplay::scrollBarPositionChanged);
     connect(_scrollBar, &QScrollBar::sliderMoved, this, &Konsole::TerminalDisplay::viewScrolledByUser);
 
     // setup timers for blinking text
     _blinkTextTimer = new QTimer(this);
     _blinkTextTimer->setInterval(TEXT_BLINK_DELAY);
     connect(_blinkTextTimer, &QTimer::timeout, this, &Konsole::TerminalDisplay::blinkTextEvent);
 
     // setup timers for blinking cursor
     _blinkCursorTimer = new QTimer(this);
     _blinkCursorTimer->setInterval(QApplication::cursorFlashTime() / 2);
     connect(_blinkCursorTimer, &QTimer::timeout, this, &Konsole::TerminalDisplay::blinkCursorEvent);
 
     // hide mouse cursor on keystroke or idle
     KCursor::setAutoHideCursor(this, true);
     setMouseTracking(true);
 
     setUsesMouseTracking(false);
     setBracketedPasteMode(false);
 
     setColorTable(ColorScheme::defaultTable);
 
     // Enable drag and drop support
     setAcceptDrops(true);
     _dragInfo.state = diNone;
 
     setFocusPolicy(Qt::WheelFocus);
 
     // enable input method support
     setAttribute(Qt::WA_InputMethodEnabled, true);
 
     // this is an important optimization, it tells Qt
     // that TerminalDisplay will handle repainting its entire area.
     setAttribute(Qt::WA_OpaquePaintEvent);
 
     // Add the stretch item once, the KMessageWidgets are inserted at index 0.
     _verticalLayout->addWidget(_headerBar);
     _verticalLayout->addStretch();
     _verticalLayout->setSpacing(0);
     _verticalLayout->setContentsMargins(0, 0, 0, 0);
     setLayout(_verticalLayout);
     new AutoScrollHandler(this);
 #ifndef QT_NO_ACCESSIBILITY
     QAccessible::installFactory(Konsole::accessibleInterfaceFactory);
 #endif
 }
 
 TerminalDisplay::~TerminalDisplay()
 {
     disconnect(_blinkTextTimer);
     disconnect(_blinkCursorTimer);
 
     delete _readOnlyMessageWidget;
     delete _outputSuspendedMessageWidget;
     delete[] _image;
     delete _filterChain;
 
     _readOnlyMessageWidget = nullptr;
     _outputSuspendedMessageWidget = nullptr;
 }
 
 void TerminalDisplay::hideDragTarget()
 {
     _drawOverlay = false;
     update();
 }
 
 void TerminalDisplay::showDragTarget(const QPoint& cursorPos)
 {
     using EdgeDistance = std::pair<int, Qt::Edge>;
     auto closerToEdge = std::min<EdgeDistance>(
         {
             {cursorPos.x(), Qt::LeftEdge},
             {cursorPos.y(), Qt::TopEdge},
             {width() - cursorPos.x(), Qt::RightEdge},
             {height() - cursorPos.y(), Qt::BottomEdge}
         },
         [](const EdgeDistance& left, const EdgeDistance& right) -> bool {
             return left.first < right.first;
         }
     );
     if (_overlayEdge == closerToEdge.second) {
         return;
     }
     _overlayEdge = closerToEdge.second;
     _drawOverlay = true;
     update();
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                             Display Operations                            */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TerminalDisplay::drawLineCharString(QPainter& painter, int x, int y, const QString& str,
         const Character* attributes)
 {
     // only turn on anti-aliasing during this short time for the "text"
     // for the normal text we have TextAntialiasing on demand on
     // otherwise we have rendering artifacts
     // set https://bugreports.qt.io/browse/QTBUG-66036
     painter.setRenderHint(QPainter::Antialiasing, _antialiasText);
 
     const bool useBoldPen = (attributes->rendition & RE_BOLD) != 0 && _boldIntense;
 
     QRect cellRect = {x, y, _fontWidth, _fontHeight};
     for (int i = 0 ; i < str.length(); i++) {
         LineBlockCharacters::draw(painter, cellRect.translated(i * _fontWidth, 0), str[i],
                                         useBoldPen);
     }
 
     painter.setRenderHint(QPainter::Antialiasing, false);
 }
 
 void TerminalDisplay::setKeyboardCursorShape(Enum::CursorShapeEnum shape)
 {
     _cursorShape = shape;
 }
 Enum::CursorShapeEnum TerminalDisplay::keyboardCursorShape() const
 {
     return _cursorShape;
 }
 
 void TerminalDisplay::setCursorStyle(Enum::CursorShapeEnum shape, bool isBlinking)
 {
     setKeyboardCursorShape(shape);
 
     setBlinkingCursorEnabled(isBlinking);
 
     // when the cursor shape and blinking state are changed via the
     // Set Cursor Style (DECSCUSR) escape sequences in vim, and if the
     // cursor isn't set to blink, the cursor shape doesn't actually
     // change until the cursor is moved by the user; calling update()
     // makes the cursor shape get updated sooner.
     if (!isBlinking) {
         update();
     }
 }
 void TerminalDisplay::resetCursorStyle()
 {
     Q_ASSERT(_sessionController != nullptr);
     Q_ASSERT(!_sessionController->session().isNull());
 
     Profile::Ptr currentProfile = SessionManager::instance()->sessionProfile(_sessionController->session());
 
     if (currentProfile != nullptr) {
         auto shape = static_cast<Enum::CursorShapeEnum>(currentProfile->property<int>(Profile::CursorShape));
 
         setKeyboardCursorShape(shape);
         setBlinkingCursorEnabled(currentProfile->blinkingCursorEnabled());
     }
 }
 
 void TerminalDisplay::setKeyboardCursorColor(const QColor& color)
 {
     _cursorColor = color;
 }
 QColor TerminalDisplay::keyboardCursorColor() const
 {
     return _cursorColor;
 }
 
 void TerminalDisplay::setOpacity(qreal opacity)
 {
     QColor color(_blendColor);
     color.setAlphaF(opacity);
     _opacity = opacity;
 
     _blendColor = color.rgba();
     onColorsChanged();
 }
 
 void TerminalDisplay::setWallpaper(const ColorSchemeWallpaper::Ptr &p)
 {
     _wallpaper = p;
 }
 
 void TerminalDisplay::drawBackground(QPainter& painter, const QRect& rect, const QColor& backgroundColor, bool useOpacitySetting)
 {
     // the area of the widget showing the contents of the terminal display is drawn
     // using the background color from the color scheme set with setColorTable()
     //
     // the area of the widget behind the scroll-bar is drawn using the background
     // brush from the scroll-bar's palette, to give the effect of the scroll-bar
     // being outside of the terminal display and visual consistency with other KDE
     // applications.
 
     if (useOpacitySetting && !_wallpaper->isNull() &&
             _wallpaper->draw(painter, rect, _opacity)) {
     } else if (qAlpha(_blendColor) < 0xff && useOpacitySetting) {
 #if defined(Q_OS_MACOS)
         // TODO - On MacOS, using CompositionMode doesn't work.  Altering the
         //        transparency in the color scheme alters the brightness.
         painter.fillRect(rect, backgroundColor);
 #else
         QColor color(backgroundColor);
         color.setAlpha(qAlpha(_blendColor));
 
         const QPainter::CompositionMode originalMode = painter.compositionMode();
         painter.setCompositionMode(QPainter::CompositionMode_Source);
         painter.fillRect(rect, color);
         painter.setCompositionMode(originalMode);
 #endif
     } else {
         painter.fillRect(rect, backgroundColor);
     }
 }
 
 void TerminalDisplay::drawCursor(QPainter& painter,
                                  const QRect& rect,
                                  const QColor& foregroundColor,
                                  const QColor& /*backgroundColor*/,
                                  bool& invertCharacterColor)
 {
     // don't draw cursor which is currently blinking
     if (_cursorBlinking) {
         return;
     }
 
     // shift rectangle top down one pixel to leave some space
     // between top and bottom
     QRectF cursorRect = rect.adjusted(0, 1, 0, 0);
 
     QColor cursorColor = _cursorColor.isValid() ? _cursorColor : foregroundColor;
     painter.setPen(cursorColor);
 
     if (_cursorShape == Enum::BlockCursor) {
         // draw the cursor outline, adjusting the area so that
         // it is draw entirely inside 'rect'
         int penWidth = qMax(1, painter.pen().width());
         painter.drawRect(cursorRect.adjusted(int(penWidth / 2) + 0.5,
                                              int(penWidth / 2) + 0.5,
                                              - int(penWidth / 2) - penWidth % 2 + 0.5,
                                              - int(penWidth / 2) - penWidth % 2 + 0.5));
 
         // draw the cursor body only when the widget has focus
         if (hasFocus()) {
             painter.fillRect(cursorRect, cursorColor);
 
             if (!_cursorColor.isValid()) {
                 // invert the color used to draw the text to ensure that the character at
                 // the cursor position is readable
                 invertCharacterColor = true;
             }
         }
     } else if (_cursorShape == Enum::UnderlineCursor) {
         QLineF line(cursorRect.left() + 0.5,
                     cursorRect.bottom() - 0.5,
                     cursorRect.right() - 0.5,
                     cursorRect.bottom() - 0.5);
         painter.drawLine(line);
 
     } else if (_cursorShape == Enum::IBeamCursor) {
         QLineF line(cursorRect.left() + 0.5,
                     cursorRect.top() + 0.5,
                     cursorRect.left() + 0.5,
                     cursorRect.bottom() - 0.5);
         painter.drawLine(line);
     }
 }
 
 void TerminalDisplay::drawCharacters(QPainter& painter,
                                      const QRect& rect,
                                      const QString& text,
                                      const Character* style,
                                      bool invertCharacterColor)
 {
     // don't draw text which is currently blinking
     if (_textBlinking && ((style->rendition & RE_BLINK) != 0)) {
         return;
     }
 
     // don't draw concealed characters
     if ((style->rendition & RE_CONCEAL) != 0) {
         return;
     }
 
     static constexpr int MaxFontWeight = 99; // https://doc.qt.io/qt-5/qfont.html#Weight-enum
 
     const int normalWeight = font().weight();
     // +26 makes "bold" from "normal", "normal" from "light", etc. It is 26 instead of not 25 to prefer
     // bolder weight when 25 falls in the middle between two weights. See QFont::Weight
     const int boldWeight = qMin(normalWeight + 26, MaxFontWeight);
 
     const auto isBold = [boldWeight](const QFont &font) { return font.weight() >= boldWeight; };
 
     const bool useBold = (((style->rendition & RE_BOLD) != 0) && _boldIntense);
     const bool useUnderline = ((style->rendition & RE_UNDERLINE) != 0) || font().underline();
     const bool useItalic = ((style->rendition & RE_ITALIC) != 0) || font().italic();
     const bool useStrikeOut = ((style->rendition & RE_STRIKEOUT) != 0) || font().strikeOut();
     const bool useOverline = ((style->rendition & RE_OVERLINE) != 0) || font().overline();
 
     QFont currentFont = painter.font();
 
     if (isBold(currentFont) != useBold
             || currentFont.underline() != useUnderline
             || currentFont.italic() != useItalic
             || currentFont.strikeOut() != useStrikeOut
             || currentFont.overline() != useOverline) {
         currentFont.setWeight(useBold ? boldWeight : normalWeight);
         currentFont.setUnderline(useUnderline);
         currentFont.setItalic(useItalic);
         currentFont.setStrikeOut(useStrikeOut);
         currentFont.setOverline(useOverline);
         painter.setFont(currentFont);
     }
 
     // setup pen
     const CharacterColor& textColor = (invertCharacterColor ? style->backgroundColor : style->foregroundColor);
     const QColor color = textColor.color(_colorTable);
     QPen pen = painter.pen();
     if (pen.color() != color) {
         pen.setColor(color);
         painter.setPen(color);
     }
 
     const bool origClipping = painter.hasClipping();
     const auto origClipRegion = painter.clipRegion();
     painter.setClipRect(rect);
     // draw text
     if (isLineCharString(text) && !_useFontLineCharacters) {
         drawLineCharString(painter, rect.x(), rect.y(), text, style);
     } else {
         // Force using LTR as the document layout for the terminal area, because
         // there is no use cases for RTL emulator and RTL terminal application.
         //
         // This still allows RTL characters to be rendered in the RTL way.
         painter.setLayoutDirection(Qt::LeftToRight);
 
         if (_bidiEnabled) {
             painter.drawText(rect.x(), rect.y() + _fontAscent + _lineSpacing, text);
         } else {
             painter.drawText(rect.x(), rect.y() + _fontAscent + _lineSpacing, LTR_OVERRIDE_CHAR + text);
         }
     }
     painter.setClipRegion(origClipRegion);
     painter.setClipping(origClipping);
 }
 
 void TerminalDisplay::drawTextFragment(QPainter& painter ,
                                        const QRect& rect,
                                        const QString& text,
                                        const Character* style)
 {
     // setup painter
     const QColor foregroundColor = style->foregroundColor.color(_colorTable);
     const QColor backgroundColor = style->backgroundColor.color(_colorTable);
 
     // draw background if different from the display's background color
     if (backgroundColor != getBackgroundColor()) {
         drawBackground(painter, rect, backgroundColor,
                        false /* do not use transparency */);
     }
 
     // draw cursor shape if the current character is the cursor
     // this may alter the foreground and background colors
     bool invertCharacterColor = false;
     if ((style->rendition & RE_CURSOR) != 0) {
         drawCursor(painter, rect, foregroundColor, backgroundColor, invertCharacterColor);
     }
 
     // draw text
     drawCharacters(painter, rect, text, style, invertCharacterColor);
 }
 
 void TerminalDisplay::drawPrinterFriendlyTextFragment(QPainter& painter,
         const QRect& rect,
         const QString& text,
         const Character* style)
 {
     // Set the colors used to draw to black foreground and white
     // background for printer friendly output when printing
     Character print_style = *style;
     print_style.foregroundColor = CharacterColor(COLOR_SPACE_RGB, 0x00000000);
     print_style.backgroundColor = CharacterColor(COLOR_SPACE_RGB, 0xFFFFFFFF);
 
     // draw text
     drawCharacters(painter, rect, text, &print_style, false);
 }
 
 void TerminalDisplay::setRandomSeed(uint randomSeed)
 {
     _randomSeed = randomSeed;
 }
 uint TerminalDisplay::randomSeed() const
 {
     return _randomSeed;
 }
 
 // scrolls the image by 'lines', down if lines > 0 or up otherwise.
 //
 // the terminal emulation keeps track of the scrolling of the character
 // image as it receives input, and when the view is updated, it calls scrollImage()
 // with the final scroll amount.  this improves performance because scrolling the
 // display is much cheaper than re-rendering all the text for the
 // part of the image which has moved up or down.
 // Instead only new lines have to be drawn
 void TerminalDisplay::scrollImage(int lines , const QRect& screenWindowRegion)
 {
     // return if there is nothing to do
     if ((lines == 0) || (_image == nullptr)) {
         return;
     }
 
     // if the flow control warning is enabled this will interfere with the
     // scrolling optimizations and cause artifacts.  the simple solution here
     // is to just disable the optimization whilst it is visible
     if ((_outputSuspendedMessageWidget != nullptr) && _outputSuspendedMessageWidget->isVisible()) {
         return;
     }
 
     if ((_readOnlyMessageWidget != nullptr) && _readOnlyMessageWidget->isVisible()) {
         return;
     }
 
     // constrain the region to the display
     // the bottom of the region is capped to the number of lines in the display's
     // internal image - 2, so that the height of 'region' is strictly less
     // than the height of the internal image.
     QRect region = screenWindowRegion;
     region.setBottom(qMin(region.bottom(), _lines - 2));
 
     // return if there is nothing to do
     if (!region.isValid()
             || (region.top() + abs(lines)) >= region.bottom()
             || _lines <= region.height()) {
         return;
     }
 
     // hide terminal size label to prevent it being scrolled
     if ((_resizeWidget != nullptr) && _resizeWidget->isVisible()) {
         _resizeWidget->hide();
     }
 
     // Note:  With Qt 4.4 the left edge of the scrolled area must be at 0
     // to get the correct (newly exposed) part of the widget repainted.
     //
     // The right edge must be before the left edge of the scroll bar to
     // avoid triggering a repaint of the entire widget, the distance is
     // given by SCROLLBAR_CONTENT_GAP
     //
     // Set the QT_FLUSH_PAINT environment variable to '1' before starting the
     // application to monitor repainting.
     //
     const int scrollBarWidth = _scrollBar->isHidden() ? 0 : _scrollBar->width();
     const int SCROLLBAR_CONTENT_GAP = 1;
     QRect scrollRect;
     if (_scrollbarLocation == Enum::ScrollBarLeft) {
         scrollRect.setLeft(scrollBarWidth + SCROLLBAR_CONTENT_GAP);
         scrollRect.setRight(width());
     } else {
         scrollRect.setLeft(0);
         scrollRect.setRight(width() - scrollBarWidth - SCROLLBAR_CONTENT_GAP);
     }
     void* firstCharPos = &_image[ region.top() * _columns ];
     void* lastCharPos = &_image[(region.top() + abs(lines)) * _columns ];
 
     const int top = _contentRect.top() + (region.top() * _fontHeight);
     const int linesToMove = region.height() - abs(lines);
     const int bytesToMove = linesToMove * _columns * sizeof(Character);
 
     Q_ASSERT(linesToMove > 0);
     Q_ASSERT(bytesToMove > 0);
 
     scrollRect.setTop( lines > 0 ? top : top + abs(lines) * _fontHeight);
     scrollRect.setHeight(linesToMove * _fontHeight);
 
     if (!scrollRect.isValid() || scrollRect.isEmpty()) {
         return;
     }
 
     //scroll internal image
     if (lines > 0) {
         // check that the memory areas that we are going to move are valid
         Q_ASSERT((char*)lastCharPos + bytesToMove <
                  (char*)(_image + (_lines * _columns)));
 
         Q_ASSERT((lines * _columns) < _imageSize);
 
         //scroll internal image down
         memmove(firstCharPos , lastCharPos , bytesToMove);
     } else {
         // check that the memory areas that we are going to move are valid
         Q_ASSERT((char*)firstCharPos + bytesToMove <
                  (char*)(_image + (_lines * _columns)));
 
         //scroll internal image up
         memmove(lastCharPos , firstCharPos , bytesToMove);
     }
 
     //scroll the display vertically to match internal _image
     scroll(0 , _fontHeight * (-lines) , scrollRect);
 }
 
 QRegion TerminalDisplay::hotSpotRegion() const
 {
     QRegion region;
     for (const Filter::HotSpot *hotSpot : _filterChain->hotSpots()) {
         QRect r;
         r.setLeft(hotSpot->startColumn());
         r.setTop(hotSpot->startLine());
         if (hotSpot->startLine() == hotSpot->endLine()) {
             r.setRight(hotSpot->endColumn());
             r.setBottom(hotSpot->endLine());
             region |= imageToWidget(r);
         } else {
             r.setRight(_columns);
             r.setBottom(hotSpot->startLine());
             region |= imageToWidget(r);
 
             r.setLeft(0);
 
             for (int line = hotSpot->startLine() + 1 ; line < hotSpot->endLine(); line++) {
                 r.moveTop(line);
                 region |= imageToWidget(r);
             }
 
             r.moveTop(hotSpot->endLine());
             r.setRight(hotSpot->endColumn());
             region |= imageToWidget(r);
         }
     }
     return region;
 }
 
 void TerminalDisplay::processFilters()
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     if (!_filterUpdateRequired) {
         return;
     }
 
     QRegion preUpdateHotSpots = hotSpotRegion();
 
     // use _screenWindow->getImage() here rather than _image because
     // other classes may call processFilters() when this display's
     // ScreenWindow emits a scrolled() signal - which will happen before
     // updateImage() is called on the display and therefore _image is
     // out of date at this point
     _filterChain->setImage(_screenWindow->getImage(),
                            _screenWindow->windowLines(),
                            _screenWindow->windowColumns(),
                            _screenWindow->getLineProperties());
     _filterChain->process();
 
     QRegion postUpdateHotSpots = hotSpotRegion();
 
     update(preUpdateHotSpots | postUpdateHotSpots);
     _filterUpdateRequired = false;
 }
 
 void TerminalDisplay::updateImage()
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     // optimization - scroll the existing image where possible and
     // avoid expensive text drawing for parts of the image that
     // can simply be moved up or down
     // disable this shortcut for transparent konsole with scaled pixels, otherwise we get rendering artifacts, see BUG 350651
     if (!(WindowSystemInfo::HAVE_TRANSPARENCY && (qApp->devicePixelRatio() > 1.0)) && _wallpaper->isNull() && !_searchBar->isVisible()) {
         scrollImage(_screenWindow->scrollCount() ,
                     _screenWindow->scrollRegion());
     }
 
     if (_image == nullptr) {
         // Create _image.
         // The emitted changedContentSizeSignal also leads to getImage being recreated, so do this first.
         updateImageSize();
     }
 
     Character* const newimg = _screenWindow->getImage();
     const int lines = _screenWindow->windowLines();
     const int columns = _screenWindow->windowColumns();
 
     setScroll(_screenWindow->currentLine() , _screenWindow->lineCount());
 
     Q_ASSERT(_usedLines <= _lines);
     Q_ASSERT(_usedColumns <= _columns);
 
     int y, x, len;
 
     const QPoint tL  = contentsRect().topLeft();
     const int    tLx = tL.x();
     const int    tLy = tL.y();
     _hasTextBlinker = false;
 
     CharacterColor cf;       // undefined
 
     const int linesToUpdate = qMin(_lines, qMax(0, lines));
     const int columnsToUpdate = qMin(_columns, qMax(0, columns));
 
     auto dirtyMask = new char[columnsToUpdate + 2];
     QRegion dirtyRegion;
 
     // debugging variable, this records the number of lines that are found to
     // be 'dirty' ( ie. have changed from the old _image to the new _image ) and
     // which therefore need to be repainted
     int dirtyLineCount = 0;
 
     for (y = 0; y < linesToUpdate; ++y) {
         const Character* currentLine = &_image[y * _columns];
         const Character* const newLine = &newimg[y * columns];
 
         bool updateLine = false;
 
         // The dirty mask indicates which characters need repainting. We also
         // mark surrounding neighbors dirty, in case the character exceeds
         // its cell boundaries
         memset(dirtyMask, 0, columnsToUpdate + 2);
 
         for (x = 0 ; x < columnsToUpdate ; ++x) {
             if (newLine[x] != currentLine[x]) {
                 dirtyMask[x] = 1;
             }
         }
 
         if (!_resizing) { // not while _resizing, we're expecting a paintEvent
             for (x = 0; x < columnsToUpdate; ++x) {
                 _hasTextBlinker |= (newLine[x].rendition & RE_BLINK);
 
                 // Start drawing if this character or the next one differs.
                 // We also take the next one into account to handle the situation
                 // where characters exceed their cell width.
                 if (dirtyMask[x] != 0) {
                     if (newLine[x + 0].character == 0u) {
                         continue;
                     }
                     const bool lineDraw = LineBlockCharacters::canDraw(newLine[x + 0].character);
                     const bool doubleWidth = (x + 1 == columnsToUpdate) ? false : (newLine[x + 1].character == 0);
                     const RenditionFlags cr = newLine[x].rendition;
                     const CharacterColor clipboard = newLine[x].backgroundColor;
                     if (newLine[x].foregroundColor != cf) {
                         cf = newLine[x].foregroundColor;
                     }
                     const int lln = columnsToUpdate - x;
                     for (len = 1; len < lln; ++len) {
                         const Character& ch = newLine[x + len];
 
                         if (ch.character == 0u) {
                             continue; // Skip trailing part of multi-col chars.
                         }
 
                         const bool nextIsDoubleWidth = (x + len + 1 == columnsToUpdate) ? false : (newLine[x + len + 1].character == 0);
 
                         if (ch.foregroundColor != cf ||
                                 ch.backgroundColor != clipboard ||
                                 (ch.rendition & ~RE_EXTENDED_CHAR) != (cr & ~RE_EXTENDED_CHAR) ||
                                 (dirtyMask[x + len] == 0) ||
                                 LineBlockCharacters::canDraw(ch.character) != lineDraw ||
                                 nextIsDoubleWidth != doubleWidth) {
                             break;
                         }
                     }
 
                     const bool saveFixedFont = _fixedFont;
                     if (lineDraw) {
                         _fixedFont = false;
                     }
                     if (doubleWidth) {
                         _fixedFont = false;
                     }
 
                     updateLine = true;
 
                     _fixedFont = saveFixedFont;
                     x += len - 1;
                 }
             }
         }
 
         //both the top and bottom halves of double height _lines must always be redrawn
         //although both top and bottom halves contain the same characters, only
         //the top one is actually
         //drawn.
         if (_lineProperties.count() > y) {
             updateLine |= (_lineProperties[y] & LINE_DOUBLEHEIGHT);
         }
 
         // if the characters on the line are different in the old and the new _image
         // then this line must be repainted.
         if (updateLine) {
             dirtyLineCount++;
 
             // add the area occupied by this line to the region which needs to be
             // repainted
             QRect dirtyRect = QRect(_contentRect.left() + tLx ,
                                     _contentRect.top() + tLy + _fontHeight * y ,
                                     _fontWidth * columnsToUpdate ,
                                     _fontHeight);
 
             dirtyRegion |= dirtyRect;
         }
 
         // replace the line of characters in the old _image with the
         // current line of the new _image
         memcpy((void*)currentLine, (const void*)newLine, columnsToUpdate * sizeof(Character));
     }
 
     // if the new _image is smaller than the previous _image, then ensure that the area
     // outside the new _image is cleared
     if (linesToUpdate < _usedLines) {
         dirtyRegion |= QRect(_contentRect.left() + tLx ,
                              _contentRect.top() + tLy + _fontHeight * linesToUpdate ,
                              _fontWidth * _columns ,
                              _fontHeight * (_usedLines - linesToUpdate));
     }
     _usedLines = linesToUpdate;
 
     if (columnsToUpdate < _usedColumns) {
         dirtyRegion |= QRect(_contentRect.left() + tLx + columnsToUpdate * _fontWidth ,
                              _contentRect.top() + tLy ,
                              _fontWidth * (_usedColumns - columnsToUpdate) ,
                              _fontHeight * _lines);
     }
     _usedColumns = columnsToUpdate;
 
     dirtyRegion |= _inputMethodData.previousPreeditRect;
 
     if ((_screenWindow->currentResultLine() != -1) && (_screenWindow->scrollCount() != 0)) {
         // De-highlight previous result region
         dirtyRegion |= _searchResultRect;
         // Highlight new result region
         dirtyRegion |= QRect(0, _contentRect.top() + (_screenWindow->currentResultLine() - _screenWindow->currentLine()) * _fontHeight,
                              _columns * _fontWidth, _fontHeight);
     }
     _screenWindow->resetScrollCount();
 
 
     // update the parts of the display which have changed
     update(dirtyRegion);
 
     if (_allowBlinkingText && _hasTextBlinker && !_blinkTextTimer->isActive()) {
         _blinkTextTimer->start();
     }
     if (!_hasTextBlinker && _blinkTextTimer->isActive()) {
         _blinkTextTimer->stop();
         _textBlinking = false;
     }
     delete[] dirtyMask;
 
 #ifndef QT_NO_ACCESSIBILITY
     QAccessibleEvent dataChangeEvent(this, QAccessible::VisibleDataChanged);
     QAccessible::updateAccessibility(&dataChangeEvent);
     QAccessibleTextCursorEvent cursorEvent(this, _usedColumns * screenWindow()->screen()->getCursorY() + screenWindow()->screen()->getCursorX());
     QAccessible::updateAccessibility(&cursorEvent);
 #endif
 }
 
 void TerminalDisplay::showResizeNotification()
 {
     if (_showTerminalSizeHint && isVisible()) {
         if (_resizeWidget == nullptr) {
             _resizeWidget = new QLabel(i18n("Size: XXX x XXX"), this);
             _resizeWidget->setMinimumWidth(_resizeWidget->fontMetrics().boundingRect(i18n("Size: XXX x XXX")).width());
             _resizeWidget->setMinimumHeight(_resizeWidget->sizeHint().height());
             _resizeWidget->setAlignment(Qt::AlignCenter);
 
             _resizeWidget->setStyleSheet(QStringLiteral("background-color:palette(window);border-style:solid;border-width:1px;border-color:palette(dark)"));
 
             _resizeTimer = new QTimer(this);
             _resizeTimer->setInterval(SIZE_HINT_DURATION);
             _resizeTimer->setSingleShot(true);
             connect(_resizeTimer, &QTimer::timeout, _resizeWidget, &QLabel::hide);
         }
         QString sizeStr = i18n("Size: %1 x %2", _columns, _lines);
         _resizeWidget->setText(sizeStr);
         _resizeWidget->move((width() - _resizeWidget->width()) / 2,
                             (height() - _resizeWidget->height()) / 2 + 20);
         _resizeWidget->show();
         _resizeTimer->start();
     }
 }
 
 void TerminalDisplay::paintEvent(QPaintEvent* pe)
 {
     QPainter paint(this);
 
     // Determine which characters should be repainted (1 region unit = 1 character)
     QRegion dirtyImageRegion;
-    foreach(const QRect & rect, (pe->region() & contentsRect())) {
+    const QRegion region = pe->region() & contentsRect();
+
+    for (const QRect &rect : region) {
         dirtyImageRegion += widgetToImage(rect);
         drawBackground(paint, rect, getBackgroundColor(), true /* use opacity setting */);
     }
 
     // only turn on text anti-aliasing, never turn on normal antialiasing
     // set https://bugreports.qt.io/browse/QTBUG-66036
     paint.setRenderHint(QPainter::TextAntialiasing, _antialiasText);
 
-    foreach(const QRect & rect, dirtyImageRegion) {
+    for (const QRect &rect : qAsConst(dirtyImageRegion)) {
         drawContents(paint, rect);
     }
     drawCurrentResultRect(paint);
     drawInputMethodPreeditString(paint, preeditRect());
     paintFilters(paint);
 
     const bool drawDimmed = _dimWhenInactive && !hasFocus();
     const QColor dimColor(0, 0, 0, 128);
-    foreach(const QRect & rect, (pe->region() & contentsRect())) {
+    for (const QRect &rect : region) {
         if (drawDimmed) {
             paint.fillRect(rect, dimColor);
         }
     }
 
     if (_drawOverlay) {
         const auto y = _headerBar->isVisible() ? _headerBar->height() : 0;
         const auto rect = _overlayEdge == Qt::LeftEdge ? QRect(0, y, width() / 2, height())
                   : _overlayEdge == Qt::TopEdge ? QRect(0, y, width(), height() / 2)
                   : _overlayEdge == Qt::RightEdge ? QRect(width() - width() / 2, y, width() / 2, height())
                   : QRect(0, height() - height() / 2, width(), height() / 2);
 
         paint.setRenderHint(QPainter::Antialiasing);
         paint.setPen(Qt::NoPen);
         paint.setBrush(QColor(100,100,100, 127));
         paint.drawRect(rect);
     }
 }
 
 void TerminalDisplay::printContent(QPainter& painter, bool friendly)
 {
     // Reinitialize the font with the printers paint device so the font
     // measurement calculations will be done correctly
     QFont savedFont = getVTFont();
     QFont font(savedFont, painter.device());
     painter.setFont(font);
     setVTFont(font);
 
     QRect rect(0, 0, _usedColumns, _usedLines);
 
     _printerFriendly = friendly;
     if (!friendly) {
         drawBackground(painter, rect, getBackgroundColor(),
                        true /* use opacity setting */);
     }
     drawContents(painter, rect);
     _printerFriendly = false;
     setVTFont(savedFont);
 }
 
 QPoint TerminalDisplay::cursorPosition() const
 {
     if (!_screenWindow.isNull()) {
         return _screenWindow->cursorPosition();
     } else {
         return {0, 0};
     }
 }
 
 inline bool TerminalDisplay::isCursorOnDisplay() const
 {
     return cursorPosition().x() < _columns &&
            cursorPosition().y() < _lines;
 }
 
 FilterChain* TerminalDisplay::filterChain() const
 {
     return _filterChain;
 }
 
 void TerminalDisplay::paintFilters(QPainter& painter)
 {
     if (_filterUpdateRequired) {
         return;
     }
 
     // get color of character under mouse and use it to draw
     // lines for filters
     QPoint cursorPos = mapFromGlobal(QCursor::pos());
     int cursorLine;
     int cursorColumn;
 
     getCharacterPosition(cursorPos, cursorLine, cursorColumn, false);
     Character cursorCharacter = _image[loc(qMin(cursorColumn, _columns - 1), cursorLine)];
 
     painter.setPen(QPen(cursorCharacter.foregroundColor.color(_colorTable)));
 
     // iterate over hotspots identified by the display's currently active filters
     // and draw appropriate visuals to indicate the presence of the hotspot
 
     QList<Filter::HotSpot*> spots = _filterChain->hotSpots();
     int urlNumber, urlNumInc;
     if (_reverseUrlHints) {
         urlNumber = spots.size() + 1;
         urlNumInc = -1;
     } else {
         urlNumber = 0;
         urlNumInc = 1;
     }
     foreach(Filter::HotSpot* spot, spots) {
         urlNumber += urlNumInc;
 
         QRegion region;
         if (spot->type() == Filter::HotSpot::Link) {
             QRect r;
             if (spot->startLine() == spot->endLine()) {
                 r.setCoords(spot->startColumn()*_fontWidth + _contentRect.left(),
                             spot->startLine()*_fontHeight + _contentRect.top(),
                             (spot->endColumn())*_fontWidth + _contentRect.left() - 1,
                             (spot->endLine() + 1)*_fontHeight + _contentRect.top() - 1);
                 region |= r;
             } else {
                 r.setCoords(spot->startColumn()*_fontWidth + _contentRect.left(),
                             spot->startLine()*_fontHeight + _contentRect.top(),
                             (_columns)*_fontWidth + _contentRect.left() - 1,
                             (spot->startLine() + 1)*_fontHeight + _contentRect.top() - 1);
                 region |= r;
                 for (int line = spot->startLine() + 1 ; line < spot->endLine() ; line++) {
                     r.setCoords(0 * _fontWidth + _contentRect.left(),
                                 line * _fontHeight + _contentRect.top(),
                                 (_columns)*_fontWidth + _contentRect.left() - 1,
                                 (line + 1)*_fontHeight + _contentRect.top() - 1);
                     region |= r;
                 }
                 r.setCoords(0 * _fontWidth + _contentRect.left(),
                             spot->endLine()*_fontHeight + _contentRect.top(),
                             (spot->endColumn())*_fontWidth + _contentRect.left() - 1,
                             (spot->endLine() + 1)*_fontHeight + _contentRect.top() - 1);
                 region |= r;
             }
 
             if (_showUrlHint && urlNumber < 10) {
                 // Position at the beginning of the URL
                 QRect hintRect(*region.begin());
                 hintRect.setWidth(r.height());
                 painter.fillRect(hintRect, QColor(0, 0, 0, 128));
                 painter.setPen(Qt::white);
                 painter.drawRect(hintRect.adjusted(0, 0, -1, -1));
                 painter.drawText(hintRect, Qt::AlignCenter, QString::number(urlNumber));
             }
         }
 
         for (int line = spot->startLine() ; line <= spot->endLine() ; line++) {
             int startColumn = 0;
             int endColumn = _columns - 1; // TODO use number of _columns which are actually
             // occupied on this line rather than the width of the
             // display in _columns
 
             // Check image size so _image[] is valid (see makeImage)
             if (endColumn >= _columns || line >= _lines) {
                 break;
             }
 
             // ignore whitespace at the end of the lines
             while (_image[loc(endColumn, line)].isSpace() && endColumn > 0) {
                 endColumn--;
             }
 
             // increment here because the column which we want to set 'endColumn' to
             // is the first whitespace character at the end of the line
             endColumn++;
 
             if (line == spot->startLine()) {
                 startColumn = spot->startColumn();
             }
             if (line == spot->endLine()) {
                 endColumn = spot->endColumn();
             }
 
             // TODO: resolve this comment with the new margin/center code
             // subtract one pixel from
             // the right and bottom so that
             // we do not overdraw adjacent
             // hotspots
             //
             // subtracting one pixel from all sides also prevents an edge case where
             // moving the mouse outside a link could still leave it underlined
             // because the check below for the position of the cursor
             // finds it on the border of the target area
             QRect r;
             r.setCoords(startColumn * _fontWidth + _contentRect.left(),
                         line * _fontHeight + _contentRect.top(),
                         endColumn * _fontWidth + _contentRect.left() - 1,
                         (line + 1)*_fontHeight + _contentRect.top() - 1);
             // Underline link hotspots
             if (spot->type() == Filter::HotSpot::Link) {
                 QFontMetrics metrics(font());
 
                 // find the baseline (which is the invisible line that the characters in the font sit on,
                 // with some having tails dangling below)
                 const int baseline = r.bottom() - metrics.descent();
                 // find the position of the underline below that
                 const int underlinePos = baseline + metrics.underlinePos();
                 if (_showUrlHint || region.contains(mapFromGlobal(QCursor::pos()))) {
                     painter.drawLine(r.left() , underlinePos ,
                                      r.right() , underlinePos);
                 }
 
                 // Marker hotspots simply have a transparent rectangular shape
                 // drawn on top of them
             } else if (spot->type() == Filter::HotSpot::Marker) {
                 //TODO - Do not use a hardcoded color for this
                 const bool isCurrentResultLine = (_screenWindow->currentResultLine() == (spot->startLine() + _screenWindow->currentLine()));
                 QColor color = isCurrentResultLine ? QColor(255, 255, 0, 120) : QColor(255, 0, 0, 120);
                 painter.fillRect(r, color);
             }
         }
     }
 }
 
 inline static bool isRtl(const Character &chr) {
     uint c = 0;
     if ((chr.rendition & RE_EXTENDED_CHAR) == 0) {
         c = chr.character;
     } else {
         ushort extendedCharLength = 0;
         const uint* chars = ExtendedCharTable::instance.lookupExtendedChar(chr.character, extendedCharLength);
         if (chars != nullptr) {
             c = chars[0];
         }
     }
 
     switch(QChar::direction(c)) {
     case QChar::DirR:
     case QChar::DirAL:
     case QChar::DirRLE:
     case QChar::DirRLI:
     case QChar::DirRLO:
         return true;
     default:
         return false;
     }
 }
 
 void TerminalDisplay::drawContents(QPainter& paint, const QRect& rect)
 {
     const int numberOfColumns = _usedColumns;
     QVector<uint> univec;
     univec.reserve(numberOfColumns);
     for (int y = rect.y(); y <= rect.bottom(); y++) {
         int x = rect.x();
         if ((_image[loc(rect.x(), y)].character == 0u) && (x != 0)) {
             x--; // Search for start of multi-column character
         }
         for (; x <= rect.right(); x++) {
             int len = 1;
             int p = 0;
 
             // reset our buffer to the number of columns
             int bufferSize = numberOfColumns;
             univec.resize(bufferSize);
             uint *disstrU = univec.data();
 
             // is this a single character or a sequence of characters ?
             if ((_image[loc(x, y)].rendition & RE_EXTENDED_CHAR) != 0) {
                 // sequence of characters
                 ushort extendedCharLength = 0;
                 const uint* chars = ExtendedCharTable::instance.lookupExtendedChar(_image[loc(x, y)].character, extendedCharLength);
                 if (chars != nullptr) {
                     Q_ASSERT(extendedCharLength > 1);
                     bufferSize += extendedCharLength - 1;
                     univec.resize(bufferSize);
                     disstrU = univec.data();
                     for (int index = 0 ; index < extendedCharLength ; index++) {
                         Q_ASSERT(p < bufferSize);
                         disstrU[p++] = chars[index];
                     }
                 }
             } else {
                 // single character
                 const uint c = _image[loc(x, y)].character;
                 if (c != 0u) {
                     Q_ASSERT(p < bufferSize);
                     disstrU[p++] = c;
                 }
             }
 
             const bool lineDraw = LineBlockCharacters::canDraw(_image[loc(x, y)].character);
             const bool doubleWidth = (_image[qMin(loc(x, y) + 1, _imageSize - 1)].character == 0);
             const CharacterColor currentForeground = _image[loc(x, y)].foregroundColor;
             const CharacterColor currentBackground = _image[loc(x, y)].backgroundColor;
             const RenditionFlags currentRendition = _image[loc(x, y)].rendition;
             const bool rtl = isRtl(_image[loc(x, y)]);
 
             const auto isInsideDrawArea = [&](int column) { return column <= rect.right(); };
             const auto hasSameColors = [&](int column) {
                 return _image[loc(column, y)].foregroundColor == currentForeground
                     && _image[loc(column, y)].backgroundColor == currentBackground;
             };
             const auto hasSameRendition = [&](int column) {
                 return (_image[loc(column, y)].rendition & ~RE_EXTENDED_CHAR)
                     == (currentRendition & ~RE_EXTENDED_CHAR);
             };
             const auto hasSameWidth = [&](int column) {
                 const int characterLoc = qMin(loc(column, y) + 1, _imageSize - 1);
                 return (_image[characterLoc].character == 0) == doubleWidth;
             };
             const auto canBeGrouped = [&](int column) {
                 return _image[loc(column, y)].character <= 0x7e || rtl;
             };
 
             if (canBeGrouped(x)) {
                 while (isInsideDrawArea(x + len) && hasSameColors(x + len)
                         && hasSameRendition(x + len) && hasSameWidth(x + len)
                         && canBeGrouped(x + len)) {
                     const uint c = _image[loc(x + len, y)].character;
                     if ((_image[loc(x + len, y)].rendition & RE_EXTENDED_CHAR) != 0) {
                         // sequence of characters
                         ushort extendedCharLength = 0;
                         const uint* chars = ExtendedCharTable::instance.lookupExtendedChar(c, extendedCharLength);
                         if (chars != nullptr) {
                             Q_ASSERT(extendedCharLength > 1);
                             bufferSize += extendedCharLength - 1;
                             univec.resize(bufferSize);
                             disstrU = univec.data();
                             for (int index = 0 ; index < extendedCharLength ; index++) {
                                 Q_ASSERT(p < bufferSize);
                                 disstrU[p++] = chars[index];
                             }
                         }
                     } else {
                         // single character
                         if (c != 0u) {
                             Q_ASSERT(p < bufferSize);
                             disstrU[p++] = c;
                         }
                     }
 
                     if (doubleWidth) { // assert((_image[loc(x+len,y)+1].character == 0)), see above if condition
                         len++; // Skip trailing part of multi-column character
                     }
                     len++;
                 }
             } else {
                 // Group spaces following any non-wide character with the character. This allows for
                 // rendering ambiguous characters with wide glyphs without clipping them.
                 while (!doubleWidth && isInsideDrawArea(x + len)
                         && _image[loc(x + len, y)].character == ' ' && hasSameColors(x + len)
                         && hasSameRendition(x + len)) {
                     // disstrU intentionally not modified - trailing spaces are meaningless
                     len++;
                 }
             }
             if ((x + len < _usedColumns) && (_image[loc(x + len, y)].character == 0u)) {
                 len++; // Adjust for trailing part of multi-column character
             }
 
             const bool save__fixedFont = _fixedFont;
             if (lineDraw) {
                 _fixedFont = false;
             }
             if (doubleWidth) {
                 _fixedFont = false;
             }
             univec.resize(p);
 
             // Create a text scaling matrix for double width and double height lines.
             QMatrix textScale;
 
             if (y < _lineProperties.size()) {
                 if ((_lineProperties[y] & LINE_DOUBLEWIDTH) != 0) {
                     textScale.scale(2, 1);
                 }
 
                 if ((_lineProperties[y] & LINE_DOUBLEHEIGHT) != 0) {
                     textScale.scale(1, 2);
                 }
             }
 
             //Apply text scaling matrix.
             // TODO: setWorldMatrix is obsolete, change to setWorldTransform
             paint.setWorldMatrix(textScale, true);
 
             //calculate the area in which the text will be drawn
             QRect textArea = QRect(_contentRect.left() + contentsRect().left() + _fontWidth * x,
                                    _contentRect.top() + contentsRect().top() + _fontHeight * y,
                                    _fontWidth * len,
                                    _fontHeight);
 
             //move the calculated area to take account of scaling applied to the painter.
             //the position of the area from the origin (0,0) is scaled
             //by the opposite of whatever
             //transformation has been applied to the painter.  this ensures that
             //painting does actually start from textArea.topLeft()
             //(instead of textArea.topLeft() * painter-scale)
             textArea.moveTopLeft(textScale.inverted().map(textArea.topLeft()));
 
             QString unistr = QString::fromUcs4(univec.data(), univec.length());
 
             //paint text fragment
             if (_printerFriendly) {
                 drawPrinterFriendlyTextFragment(paint,
                                                 textArea,
                                                 unistr,
                                                 &_image[loc(x, y)]);
             } else {
                 drawTextFragment(paint,
                                  textArea,
                                  unistr,
                                  &_image[loc(x, y)]);
             }
 
             _fixedFont = save__fixedFont;
 
             //reset back to single-width, single-height _lines
             // TODO: setWorldMatrix is obsolete, change to setWorldTransform
             paint.setWorldMatrix(textScale.inverted(), true);
 
             if (y < _lineProperties.size() - 1) {
                 //double-height _lines are represented by two adjacent _lines
                 //containing the same characters
                 //both _lines will have the LINE_DOUBLEHEIGHT attribute.
                 //If the current line has the LINE_DOUBLEHEIGHT attribute,
                 //we can therefore skip the next line
                 if ((_lineProperties[y] & LINE_DOUBLEHEIGHT) != 0) {
                     y++;
                 }
             }
 
             x += len - 1;
         }
     }
 }
 
 void TerminalDisplay::drawCurrentResultRect(QPainter& painter)
 {
     if(_screenWindow->currentResultLine() == -1) {
         return;
     }
 
     _searchResultRect.setRect(0, _contentRect.top() + (_screenWindow->currentResultLine() - _screenWindow->currentLine()) * _fontHeight,
                               _columns * _fontWidth, _fontHeight);
     painter.fillRect(_searchResultRect, QColor(0, 0, 255, 80));
 }
 
 QRect TerminalDisplay::imageToWidget(const QRect& imageArea) const
 {
     QRect result;
     result.setLeft(_contentRect.left() + _fontWidth * imageArea.left());
     result.setTop(_contentRect.top() + _fontHeight * imageArea.top());
     result.setWidth(_fontWidth * imageArea.width());
     result.setHeight(_fontHeight * imageArea.height());
 
     return result;
 }
 
 QRect TerminalDisplay::widgetToImage(const QRect &widgetArea) const
 {
     QRect result;
     result.setLeft(  qMin(_usedColumns - 1, qMax(0, (widgetArea.left()   - contentsRect().left() - _contentRect.left()) / _fontWidth )));
     result.setTop(   qMin(_usedLines   - 1, qMax(0, (widgetArea.top()    - contentsRect().top()  - _contentRect.top() ) / _fontHeight)));
     result.setRight( qMin(_usedColumns - 1, qMax(0, (widgetArea.right()  - contentsRect().left() - _contentRect.left()) / _fontWidth )));
     result.setBottom(qMin(_usedLines   - 1, qMax(0, (widgetArea.bottom() - contentsRect().top()  - _contentRect.top() ) / _fontHeight)));
     return result;
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                          Blinking Text & Cursor                           */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TerminalDisplay::setBlinkingCursorEnabled(bool blink)
 {
     _allowBlinkingCursor = blink;
 
     if (blink && !_blinkCursorTimer->isActive()) {
         _blinkCursorTimer->start();
     }
 
     if (!blink && _blinkCursorTimer->isActive()) {
         _blinkCursorTimer->stop();
         if (_cursorBlinking) {
             // if cursor is blinking(hidden), blink it again to make it show
             _cursorBlinking = false;
             updateCursor();
         }
         Q_ASSERT(!_cursorBlinking);
     }
 }
 
 void TerminalDisplay::setBlinkingTextEnabled(bool blink)
 {
     _allowBlinkingText = blink;
 
     if (blink && !_blinkTextTimer->isActive()) {
         _blinkTextTimer->start();
     }
 
     if (!blink && _blinkTextTimer->isActive()) {
         _blinkTextTimer->stop();
         _textBlinking = false;
     }
 }
 
 void TerminalDisplay::focusOutEvent(QFocusEvent*)
 {
     // trigger a repaint of the cursor so that it is both:
     //
     //   * visible (in case it was hidden during blinking)
     //   * drawn in a focused out state
     _cursorBlinking = false;
     updateCursor();
 
     // suppress further cursor blinking
     _blinkCursorTimer->stop();
     Q_ASSERT(!_cursorBlinking);
 
     // if text is blinking (hidden), blink it again to make it shown
     if (_textBlinking) {
         blinkTextEvent();
     }
 
     // suppress further text blinking
     _blinkTextTimer->stop();
     Q_ASSERT(!_textBlinking);
 
     _showUrlHint = false;
     _headerBar->terminalFocusOut();
     emit focusLost();
 }
 
 void TerminalDisplay::focusInEvent(QFocusEvent*)
 {
     if (_allowBlinkingCursor) {
         _blinkCursorTimer->start();
     }
 
     updateCursor();
 
     if (_allowBlinkingText && _hasTextBlinker) {
         _blinkTextTimer->start();
     }
     _headerBar->terminalFocusIn();
     emit focusGained();
 }
 
 void TerminalDisplay::blinkTextEvent()
 {
     Q_ASSERT(_allowBlinkingText);
 
     _textBlinking = !_textBlinking;
 
     // TODO: Optimize to only repaint the areas of the widget where there is
     // blinking text rather than repainting the whole widget.
     _headerBar->terminalFocusOut();
     update();
 }
 
 void TerminalDisplay::blinkCursorEvent()
 {
     Q_ASSERT(_allowBlinkingCursor);
 
     _cursorBlinking = !_cursorBlinking;
     updateCursor();
 }
 
 void TerminalDisplay::updateCursor()
 {
     if (!isCursorOnDisplay()){
         return;
     }
 
     const int cursorLocation = loc(cursorPosition().x(), cursorPosition().y());
     Q_ASSERT(cursorLocation < _imageSize);
 
     int charWidth = _image[cursorLocation].width();
     QRect cursorRect = imageToWidget(QRect(cursorPosition(), QSize(charWidth, 1)));
     update(cursorRect);
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                          Geometry & Resizing                              */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TerminalDisplay::resizeEvent(QResizeEvent *event)
 {
     Q_UNUSED(event)
 
     if (contentsRect().isValid()) {
         // NOTE: This calls setTabText() in TabbedViewContainer::updateTitle(),
         // which might update the widget size again. New resizeEvent
         // won't be called, do not rely on new sizes before this call.
         updateImageSize();
         updateImage();
     }
 
     const auto scrollBarWidth = _scrollbarLocation != Enum::ScrollBarHidden
                                 ? _scrollBar->width()
                                 : 0;
     const auto headerHeight = _headerBar->isVisible() ? _headerBar->height() : 0;
 
     const auto x = width() - scrollBarWidth - _searchBar->width();
     const auto y = headerHeight;
     _searchBar->move(x, y);
 }
 
 void TerminalDisplay::propagateSize()
 {
     if (_image != nullptr) {
         updateImageSize();
     }
 }
 
 void TerminalDisplay::updateImageSize()
 {
     Character* oldImage = _image;
     const int oldLines = _lines;
     const int oldColumns = _columns;
 
     makeImage();
 
     if (oldImage != nullptr) {
         // copy the old image to reduce flicker
         int lines = qMin(oldLines, _lines);
         int columns = qMin(oldColumns, _columns);
         for (int line = 0; line < lines; line++) {
             memcpy((void*)&_image[_columns * line],
                    (void*)&oldImage[oldColumns * line],
                    columns * sizeof(Character));
         }
         delete[] oldImage;
     }
 
     if (!_screenWindow.isNull()) {
         _screenWindow->setWindowLines(_lines);
     }
 
     _resizing = (oldLines != _lines) || (oldColumns != _columns);
 
     if (_resizing) {
         showResizeNotification();
         emit changedContentSizeSignal(_contentRect.height(), _contentRect.width()); // expose resizeEvent
     }
 
     _resizing = false;
 }
 
 void TerminalDisplay::makeImage()
 {
     _wallpaper->load();
 
     calcGeometry();
 
     // confirm that array will be of non-zero size, since the painting code
     // assumes a non-zero array length
     Q_ASSERT(_lines > 0 && _columns > 0);
     Q_ASSERT(_usedLines <= _lines && _usedColumns <= _columns);
 
     _imageSize = _lines * _columns;
 
     _image = new Character[_imageSize];
 
     clearImage();
 }
 
 void TerminalDisplay::clearImage()
 {
     for (int i = 0; i < _imageSize; ++i) {
         _image[i] = Screen::DefaultChar;
     }
 }
 
 void TerminalDisplay::calcGeometry()
 {
     const auto headerHeight = _headerBar->isVisible() ? _headerBar->height() : 0;
 
     _scrollBar->resize(
         _scrollBar->sizeHint().width(),        // width
         contentsRect().height() - headerHeight // height
     );
 
     _contentRect = contentsRect().adjusted(_margin, _margin, -_margin, -_margin);
 
     switch (_scrollbarLocation) {
     case Enum::ScrollBarHidden :
         break;
     case Enum::ScrollBarLeft :
         _contentRect.setLeft(_contentRect.left() + _scrollBar->width());
         _scrollBar->move(contentsRect().left(),
                          contentsRect().top() + headerHeight);
         break;
     case Enum::ScrollBarRight:
         _contentRect.setRight(_contentRect.right() - _scrollBar->width());
         _scrollBar->move(contentsRect().left() + contentsRect().width() - _scrollBar->width(),
                          contentsRect().top() + headerHeight);
         break;
     }
 
     _contentRect.setTop(_contentRect.top() + headerHeight);
 
     // ensure that display is always at least one column wide
     _columns = qMax(1, _contentRect.width() / _fontWidth);
     _usedColumns = qMin(_usedColumns, _columns);
 
     // ensure that display is always at least one line high
     _lines = qMax(1, _contentRect.height() / _fontHeight);
     _usedLines = qMin(_usedLines, _lines);
 
     if(_centerContents) {
         QSize unusedPixels = _contentRect.size() - QSize(_columns * _fontWidth, _lines * _fontHeight);
         _contentRect.adjust(unusedPixels.width() / 2, unusedPixels.height() / 2, 0, 0);
     }
 }
 
 // calculate the needed size, this must be synced with calcGeometry()
 void TerminalDisplay::setSize(int columns, int lines)
 {
     const int scrollBarWidth = _scrollBar->isHidden() ? 0 : _scrollBar->sizeHint().width();
     const int horizontalMargin = _margin * 2;
     const int verticalMargin = _margin * 2;
 
     QSize newSize = QSize(horizontalMargin + scrollBarWidth + (columns * _fontWidth)  ,
                           verticalMargin + (lines * _fontHeight));
 
     if (newSize != size()) {
         _size = newSize;
         updateGeometry();
     }
 }
 
 QSize TerminalDisplay::sizeHint() const
 {
     return _size;
 }
 
 //showEvent and hideEvent are reimplemented here so that it appears to other classes that the
 //display has been resized when the display is hidden or shown.
 //
 //TODO: Perhaps it would be better to have separate signals for show and hide instead of using
 //the same signal as the one for a content size change
 void TerminalDisplay::showEvent(QShowEvent*)
 {
     propagateSize();
     emit changedContentSizeSignal(_contentRect.height(), _contentRect.width());
 }
 void TerminalDisplay::hideEvent(QHideEvent*)
 {
     emit changedContentSizeSignal(_contentRect.height(), _contentRect.width());
 }
 
 void TerminalDisplay::setMargin(int margin)
 {
     if (margin < 0) {
         margin = 0;
     }
     _margin = margin;
     updateImageSize();
 }
 
 void TerminalDisplay::setCenterContents(bool enable)
 {
     _centerContents = enable;
     calcGeometry();
     update();
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Scrollbar                                  */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TerminalDisplay::setScrollBarPosition(Enum::ScrollBarPositionEnum position)
 {
     if (_scrollbarLocation == position) {
         return;
     }
 
     _scrollBar->setHidden(position == Enum::ScrollBarHidden);
     _scrollbarLocation = position;
 
     propagateSize();
     update();
 }
 
 void TerminalDisplay::scrollBarPositionChanged(int)
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     _screenWindow->scrollTo(_scrollBar->value());
 
     // if the thumb has been moved to the bottom of the _scrollBar then set
     // the display to automatically track new output,
     // that is, scroll down automatically
     // to how new _lines as they are added
     const bool atEndOfOutput = (_scrollBar->value() == _scrollBar->maximum());
     _screenWindow->setTrackOutput(atEndOfOutput);
 
     updateImage();
 }
 
 void TerminalDisplay::setScroll(int cursor, int slines)
 {
     // update _scrollBar if the range or value has changed,
     // otherwise return
     //
     // setting the range or value of a _scrollBar will always trigger
     // a repaint, so it should be avoided if it is not necessary
     if (_scrollBar->minimum() == 0                 &&
             _scrollBar->maximum() == (slines - _lines) &&
             _scrollBar->value()   == cursor) {
         return;
     }
 
     disconnect(_scrollBar, &QScrollBar::valueChanged, this, &Konsole::TerminalDisplay::scrollBarPositionChanged);
     _scrollBar->setRange(0, slines - _lines);
     _scrollBar->setSingleStep(1);
     _scrollBar->setPageStep(_lines);
     _scrollBar->setValue(cursor);
     connect(_scrollBar, &QScrollBar::valueChanged, this, &Konsole::TerminalDisplay::scrollBarPositionChanged);
 }
 
 void TerminalDisplay::setScrollFullPage(bool fullPage)
 {
     _scrollFullPage = fullPage;
 }
 
 bool TerminalDisplay::scrollFullPage() const
 {
     return _scrollFullPage;
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                  Mouse                                    */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 void TerminalDisplay::mousePressEvent(QMouseEvent* ev)
 {
     if (_possibleTripleClick && (ev->button() == Qt::LeftButton)) {
         mouseTripleClickEvent(ev);
         return;
     }
 
     if (!contentsRect().contains(ev->pos())) {
         return;
     }
 
     if (_screenWindow.isNull()) {
         return;
     }
 
     // Ignore clicks on the message widget
     if (_readOnlyMessageWidget != nullptr) {
         if (_readOnlyMessageWidget->isVisible() && _readOnlyMessageWidget->frameGeometry().contains(ev->pos())) {
             return;
         }
     }
 
     if (_outputSuspendedMessageWidget != nullptr) {
         if (_outputSuspendedMessageWidget->isVisible() && _outputSuspendedMessageWidget->frameGeometry().contains(ev->pos())) {
             return;
         }
     }
 
     int charLine;
     int charColumn;
     getCharacterPosition(ev->pos(), charLine, charColumn, !_usesMouseTracking);
     QPoint pos = QPoint(charColumn, charLine);
 
     if (ev->button() == Qt::LeftButton) {
         // request the software keyboard, if any
         if (qApp->autoSipEnabled()) {
             auto behavior = QStyle::RequestSoftwareInputPanel(
                         style()->styleHint(QStyle::SH_RequestSoftwareInputPanel));
             if (hasFocus() || behavior == QStyle::RSIP_OnMouseClick) {
                 QEvent event(QEvent::RequestSoftwareInputPanel);
                 QApplication::sendEvent(this, &event);
             }
         }
 
         if (!ev->modifiers()) {
             _lineSelectionMode = false;
             _wordSelectionMode = false;
         }
 
         // The user clicked inside selected text
         bool selected =  _screenWindow->isSelected(pos.x(), pos.y());
 
         // Drag only when the Control key is held
         if ((!_ctrlRequiredForDrag || ((ev->modifiers() & Qt::ControlModifier) != 0u)) && selected) {
             _dragInfo.state = diPending;
             _dragInfo.start = ev->pos();
         } else {
             // No reason to ever start a drag event
             _dragInfo.state = diNone;
 
             _preserveLineBreaks = !(((ev->modifiers() & Qt::ControlModifier) != 0u) && !(ev->modifiers() & Qt::AltModifier));
             _columnSelectionMode = ((ev->modifiers() & Qt::AltModifier) != 0u) && ((ev->modifiers() & Qt::ControlModifier) != 0u);
 
     // There are a couple of use cases when selecting text :
     // Normal buffer or Alternate buffer when not using Mouse Tracking:
     //  select text or extendSelection or columnSelection or columnSelection + extendSelection
     //
     // Alternate buffer when using Mouse Tracking and with Shift pressed:
     //  select text or columnSelection
             if (!_usesMouseTracking &&
                 ((ev->modifiers() == Qt::ShiftModifier) ||
                 (((ev->modifiers() & Qt::ShiftModifier) != 0u) && _columnSelectionMode))) {
                     extendSelection(ev->pos());
             } else if ((!_usesMouseTracking && !((ev->modifiers() & Qt::ShiftModifier))) ||
                        (_usesMouseTracking && ((ev->modifiers() & Qt::ShiftModifier) != 0u))) {
                 _screenWindow->clearSelection();
 
                 pos.ry() += _scrollBar->value();
                 _iPntSel = _pntSel = pos;
                 _actSel = 1; // left mouse button pressed but nothing selected yet.
             } else if (_usesMouseTracking && !_readOnly) {
                     emit mouseSignal(0, charColumn + 1, charLine + 1 + _scrollBar->value() - _scrollBar->maximum() , 0);
             }
 
             if ((_openLinksByDirectClick || ((ev->modifiers() & Qt::ControlModifier) != 0u))) {
                 Filter::HotSpot* spot = _filterChain->hotSpotAt(charLine, charColumn);
                 if ((spot != nullptr) && spot->type() == Filter::HotSpot::Link) {
                     QObject action;
                     action.setObjectName(QStringLiteral("open-action"));
                     spot->activate(&action);
                 }
             }
         }
     } else if (ev->button() == Qt::MidButton) {
         processMidButtonClick(ev);
     } else if (ev->button() == Qt::RightButton) {
         if (!_usesMouseTracking || ((ev->modifiers() & Qt::ShiftModifier) != 0u)) {
             emit configureRequest(ev->pos());
         } else {
             if(!_readOnly) {
                 emit mouseSignal(2, charColumn + 1, charLine + 1 + _scrollBar->value() - _scrollBar->maximum() , 0);
             }
         }
     }
 }
 
 QList<QAction*> TerminalDisplay::filterActions(const QPoint& position)
 {
     int charLine, charColumn;
     getCharacterPosition(position, charLine, charColumn, false);
 
     Filter::HotSpot* spot = _filterChain->hotSpotAt(charLine, charColumn);
 
     return spot != nullptr ? spot->actions() : QList<QAction*>();
 }
 
 void TerminalDisplay::mouseMoveEvent(QMouseEvent* ev)
 {
     int charLine = 0;
     int charColumn = 0;
     getCharacterPosition(ev->pos(), charLine, charColumn, !_usesMouseTracking);
 
     processFilters();
     // handle filters
     // change link hot-spot appearance on mouse-over
     Filter::HotSpot* spot = _filterChain->hotSpotAt(charLine, charColumn);
     if ((spot != nullptr) && spot->type() == Filter::HotSpot::Link) {
         QRegion previousHotspotArea = _mouseOverHotspotArea;
         _mouseOverHotspotArea = QRegion();
         QRect r;
         if (spot->startLine() == spot->endLine()) {
             r.setCoords(spot->startColumn()*_fontWidth + _contentRect.left(),
                         spot->startLine()*_fontHeight + _contentRect.top(),
                         (spot->endColumn())*_fontWidth + _contentRect.left() - 1,
                         (spot->endLine() + 1)*_fontHeight + _contentRect.top() - 1);
             _mouseOverHotspotArea |= r;
         } else {
             r.setCoords(spot->startColumn()*_fontWidth + _contentRect.left(),
                         spot->startLine()*_fontHeight + _contentRect.top(),
                         (_columns)*_fontWidth + _contentRect.left() - 1,
                         (spot->startLine() + 1)*_fontHeight + _contentRect.top() - 1);
             _mouseOverHotspotArea |= r;
             for (int line = spot->startLine() + 1 ; line < spot->endLine() ; line++) {
                 r.setCoords(0 * _fontWidth + _contentRect.left(),
                             line * _fontHeight + _contentRect.top(),
                             (_columns)*_fontWidth + _contentRect.left() - 1,
                             (line + 1)*_fontHeight + _contentRect.top() - 1);
                 _mouseOverHotspotArea |= r;
             }
             r.setCoords(0 * _fontWidth + _contentRect.left(),
                         spot->endLine()*_fontHeight + _contentRect.top(),
                         (spot->endColumn())*_fontWidth + _contentRect.left() - 1,
                         (spot->endLine() + 1)*_fontHeight + _contentRect.top() - 1);
             _mouseOverHotspotArea |= r;
         }
 
         if ((_openLinksByDirectClick || ((ev->modifiers() & Qt::ControlModifier) != 0u)) && (cursor().shape() != Qt::PointingHandCursor)) {
             setCursor(Qt::PointingHandCursor);
         }
 
         update(_mouseOverHotspotArea | previousHotspotArea);
     } else if (!_mouseOverHotspotArea.isEmpty()) {
         if ((_openLinksByDirectClick || ((ev->modifiers() & Qt::ControlModifier) != 0u)) || (cursor().shape() == Qt::PointingHandCursor)) {
             setCursor(_usesMouseTracking ? Qt::ArrowCursor : Qt::IBeamCursor);
         }
 
         update(_mouseOverHotspotArea);
         // set hotspot area to an invalid rectangle
         _mouseOverHotspotArea = QRegion();
     }
 
     // for auto-hiding the cursor, we need mouseTracking
     if (ev->buttons() == Qt::NoButton) {
         return;
     }
 
     // if the program running in the terminal is interested in Mouse Tracking
     // evnets then emit a mouse movement signal, unless the shift key is
     // being held down, which overrides this.
     if (_usesMouseTracking && !(ev->modifiers() & Qt::ShiftModifier)) {
         int button = 3;
         if ((ev->buttons() & Qt::LeftButton) != 0u) {
             button = 0;
         }
         if ((ev->buttons() & Qt::MidButton) != 0u) {
             button = 1;
         }
         if ((ev->buttons() & Qt::RightButton) != 0u) {
             button = 2;
         }
 
         emit mouseSignal(button,
                          charColumn + 1,
                          charLine + 1 + _scrollBar->value() - _scrollBar->maximum(),
                          1);
 
         return;
     }
 
     if (_dragInfo.state == diPending) {
         // we had a mouse down, but haven't confirmed a drag yet
         // if the mouse has moved sufficiently, we will confirm
 
         const int distance = QApplication::startDragDistance();
         if (ev->x() > _dragInfo.start.x() + distance || ev->x() < _dragInfo.start.x() - distance ||
                 ev->y() > _dragInfo.start.y() + distance || ev->y() < _dragInfo.start.y() - distance) {
             // we've left the drag square, we can start a real drag operation now
 
             _screenWindow->clearSelection();
             doDrag();
         }
         return;
     } else if (_dragInfo.state == diDragging) {
         // this isn't technically needed because mouseMoveEvent is suppressed during
         // Qt drag operations, replaced by dragMoveEvent
         return;
     }
 
     if (_actSel == 0) {
         return;
     }
 
 // don't extend selection while pasting
     if ((ev->buttons() & Qt::MidButton) != 0u) {
         return;
     }
 
     extendSelection(ev->pos());
 }
 
 void TerminalDisplay::leaveEvent(QEvent *)
 {
     // remove underline from an active link when cursor leaves the widget area
     if(!_mouseOverHotspotArea.isEmpty()) {
         update(_mouseOverHotspotArea);
         _mouseOverHotspotArea = QRegion();
     }
 }
 
 void TerminalDisplay::extendSelection(const QPoint& position)
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     //if ( !contentsRect().contains(ev->pos()) ) return;
     const QPoint tL  = contentsRect().topLeft();
     const int    tLx = tL.x();
     const int    tLy = tL.y();
     const int    scroll = _scrollBar->value();
 
     // we're in the process of moving the mouse with the left button pressed
     // the mouse cursor will kept caught within the bounds of the text in
     // this widget.
 
     int linesBeyondWidget = 0;
 
     QRect textBounds(tLx + _contentRect.left(),
                      tLy + _contentRect.top(),
                      _usedColumns * _fontWidth - 1,
                      _usedLines * _fontHeight - 1);
 
     QPoint pos = position;
 
     // Adjust position within text area bounds.
     const QPoint oldpos = pos;
 
     pos.setX(qBound(textBounds.left(), pos.x(), textBounds.right()));
     pos.setY(qBound(textBounds.top(), pos.y(), textBounds.bottom()));
 
     if (oldpos.y() > textBounds.bottom()) {
         linesBeyondWidget = (oldpos.y() - textBounds.bottom()) / _fontHeight;
         _scrollBar->setValue(_scrollBar->value() + linesBeyondWidget + 1); // scrollforward
     }
     if (oldpos.y() < textBounds.top()) {
         linesBeyondWidget = (textBounds.top() - oldpos.y()) / _fontHeight;
         _scrollBar->setValue(_scrollBar->value() - linesBeyondWidget - 1); // history
     }
 
     int charColumn = 0;
     int charLine = 0;
     getCharacterPosition(pos, charLine, charColumn, true);
 
     QPoint here = QPoint(charColumn, charLine);
     QPoint ohere;
     QPoint _iPntSelCorr = _iPntSel;
     _iPntSelCorr.ry() -= _scrollBar->value();
     QPoint _pntSelCorr = _pntSel;
     _pntSelCorr.ry() -= _scrollBar->value();
     bool swapping = false;
 
     if (_wordSelectionMode) {
         // Extend to word boundaries
         const bool left_not_right = (here.y() < _iPntSelCorr.y() ||
                                      (here.y() == _iPntSelCorr.y() && here.x() < _iPntSelCorr.x()));
         const bool old_left_not_right = (_pntSelCorr.y() < _iPntSelCorr.y() ||
                                          (_pntSelCorr.y() == _iPntSelCorr.y() && _pntSelCorr.x() < _iPntSelCorr.x()));
         swapping = left_not_right != old_left_not_right;
 
         // Find left (left_not_right ? from here : from start of word)
         QPoint left = left_not_right ? here : _iPntSelCorr;
         // Find left (left_not_right ? from end of word : from here)
         QPoint right = left_not_right ? _iPntSelCorr : here;
 
         if (left.y() < 0 || left.y() >= _lines || left.x() < 0 || left.x() >= _columns) {
             left = _pntSelCorr;
         } else {
             left = findWordStart(left);
         }
         if (right.y() < 0 || right.y() >= _lines || right.x() < 0 || right.x() >= _columns) {
             right = _pntSelCorr;
         } else {
             right = findWordEnd(right);
         }
 
         // Pick which is start (ohere) and which is extension (here)
         if (left_not_right) {
             here = left;
             ohere = right;
         } else {
             here = right;
             ohere = left;
         }
         ohere.rx()++;
     }
 
     if (_lineSelectionMode) {
         // Extend to complete line
         const bool above_not_below = (here.y() < _iPntSelCorr.y());
         if (above_not_below) {
             ohere = findLineEnd(_iPntSelCorr);
             here = findLineStart(here);
         } else {
             ohere = findLineStart(_iPntSelCorr);
             here = findLineEnd(here);
         }
 
         swapping = !(_tripleSelBegin == ohere);
         _tripleSelBegin = ohere;
 
         ohere.rx()++;
     }
 
     int offset = 0;
     if (!_wordSelectionMode && !_lineSelectionMode) {
         QChar selClass;
 
         const bool left_not_right = (here.y() < _iPntSelCorr.y() ||
                                      (here.y() == _iPntSelCorr.y() && here.x() < _iPntSelCorr.x()));
         const bool old_left_not_right = (_pntSelCorr.y() < _iPntSelCorr.y() ||
                                          (_pntSelCorr.y() == _iPntSelCorr.y() && _pntSelCorr.x() < _iPntSelCorr.x()));
         swapping = left_not_right != old_left_not_right;
 
         // Find left (left_not_right ? from here : from start)
         const QPoint left = left_not_right ? here : _iPntSelCorr;
 
         // Find left (left_not_right ? from start : from here)
         QPoint right = left_not_right ? _iPntSelCorr : here;
         if (right.x() > 0 && !_columnSelectionMode) {
             if (right.x() - 1 < _columns && right.y() < _lines) {
                 selClass = charClass(_image[loc(right.x() - 1, right.y())]);
             }
         }
 
         // Pick which is start (ohere) and which is extension (here)
         if (left_not_right) {
             here = left;
             ohere = right;
             offset = 0;
         } else {
             here = right;
             ohere = left;
             offset = -1;
         }
     }
 
     if ((here == _pntSelCorr) && (scroll == _scrollBar->value())) {
         return; // not moved
     }
 
     if (here == ohere) {
         return; // It's not left, it's not right.
     }
 
     if (_actSel < 2 || swapping) {
         if (_columnSelectionMode && !_lineSelectionMode && !_wordSelectionMode) {
             _screenWindow->setSelectionStart(ohere.x() , ohere.y() , true);
         } else {
             _screenWindow->setSelectionStart(ohere.x() - 1 - offset , ohere.y() , false);
         }
     }
 
     _actSel = 2; // within selection
     _pntSel = here;
     _pntSel.ry() += _scrollBar->value();
 
     if (_columnSelectionMode && !_lineSelectionMode && !_wordSelectionMode) {
         _screenWindow->setSelectionEnd(here.x() , here.y());
     } else {
         _screenWindow->setSelectionEnd(here.x() + offset , here.y());
     }
 }
 
 void TerminalDisplay::mouseReleaseEvent(QMouseEvent* ev)
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     int charLine;
     int charColumn;
     getCharacterPosition(ev->pos(), charLine, charColumn, !_usesMouseTracking);
 
     if (ev->button() == Qt::LeftButton) {
         if (_dragInfo.state == diPending) {
             // We had a drag event pending but never confirmed.  Kill selection
             _screenWindow->clearSelection();
         } else {
             if (_actSel > 1) {
                 copyToX11Selection();
             }
 
             _actSel = 0;
 
             //FIXME: emits a release event even if the mouse is
             //       outside the range. The procedure used in `mouseMoveEvent'
             //       applies here, too.
 
             if (_usesMouseTracking && !(ev->modifiers() & Qt::ShiftModifier)) {
                 emit mouseSignal(0,
                                  charColumn + 1,
                                  charLine + 1 + _scrollBar->value() - _scrollBar->maximum() , 2);
             }
         }
         _dragInfo.state = diNone;
     }
 
     if (_usesMouseTracking &&
             (ev->button() == Qt::RightButton || ev->button() == Qt::MidButton) &&
             !(ev->modifiers() & Qt::ShiftModifier)) {
         emit mouseSignal(ev->button() == Qt::MidButton ? 1 : 2,
                          charColumn + 1,
                          charLine + 1 + _scrollBar->value() - _scrollBar->maximum() ,
                          2);
     }
 }
 
 void TerminalDisplay::getCharacterPosition(const QPoint& widgetPoint, int& line, int& column, bool edge) const
 {
     // the column value returned can be equal to _usedColumns (when edge == true),
     // which is the position just after the last character displayed in a line.
     //
     // this is required so that the user can select characters in the right-most
     // column (or left-most for right-to-left input)
     const int columnMax = edge ? _usedColumns : _usedColumns - 1;
     const int xOffset = edge ? _fontWidth / 2 : 0;
     column = qBound(0, (widgetPoint.x() + xOffset - contentsRect().left() - _contentRect.left()) / _fontWidth, columnMax);
     line = qBound(0, (widgetPoint.y() - contentsRect().top() - _contentRect.top()) / _fontHeight, _usedLines - 1);
 }
 
 void TerminalDisplay::updateLineProperties()
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     _lineProperties = _screenWindow->getLineProperties();
 }
 
 void TerminalDisplay::processMidButtonClick(QMouseEvent* ev)
 {
     if (!_usesMouseTracking || ((ev->modifiers() & Qt::ShiftModifier) != 0u)) {
         const bool appendEnter = (ev->modifiers() & Qt::ControlModifier) != 0u;
 
         if (_middleClickPasteMode == Enum::PasteFromX11Selection) {
             pasteFromX11Selection(appendEnter);
         } else if (_middleClickPasteMode == Enum::PasteFromClipboard) {
             pasteFromClipboard(appendEnter);
         } else {
             Q_ASSERT(false);
         }
     } else {
         if(!_readOnly) {
             int charLine = 0;
             int charColumn = 0;
             getCharacterPosition(ev->pos(), charLine, charColumn, !_usesMouseTracking);
 
             emit mouseSignal(1, charColumn + 1, charLine + 1 + _scrollBar->value() - _scrollBar->maximum() , 0);
         }
     }
 }
 
 void TerminalDisplay::mouseDoubleClickEvent(QMouseEvent* ev)
 {
     // Yes, successive middle click can trigger this event
     if (ev->button() == Qt::MidButton) {
         processMidButtonClick(ev);
         return;
     }
 
     if (ev->button() != Qt::LeftButton) {
         return;
     }
     if (_screenWindow.isNull()) {
         return;
     }
 
     int charLine = 0;
     int charColumn = 0;
 
     getCharacterPosition(ev->pos(), charLine, charColumn, !_usesMouseTracking);
 
     QPoint pos(qMin(charColumn, _columns - 1), qMin(charLine, _lines - 1));
 
     // pass on double click as two clicks.
     if (_usesMouseTracking && !(ev->modifiers() & Qt::ShiftModifier)) {
         if(!_readOnly) {
             // Send just _ONE_ click event, since the first click of the double click
             // was already sent by the click handler
             emit mouseSignal(0, charColumn + 1,
                              charLine + 1 + _scrollBar->value() - _scrollBar->maximum(),
                              0);  // left button
         }
         return;
     }
 
     _screenWindow->clearSelection();
     _iPntSel = pos;
     _iPntSel.ry() += _scrollBar->value();
 
     _wordSelectionMode = true;
     _actSel = 2; // within selection
 
     // find word boundaries...
     {
         // find the start of the word
         const QPoint bgnSel = findWordStart(pos);
         const QPoint endSel = findWordEnd(pos);
 
         _actSel = 2; // within selection
 
         _screenWindow->setSelectionStart(bgnSel.x() , bgnSel.y() , false);
         _screenWindow->setSelectionEnd(endSel.x() , endSel.y());
 
         copyToX11Selection();
     }
 
     _possibleTripleClick = true;
 
     QTimer::singleShot(QApplication::doubleClickInterval(), this, [this]() {
         _possibleTripleClick = false;
     });
 }
 
 void TerminalDisplay::wheelEvent(QWheelEvent* ev)
 {
     // Only vertical scrolling is supported
     if (ev->orientation() != Qt::Vertical) {
         return;
     }
 
     const int modifiers = ev->modifiers();
 
     // ctrl+<wheel> for zooming, like in konqueror and firefox
     if (((modifiers & Qt::ControlModifier) != 0u) && _mouseWheelZoom) {
         _scrollWheelState.addWheelEvent(ev);
 
         int steps = _scrollWheelState.consumeLegacySteps(ScrollState::DEFAULT_ANGLE_SCROLL_LINE);
         for (;steps > 0; --steps) {
             // wheel-up for increasing font size
             increaseFontSize();
         }
         for (;steps < 0; ++steps) {
             // wheel-down for decreasing font size
             decreaseFontSize();
         }
     } else if (!_usesMouseTracking && (_scrollBar->maximum() > 0)) {
         // If the program running in the terminal is not interested in Mouse
         // Tracking events, send the event to the scrollbar if the slider
         // has room to move
 
         _scrollWheelState.addWheelEvent(ev);
 
         _scrollBar->event(ev);
 
         Q_ASSERT(_sessionController != nullptr);
 
         _sessionController->setSearchStartToWindowCurrentLine();
         _scrollWheelState.clearAll();
     } else if (!_readOnly) {
         _scrollWheelState.addWheelEvent(ev);
 
         Q_ASSERT(!_sessionController->session().isNull());
 
         if(!_usesMouseTracking && !_sessionController->session()->isPrimaryScreen() && _alternateScrolling) {
             // Send simulated up / down key presses to the terminal program
             // for the benefit of programs such as 'less' (which use the alternate screen)
 
             // assume that each Up / Down key event will cause the terminal application
             // to scroll by one line.
             //
             // to get a reasonable scrolling speed, scroll by one line for every 5 degrees
             // of mouse wheel rotation.  Mouse wheels typically move in steps of 15 degrees,
             // giving a scroll of 3 lines
 
             const int lines = _scrollWheelState.consumeSteps(static_cast<int>(_fontHeight * qApp->devicePixelRatio()), ScrollState::degreesToAngle(5));
             const int keyCode = lines > 0 ? Qt::Key_Up : Qt::Key_Down;
             QKeyEvent keyEvent(QEvent::KeyPress, keyCode, Qt::NoModifier);
 
             for (int i = 0; i < abs(lines); i++) {
                 _screenWindow->screen()->setCurrentTerminalDisplay(this);
                 emit keyPressedSignal(&keyEvent);
             }
         } else if (_usesMouseTracking) {
             // terminal program wants notification of mouse activity
 
             int charLine;
             int charColumn;
             getCharacterPosition(ev->pos() , charLine , charColumn, !_usesMouseTracking);
             const int steps = _scrollWheelState.consumeLegacySteps(ScrollState::DEFAULT_ANGLE_SCROLL_LINE);
             const int button = (steps > 0) ? 4 : 5;
             for (int i = 0; i < abs(steps); ++i) {
                 emit mouseSignal(button,
                                  charColumn + 1,
                                  charLine + 1 + _scrollBar->value() - _scrollBar->maximum() ,
                                  0);
             }
         }
     }
 }
 
 void TerminalDisplay::viewScrolledByUser()
 {
     Q_ASSERT(_sessionController != nullptr);
     _sessionController->setSearchStartToWindowCurrentLine();
 }
 
 /* Moving left/up from the line containing pnt, return the starting
    offset point which the given line is continuously wrapped
    (top left corner = 0,0; previous line not visible = 0,-1).
 */
 QPoint TerminalDisplay::findLineStart(const QPoint &pnt)
 {
     const int visibleScreenLines = _lineProperties.size();
     const int topVisibleLine = _screenWindow->currentLine();
     Screen *screen = _screenWindow->screen();
     int line = pnt.y();
     int lineInHistory= line + topVisibleLine;
 
     QVector<LineProperty> lineProperties = _lineProperties;
 
     while (lineInHistory > 0) {
         for (; line > 0; line--, lineInHistory--) {
             // Does previous line wrap around?
             if ((lineProperties[line - 1] & LINE_WRAPPED) == 0) {
                 return {0, lineInHistory - topVisibleLine};
             }
         }
 
         if (lineInHistory < 1) {
             break;
         }
 
         // _lineProperties is only for the visible screen, so grab new data
         int newRegionStart = qMax(0, lineInHistory - visibleScreenLines);
         lineProperties = screen->getLineProperties(newRegionStart, lineInHistory - 1);
         line = lineInHistory - newRegionStart;
     }
     return {0, lineInHistory - topVisibleLine};
 }
 
 /* Moving right/down from the line containing pnt, return the ending
    offset point which the given line is continuously wrapped.
 */
 QPoint TerminalDisplay::findLineEnd(const QPoint &pnt)
 {
     const int visibleScreenLines = _lineProperties.size();
     const int topVisibleLine = _screenWindow->currentLine();
     const int maxY = _screenWindow->lineCount() - 1;
     Screen *screen = _screenWindow->screen();
     int line = pnt.y();
     int lineInHistory= line + topVisibleLine;
 
     QVector<LineProperty> lineProperties = _lineProperties;
 
     while (lineInHistory < maxY) {
         for (; line < lineProperties.count() && lineInHistory < maxY; line++, lineInHistory++) {
             // Does current line wrap around?
             if ((lineProperties[line] & LINE_WRAPPED) == 0) {
                 return {_columns - 1, lineInHistory - topVisibleLine};
             }
         }
 
         line = 0;
         lineProperties = screen->getLineProperties(lineInHistory, qMin(lineInHistory + visibleScreenLines, maxY));
     }
     return {_columns - 1, lineInHistory - topVisibleLine};
 }
 
 QPoint TerminalDisplay::findWordStart(const QPoint &pnt)
 {
     const int regSize = qMax(_screenWindow->windowLines(), 10);
     const int firstVisibleLine = _screenWindow->currentLine();
 
     Screen *screen = _screenWindow->screen();
     Character *image = _image;
     Character *tmp_image = nullptr;
 
     int imgLine = pnt.y();
     int x = pnt.x();
     int y = imgLine + firstVisibleLine;
     int imgLoc = loc(x, imgLine);
     QVector<LineProperty> lineProperties = _lineProperties;
     const QChar selClass = charClass(image[imgLoc]);
     const int imageSize = regSize * _columns;
 
     while (true) {
         for (;;imgLoc--, x--) {
             if (imgLoc < 1) {
                 // no more chars in this region
                 break;
             }
             if (x > 0) {
                 // has previous char on this line
                 if (charClass(image[imgLoc - 1]) == selClass) {
                     continue;
                 }
                 goto out;
             } else if (imgLine > 0) {
                 // not the first line in the session
                 if ((lineProperties[imgLine - 1] & LINE_WRAPPED) != 0) {
                     // have continuation on prev line
                     if (charClass(image[imgLoc - 1]) == selClass) {
                         x = _columns;
                         imgLine--;
                         y--;
                         continue;
                     }
                 }
                 goto out;
             } else if (y > 0) {
                 // want more data, but need to fetch new region
                 break;
             } else {
                 goto out;
             }
         }
         if (y <= 0) {
             // No more data
             goto out;
         }
         int newRegStart = qMax(0, y - regSize + 1);
         lineProperties = screen->getLineProperties(newRegStart, y - 1);
         imgLine = y - newRegStart;
 
         delete[] tmp_image;
         tmp_image = new Character[imageSize];
         image = tmp_image;
 
         screen->getImage(tmp_image, imageSize, newRegStart, y - 1);
         imgLoc = loc(x, imgLine);
         if (imgLoc < 1) {
             // Reached the start of the session
             break;
         }
     }
 out:
     delete[] tmp_image;
     return {x, y - firstVisibleLine};
 }
 
 QPoint TerminalDisplay::findWordEnd(const QPoint &pnt)
 {
     const int regSize = qMax(_screenWindow->windowLines(), 10);
     const int curLine = _screenWindow->currentLine();
     int i = pnt.y();
     int x = pnt.x();
     int y = i + curLine;
     int j = loc(x, i);
     QVector<LineProperty> lineProperties = _lineProperties;
     Screen *screen = _screenWindow->screen();
     Character *image = _image;
     Character *tmp_image = nullptr;
     const QChar selClass = charClass(image[j]);
     const int imageSize = regSize * _columns;
     const int maxY = _screenWindow->lineCount() - 1;
     const int maxX = _columns - 1;
 
     while (true) {
         const int lineCount = lineProperties.count();
         for (;;j++, x++) {
             if (x < maxX) {
                 if (charClass(image[j + 1]) == selClass &&
                     // A colon right before whitespace is never part of a word
                     ! (image[j + 1].character == ':' && charClass(image[j + 2]) == QLatin1Char(' '))) {
                     continue;
                 }
                 goto out;
             } else if (i < lineCount - 1) {
                 if (((lineProperties[i] & LINE_WRAPPED) != 0) &&
                     charClass(image[j + 1]) == selClass &&
                     // A colon right before whitespace is never part of a word
                     ! (image[j + 1].character == ':' && charClass(image[j + 2]) == QLatin1Char(' '))) {
                     x = -1;
                     i++;
                     y++;
                     continue;
                 }
                 goto out;
             } else if (y < maxY) {
                 if (i < lineCount && ((lineProperties[i] & LINE_WRAPPED) == 0)) {
                     goto out;
                 }
                 break;
             } else {
                 goto out;
             }
         }
         int newRegEnd = qMin(y + regSize - 1, maxY);
         lineProperties = screen->getLineProperties(y, newRegEnd);
         i = 0;
         if (tmp_image == nullptr) {
             tmp_image = new Character[imageSize];
             image = tmp_image;
         }
         screen->getImage(tmp_image, imageSize, y, newRegEnd);
         x--;
         j = loc(x, i);
     }
 out:
     y -= curLine;
     // In word selection mode don't select @ (64) if at end of word.
     if (((image[j].rendition & RE_EXTENDED_CHAR) == 0) &&
         (QChar(image[j].character) == QLatin1Char('@')) &&
         (y > pnt.y() || x > pnt.x())) {
         if (x > 0) {
             x--;
         } else {
             y--;
         }
     }
     delete[] tmp_image;
 
     return {x, y};
 }
 
 Screen::DecodingOptions TerminalDisplay::currentDecodingOptions()
 {
     Screen::DecodingOptions decodingOptions;
     if (_preserveLineBreaks) {
         decodingOptions |= Screen::PreserveLineBreaks;
     }
     if (_trimLeadingSpaces) {
         decodingOptions |= Screen::TrimLeadingWhitespace;
     }
     if (_trimTrailingSpaces) {
         decodingOptions |= Screen::TrimTrailingWhitespace;
     }
 
     return decodingOptions;
 }
 
 void TerminalDisplay::mouseTripleClickEvent(QMouseEvent* ev)
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     int charLine;
     int charColumn;
     getCharacterPosition(ev->pos(), charLine, charColumn, true);
     selectLine(QPoint(charColumn, charLine),
                _tripleClickMode == Enum::SelectWholeLine);
 }
 
 void TerminalDisplay::selectLine(QPoint pos, bool entireLine)
 {
     _iPntSel = pos;
 
     _screenWindow->clearSelection();
 
     _lineSelectionMode = true;
     _wordSelectionMode = false;
 
     _actSel = 2; // within selection
 
     if (!entireLine) { // Select from cursor to end of line
         _tripleSelBegin = findWordStart(_iPntSel);
         _screenWindow->setSelectionStart(_tripleSelBegin.x(),
                                          _tripleSelBegin.y() , false);
     } else {
         _tripleSelBegin = findLineStart(_iPntSel);
         _screenWindow->setSelectionStart(0 , _tripleSelBegin.y() , false);
     }
 
     _iPntSel = findLineEnd(_iPntSel);
     _screenWindow->setSelectionEnd(_iPntSel.x() , _iPntSel.y());
 
     copyToX11Selection();
 
     _iPntSel.ry() += _scrollBar->value();
 }
 
 void TerminalDisplay::selectCurrentLine()
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     selectLine(cursorPosition(), true);
 }
 
 void TerminalDisplay::selectAll()
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     _preserveLineBreaks = true;
     _screenWindow->setSelectionByLineRange(0, _screenWindow->lineCount());
     copyToX11Selection();
 }
 
 bool TerminalDisplay::focusNextPrevChild(bool next)
 {
     // for 'Tab', always disable focus switching among widgets
     // for 'Shift+Tab', leave the decision to higher level
     if (next) {
         return false;
     } else {
         return QWidget::focusNextPrevChild(next);
     }
 }
 
 QChar TerminalDisplay::charClass(const Character& ch) const
 {
     if ((ch.rendition & RE_EXTENDED_CHAR) != 0) {
         ushort extendedCharLength = 0;
         const uint* chars = ExtendedCharTable::instance.lookupExtendedChar(ch.character, extendedCharLength);
         if ((chars != nullptr) && extendedCharLength > 0) {
             const QString s = QString::fromUcs4(chars, extendedCharLength);
             if (_wordCharacters.contains(s, Qt::CaseInsensitive)) {
                 return QLatin1Char('a');
             }
             bool letterOrNumber = false;
             for (int i = 0; !letterOrNumber && i < s.size(); ++i) {
                 letterOrNumber = s.at(i).isLetterOrNumber();
             }
             return letterOrNumber ? QLatin1Char('a') : s.at(0);
         }
         return 0;
     } else {
         const QChar qch(ch.character);
         if (qch.isSpace()) {
             return QLatin1Char(' ');
         }
 
         if (qch.isLetterOrNumber() || _wordCharacters.contains(qch, Qt::CaseInsensitive)) {
             return QLatin1Char('a');
         }
 
         return qch;
     }
 }
 
 void TerminalDisplay::setWordCharacters(const QString& wc)
 {
     _wordCharacters = wc;
 }
 
 void TerminalDisplay::setUsesMouseTracking(bool on)
 {
     _usesMouseTracking = on;
     setCursor(_usesMouseTracking ? Qt::ArrowCursor : Qt::IBeamCursor);
 }
 bool TerminalDisplay::usesMouseTracking() const
 {
     return _usesMouseTracking;
 }
 
 void TerminalDisplay::setAlternateScrolling(bool enable)
 {
     _alternateScrolling = enable;
 }
 bool TerminalDisplay::alternateScrolling() const
 {
     return _alternateScrolling;
 }
 
 void TerminalDisplay::setBracketedPasteMode(bool on)
 {
     _bracketedPasteMode = on;
 }
 bool TerminalDisplay::bracketedPasteMode() const
 {
     return _bracketedPasteMode;
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                               Clipboard                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TerminalDisplay::doPaste(QString text, bool appendReturn)
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     if (_readOnly) {
         return;
     }
 
     if (appendReturn) {
         text.append(QLatin1String("\r"));
     }
 
     if (text.length() > 8000) {
         if (KMessageBox::warningContinueCancel(window(),
                         i18np("Are you sure you want to paste %1 character?",
                               "Are you sure you want to paste %1 characters?",
                               text.length()),
                         i18n("Confirm Paste"),
                         KStandardGuiItem::cont(),
                         KStandardGuiItem::cancel(),
                         QStringLiteral("ShowPasteHugeTextWarning")) == KMessageBox::Cancel) {
             return;
         }
     }
 
     // Most code in Konsole uses UTF-32. We're filtering
     // UTF-16 here, as all control characters can be represented
     // in this encoding as single code unit. If you ever need to
     // filter anything above 0xFFFF (specific code points or
     // categories which contain such code points), convert text to
     // UTF-32 using QString::toUcs4() and use QChar static
     // methods which take "uint ucs4".
     static const QVector<ushort> whitelist = { u'\t', u'\r', u'\n' };
     static const auto isUnsafe = [](const QChar &c) {
         return (c.category() == QChar::Category::Other_Control && !whitelist.contains(c.unicode()));
     };
     // Returns control sequence string (e.g. "^C") for control character c
     static const auto charToSequence = [](const QChar &c) {
         if (c.unicode() <= 0x1F) {
             return QStringLiteral("^%1").arg(QChar(u'@' + c.unicode()));
         } else if (c.unicode() == 0x7F) {
             return QStringLiteral("^?");
         } else if (c.unicode() >= 0x80 && c.unicode() <= 0x9F){
             return QStringLiteral("^[%1").arg(QChar(u'@' + c.unicode() - 0x80));
         }
         return QString();
     };
 
     const QMap<ushort, QString> characterDescriptions = {
         {0x0003, i18n("End Of Text/Interrupt: may exit the current process")},
         {0x0004, i18n("End Of Transmission: may exit the current process")},
         {0x0007, i18n("Bell: will try to emit an audible warning")},
         {0x0008, i18n("Backspace")},
         {0x0013, i18n("Device Control Three/XOFF: suspends output")},
         {0x001a, i18n("Substitute/Suspend: may suspend current process")},
         {0x001b, i18n("Escape: used for manipulating terminal state")},
         {0x001c, i18n("File Separator/Quit: may abort the current process")},
     };
 
     QStringList unsafeCharacters;
     for (const QChar &c : text) {
         if (isUnsafe(c)) {
             const QString sequence = charToSequence(c);
             const QString description = characterDescriptions.value(c.unicode(), QString());
             QString entry = QStringLiteral("U+%1").arg(c.unicode(), 4, 16, QLatin1Char('0'));
             if(!sequence.isEmpty()) {
                 entry += QStringLiteral("\t%1").arg(sequence);
             }
             if(!description.isEmpty()) {
                 entry += QStringLiteral("\t%1").arg(description);
             }
             unsafeCharacters.append(entry);
         }
     }
     unsafeCharacters.removeDuplicates();
 
     if (!unsafeCharacters.isEmpty()) {
         int result = KMessageBox::warningYesNoCancelList(window(),
                 i18n("The text you're trying to paste contains hidden control characters, "
                     "do you want to filter them out?"),
                 unsafeCharacters,
                 i18nc("@title", "Confirm Paste"),
                 KGuiItem(i18nc("@action:button",
                     "Paste &without control characters"),
                     QStringLiteral("filter-symbolic")),
                 KGuiItem(i18nc("@action:button",
                     "&Paste everything"),
                     QStringLiteral("edit-paste")),
                 KGuiItem(i18nc("@action:button",
                     "&Cancel"),
                     QStringLiteral("dialog-cancel")),
                 QStringLiteral("ShowPasteUnprintableWarning")
             );
         switch(result){
         case KMessageBox::Cancel:
             return;
         case KMessageBox::Yes: {
             QString sanitized;
             for (const QChar &c : text) {
                 if (!isUnsafe(c)) {
                     sanitized.append(c);
                 }
             }
             text = sanitized;
         }
         case KMessageBox::No:
             break;
         default:
             break;
         }
     }
 
     if (!text.isEmpty()) {
         text.replace(QLatin1Char('\n'), QLatin1Char('\r'));
         if (bracketedPasteMode()) {
             text.remove(QLatin1String("\033"));
             text.prepend(QLatin1String("\033[200~"));
             text.append(QLatin1String("\033[201~"));
         }
         // perform paste by simulating keypress events
         QKeyEvent e(QEvent::KeyPress, 0, Qt::NoModifier, text);
         emit keyPressedSignal(&e);
     }
 }
 
 void TerminalDisplay::setAutoCopySelectedText(bool enabled)
 {
     _autoCopySelectedText = enabled;
 }
 
 void TerminalDisplay::setMiddleClickPasteMode(Enum::MiddleClickPasteModeEnum mode)
 {
     _middleClickPasteMode = mode;
 }
 
 void TerminalDisplay::setCopyTextAsHTML(bool enabled)
 {
     _copyTextAsHTML = enabled;
 }
 
 void TerminalDisplay::copyToX11Selection()
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
 
     const QString &text = _screenWindow->selectedText(currentDecodingOptions());
     if (text.isEmpty()) {
         return;
     }
 
     auto mimeData = new QMimeData;
     mimeData->setText(text);
 
     if (_copyTextAsHTML) {
         mimeData->setHtml(_screenWindow->selectedText(currentDecodingOptions() | Screen::ConvertToHtml));
     }
 
     if (QApplication::clipboard()->supportsSelection()) {
         QApplication::clipboard()->setMimeData(mimeData, QClipboard::Selection);
     }
 
     if (_autoCopySelectedText) {
         QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
     }
 }
 
 void TerminalDisplay::copyToClipboard()
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     const QString &text = _screenWindow->selectedText(currentDecodingOptions());
     if (text.isEmpty()) {
         return;
     }
 
     auto mimeData = new QMimeData;
     mimeData->setText(text);
 
     if (_copyTextAsHTML) {
         mimeData->setHtml(_screenWindow->selectedText(currentDecodingOptions() | Screen::ConvertToHtml));
     }
 
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
 }
 
 void TerminalDisplay::pasteFromClipboard(bool appendEnter)
 {
     QString text = QApplication::clipboard()->text(QClipboard::Clipboard);
     doPaste(text, appendEnter);
 }
 
 void TerminalDisplay::pasteFromX11Selection(bool appendEnter)
 {
     if (QApplication::clipboard()->supportsSelection()) {
         QString text = QApplication::clipboard()->text(QClipboard::Selection);
         doPaste(text, appendEnter);
     }
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Input Method                               */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TerminalDisplay::inputMethodEvent(QInputMethodEvent* event)
 {
     if (!event->commitString().isEmpty()) {
         QKeyEvent keyEvent(QEvent::KeyPress, 0, Qt::NoModifier, event->commitString());
         emit keyPressedSignal(&keyEvent);
     }
 
     if (!_readOnly && isCursorOnDisplay()) {
         _inputMethodData.preeditString = event->preeditString();
         update(preeditRect() | _inputMethodData.previousPreeditRect);
     }
     event->accept();
 }
 
 QVariant TerminalDisplay::inputMethodQuery(Qt::InputMethodQuery query) const
 {
     const QPoint cursorPos = cursorPosition();
     switch (query) {
     case Qt::ImMicroFocus:
         return imageToWidget(QRect(cursorPos.x(), cursorPos.y(), 1, 1));
     case Qt::ImFont:
         return font();
     case Qt::ImCursorPosition:
         // return the cursor position within the current line
         return cursorPos.x();
     case Qt::ImSurroundingText: {
         // return the text from the current line
         QString lineText;
         QTextStream stream(&lineText);
         PlainTextDecoder decoder;
         decoder.begin(&stream);
         if (isCursorOnDisplay()) {
             decoder.decodeLine(&_image[loc(0, cursorPos.y())], _usedColumns, LINE_DEFAULT);
         }
         decoder.end();
         return lineText;
     }
     case Qt::ImCurrentSelection:
         return QString();
     default:
         break;
     }
 
     return QVariant();
 }
 
 QRect TerminalDisplay::preeditRect() const
 {
     const int preeditLength = Character::stringWidth(_inputMethodData.preeditString);
 
     if (preeditLength == 0) {
         return {};
     }
     const QRect stringRect(_contentRect.left() + _fontWidth * cursorPosition().x(),
                            _contentRect.top() + _fontHeight * cursorPosition().y(),
                            _fontWidth * preeditLength,
                            _fontHeight);
 
     return stringRect.intersected(_contentRect);
 }
 
 void TerminalDisplay::drawInputMethodPreeditString(QPainter& painter , const QRect& rect)
 {
     if (_inputMethodData.preeditString.isEmpty() || !isCursorOnDisplay()) {
         return;
     }
 
     const QPoint cursorPos = cursorPosition();
 
     bool invertColors = false;
     const QColor background = _colorTable[DEFAULT_BACK_COLOR];
     const QColor foreground = _colorTable[DEFAULT_FORE_COLOR];
     const Character* style = &_image[loc(cursorPos.x(), cursorPos.y())];
 
     drawBackground(painter, rect, background, true);
     drawCursor(painter, rect, foreground, background, invertColors);
     drawCharacters(painter, rect, _inputMethodData.preeditString, style, invertColors);
 
     _inputMethodData.previousPreeditRect = rect;
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Keyboard                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TerminalDisplay::setFlowControlWarningEnabled(bool enable)
 {
     _flowControlWarningEnabled = enable;
 
     // if the dialog is currently visible and the flow control warning has
     // been disabled then hide the dialog
     if (!enable) {
         outputSuspended(false);
     }
 }
 
 void TerminalDisplay::outputSuspended(bool suspended)
 {
     //create the label when this function is first called
     if (_outputSuspendedMessageWidget == nullptr) {
         //This label includes a link to an English language website
         //describing the 'flow control' (Xon/Xoff) feature found in almost
         //all terminal emulators.
         //If there isn't a suitable article available in the target language the link
         //can simply be removed.
         _outputSuspendedMessageWidget = createMessageWidget(i18n("<qt>Output has been "
                                                     "<a href=\"https://en.wikipedia.org/wiki/Software_flow_control\">suspended</a>"
                                                     " by pressing Ctrl+S."
                                                     " Press <b>Ctrl+Q</b> to resume.</qt>"));
 
         connect(_outputSuspendedMessageWidget, &KMessageWidget::linkActivated, this, [](const QString &url) {
             QDesktopServices::openUrl(QUrl(url));
         });
 
         _outputSuspendedMessageWidget->setMessageType(KMessageWidget::Warning);
     }
 
     suspended ? _outputSuspendedMessageWidget->animatedShow() : _outputSuspendedMessageWidget->animatedHide();
 }
 
 void TerminalDisplay::dismissOutputSuspendedMessage()
 {
     outputSuspended(false);
 }
 
 KMessageWidget* TerminalDisplay::createMessageWidget(const QString &text) {
     auto widget = new KMessageWidget(text);
     widget->setWordWrap(true);
     widget->setFocusProxy(this);
     widget->setCursor(Qt::ArrowCursor);
 
     _verticalLayout->insertWidget(1, widget);
     return widget;
 }
 
 void TerminalDisplay::updateReadOnlyState(bool readonly) {
     if (_readOnly == readonly) {
         return;
     }
 
     if (readonly) {
         // Lazy create the readonly messagewidget
         if (_readOnlyMessageWidget == nullptr) {
             _readOnlyMessageWidget = createMessageWidget(i18n("This terminal is read-only."));
             _readOnlyMessageWidget->setIcon(QIcon::fromTheme(QStringLiteral("object-locked")));
         }
     }
 
     if (_readOnlyMessageWidget != nullptr) {
         readonly ? _readOnlyMessageWidget->animatedShow() : _readOnlyMessageWidget->animatedHide();
     }
 
     _readOnly = readonly;
 }
 
 void TerminalDisplay::scrollScreenWindow(enum ScreenWindow::RelativeScrollMode mode, int amount)
 {
     _screenWindow->scrollBy(mode, amount, _scrollFullPage);
     _screenWindow->setTrackOutput(_screenWindow->atEndOfOutput());
     updateLineProperties();
     updateImage();
     viewScrolledByUser();
 }
 
 void TerminalDisplay::keyPressEvent(QKeyEvent* event)
 {
     if ((_urlHintsModifiers != 0u) && event->modifiers() == _urlHintsModifiers) {
         int nHotSpots = _filterChain->hotSpots().count();
         int hintSelected = event->key() - 0x31;
         if (hintSelected >= 0 && hintSelected < 10 && hintSelected < nHotSpots) {
             if (_reverseUrlHints) {
                 hintSelected = nHotSpots - hintSelected - 1;
             }
             _filterChain->hotSpots().at(hintSelected)->activate();
             _showUrlHint = false;
             update();
             return;
         }
 
         if (!_showUrlHint) {
             processFilters();
             _showUrlHint = true;
             update();
         }
     }
 
     _screenWindow->screen()->setCurrentTerminalDisplay(this);
 
     if (!_readOnly) {
         _actSel = 0; // Key stroke implies a screen update, so TerminalDisplay won't
                      // know where the current selection is.
 
         if (_allowBlinkingCursor) {
             _blinkCursorTimer->start();
             if (_cursorBlinking) {
                 // if cursor is blinking(hidden), blink it again to show it
                 blinkCursorEvent();
             }
             Q_ASSERT(!_cursorBlinking);
         }
     }
 
     if (_searchBar->isVisible() && event->key() == Qt::Key_Escape) {
         _sessionController->searchClosed();
     }
 
     emit keyPressedSignal(event);
 
 #ifndef QT_NO_ACCESSIBILITY
     if (!_readOnly) {
         QAccessibleTextCursorEvent textCursorEvent(this, _usedColumns * screenWindow()->screen()->getCursorY() + screenWindow()->screen()->getCursorX());
         QAccessible::updateAccessibility(&textCursorEvent);
     }
 #endif
 
     event->accept();
 }
 
 void TerminalDisplay::keyReleaseEvent(QKeyEvent *event)
 {
     if (_showUrlHint) {
         _showUrlHint = false;
         update();
     }
 
     if (_readOnly) {
         event->accept();
         return;
     }
 
     QWidget::keyReleaseEvent(event);
 }
 
 bool TerminalDisplay::handleShortcutOverrideEvent(QKeyEvent* keyEvent)
 {
     const int modifiers = keyEvent->modifiers();
 
     //  When a possible shortcut combination is pressed,
     //  emit the overrideShortcutCheck() signal to allow the host
     //  to decide whether the terminal should override it or not.
     if (modifiers != Qt::NoModifier) {
         int modifierCount = 0;
         unsigned int currentModifier = Qt::ShiftModifier;
 
         while (currentModifier <= Qt::KeypadModifier) {
             if ((modifiers & currentModifier) != 0u) {
                 modifierCount++;
             }
             currentModifier <<= 1;
         }
         if (modifierCount < 2) {
             bool override = false;
             emit overrideShortcutCheck(keyEvent, override);
             if (override) {
                 keyEvent->accept();
                 return true;
             }
         }
     }
 
     // Override any of the following shortcuts because
     // they are needed by the terminal
     int keyCode = keyEvent->key() | modifiers;
     switch (keyCode) {
         // list is taken from the QLineEdit::event() code
     case Qt::Key_Tab:
     case Qt::Key_Delete:
     case Qt::Key_Home:
     case Qt::Key_End:
     case Qt::Key_Backspace:
     case Qt::Key_Left:
     case Qt::Key_Right:
     case Qt::Key_Slash:
     case Qt::Key_Period:
     case Qt::Key_Space:
         keyEvent->accept();
         return true;
     }
     return false;
 }
 
 bool TerminalDisplay::event(QEvent* event)
 {
     bool eventHandled = false;
     switch (event->type()) {
     case QEvent::ShortcutOverride:
         eventHandled = handleShortcutOverrideEvent(static_cast<QKeyEvent*>(event));
         break;
     case QEvent::PaletteChange:
     case QEvent::ApplicationPaletteChange:
         onColorsChanged();
         break;
     case QEvent::FocusOut:
     case QEvent::FocusIn:
         if(_screenWindow != nullptr) {
             // force a redraw on focusIn, fixes the
             // black screen bug when the view is focused
             // but doesn't redraws.
             _screenWindow->notifyOutputChanged();
         }
         update();
         break;
     default:
         break;
     }
     return eventHandled ? true : QWidget::event(event);
 }
 
 void TerminalDisplay::contextMenuEvent(QContextMenuEvent* event)
 {
     // the logic for the mouse case is within MousePressEvent()
     if (event->reason() != QContextMenuEvent::Mouse) {
         emit configureRequest(mapFromGlobal(QCursor::pos()));
     }
 }
 
 /* --------------------------------------------------------------------- */
 /*                                                                       */
 /*                                  Bell                                 */
 /*                                                                       */
 /* --------------------------------------------------------------------- */
 
 void TerminalDisplay::setBellMode(int mode)
 {
     _bellMode = mode;
 }
 
 int TerminalDisplay::bellMode() const
 {
     return _bellMode;
 }
 
 void TerminalDisplay::bell(const QString& message)
 {
     if (_bellMasked) {
         return;
     }
 
     switch (_bellMode) {
     case Enum::SystemBeepBell:
         KNotification::beep();
         break;
     case Enum::NotifyBell:
         // STABLE API:
         //     Please note that these event names, "BellVisible" and "BellInvisible",
         //     should not change and should be kept stable, because other applications
         //     that use this code via KPart rely on these names for notifications.
         KNotification::event(hasFocus() ? QStringLiteral("BellVisible") : QStringLiteral("BellInvisible"),
                              message, QPixmap(), this);
         break;
     case Enum::VisualBell:
         visualBell();
         break;
     default:
         break;
     }
 
     // limit the rate at which bells can occur.
     // ...mainly for sound effects where rapid bells in sequence
     // produce a horrible noise.
     _bellMasked = true;
     QTimer::singleShot(500, this, [this]() {
         _bellMasked = false;
     });
 }
 
 void TerminalDisplay::visualBell()
 {
     swapFGBGColors();
     QTimer::singleShot(200, this, &Konsole::TerminalDisplay::swapFGBGColors);
 }
 
 void TerminalDisplay::swapFGBGColors()
 {
     // swap the default foreground & background color
     ColorEntry color = _colorTable[DEFAULT_BACK_COLOR];
     _colorTable[DEFAULT_BACK_COLOR] = _colorTable[DEFAULT_FORE_COLOR];
     _colorTable[DEFAULT_FORE_COLOR] = color;
 
     onColorsChanged();
 }
 
 /* --------------------------------------------------------------------- */
 /*                                                                       */
 /* Drag & Drop                                                           */
 /*                                                                       */
 /* --------------------------------------------------------------------- */
 
 void TerminalDisplay::dragEnterEvent(QDragEnterEvent* event)
 {
     // text/plain alone is enough for KDE-apps
     // text/uri-list is for supporting some non-KDE apps, such as thunar
     //   and pcmanfm
     // That also applies in dropEvent()
     const auto mimeData = event->mimeData();
     if ((!_readOnly) && (mimeData != nullptr)
             && (mimeData->hasFormat(QStringLiteral("text/plain"))
                 || mimeData->hasFormat(QStringLiteral("text/uri-list")))) {
         event->acceptProposedAction();
     }
 }
 
 namespace {
 QString extractDroppedText(const QList<QUrl>& urls) {
     QString dropText;
     for (int i = 0 ; i < urls.count() ; i++) {
         KIO::StatJob* job = KIO::mostLocalUrl(urls[i], KIO::HideProgressInfo);
         if (!job->exec()) {
             continue;
         }
 
         const QUrl url = job->mostLocalUrl();
         // in future it may be useful to be able to insert file names with drag-and-drop
         // without quoting them (this only affects paths with spaces in)
         dropText += KShell::quoteArg(url.isLocalFile() ? url.path() : url.url());
 
         // Each filename(including the last) should be followed by one space.
         dropText += QLatin1Char(' ');
     }
     return dropText;
 }
 
 void setupCdToUrlAction(const QString& dropText, const QUrl& url, QList<QAction*>& additionalActions, TerminalDisplay *display) {
     KIO::StatJob* job = KIO::mostLocalUrl(url, KIO::HideProgressInfo);
     if (!job->exec()) {
         return;
     }
 
     const QUrl localUrl = job->mostLocalUrl();
     if (!localUrl.isLocalFile()) {
         return;
     }
 
     const QFileInfo fileInfo(localUrl.path());
     if (!fileInfo.isDir()) {
         return;
     }
 
     QAction* cdAction = new QAction(i18n("Change &Directory To"), display);
     const QByteArray triggerText = QString(QLatin1String(" cd ") + dropText + QLatin1Char('\n')).toLocal8Bit();
     display->connect(cdAction, &QAction::triggered, display,  [display, triggerText]{
         emit display->sendStringToEmu(triggerText);} );
     additionalActions.append(cdAction);
 }
 
 }
 
 void TerminalDisplay::dropEvent(QDropEvent* event)
 {
     if (_readOnly) {
         event->accept();
         return;
     }
 
     const auto mimeData = event->mimeData();
     if (mimeData == nullptr) {
         return;
     }
     auto urls = mimeData->urls();
 
     QString dropText;
     if (!urls.isEmpty()) {
         dropText = extractDroppedText(urls);
 
         // If our target is local we will open a popup - otherwise the fallback kicks
         // in and the URLs will simply be pasted as text.
         if (!_dropUrlsAsText && (_sessionController != nullptr) && _sessionController->url().isLocalFile()) {
             // A standard popup with Copy, Move and Link as options -
             // plus an additional Paste option.
 
             QAction* pasteAction = new QAction(i18n("&Paste Location"), this);
             connect(pasteAction, &QAction::triggered, this, [this, dropText]{ emit sendStringToEmu(dropText.toLocal8Bit());} );
 
             QList<QAction*> additionalActions;
             additionalActions.append(pasteAction);
 
             if (urls.count() == 1) {
                 setupCdToUrlAction(dropText, urls.at(0), additionalActions, this);
             }
 
             QUrl target = QUrl::fromLocalFile(_sessionController->currentDir());
 
             KIO::DropJob* job = KIO::drop(event, target);
             KJobWidgets::setWindow(job, this);
             job->setApplicationActions(additionalActions);
             return;
         }
 
     } else {
         dropText = mimeData->text();
     }
 
     if (mimeData->hasFormat(QStringLiteral("text/plain")) ||
             mimeData->hasFormat(QStringLiteral("text/uri-list"))) {
         emit sendStringToEmu(dropText.toLocal8Bit());
     }
 }
 
 void TerminalDisplay::doDrag()
 {
     const QMimeData *clipboardMimeData = QApplication::clipboard()->mimeData(QClipboard::Selection);
     if (clipboardMimeData == nullptr) {
         return;
     }
     auto mimeData = new QMimeData();
     _dragInfo.state = diDragging;
     _dragInfo.dragObject = new QDrag(this);
     mimeData->setText(clipboardMimeData->text());
     mimeData->setHtml(clipboardMimeData->html());
     _dragInfo.dragObject->setMimeData(mimeData);
     _dragInfo.dragObject->exec(Qt::CopyAction);
 }
 
 void TerminalDisplay::setSessionController(SessionController* controller)
 {
     _sessionController = controller;
     _headerBar->finishHeaderSetup(controller);
 }
 
 SessionController* TerminalDisplay::sessionController()
 {
     return _sessionController;
 }
 
 IncrementalSearchBar *TerminalDisplay::searchBar() const
 {
     return _searchBar;
 }
 
 AutoScrollHandler::AutoScrollHandler(QWidget* parent)
     : QObject(parent)
     , _timerId(0)
 {
     parent->installEventFilter(this);
 }
 void AutoScrollHandler::timerEvent(QTimerEvent* event)
 {
     if (event->timerId() != _timerId) {
         return;
     }
 
     QMouseEvent mouseEvent(QEvent::MouseMove,
                            widget()->mapFromGlobal(QCursor::pos()),
                            Qt::NoButton,
                            Qt::LeftButton,
                            Qt::NoModifier);
 
     QApplication::sendEvent(widget(), &mouseEvent);
 }
 bool AutoScrollHandler::eventFilter(QObject* watched, QEvent* event)
 {
     Q_ASSERT(watched == parent());
     Q_UNUSED(watched);
 
     switch (event->type()) {
     case QEvent::MouseMove: {
         auto* mouseEvent = static_cast<QMouseEvent*>(event);
         bool mouseInWidget = widget()->rect().contains(mouseEvent->pos());
         if (mouseInWidget) {
             if (_timerId != 0) {
                 killTimer(_timerId);
             }
 
             _timerId = 0;
         } else {
             if ((_timerId == 0) && ((mouseEvent->buttons() & Qt::LeftButton) != 0u)) {
                 _timerId = startTimer(100);
             }
         }
 
         break;
     }
     case QEvent::MouseButtonRelease: {
         auto* mouseEvent = static_cast<QMouseEvent*>(event);
         if ((_timerId != 0) && ((mouseEvent->buttons() & ~Qt::LeftButton) != 0u)) {
             killTimer(_timerId);
             _timerId = 0;
         }
         break;
     }
     default:
         break;
     };
 
     return false;
 }
 
 void TerminalDisplay::applyProfile(const Profile::Ptr &profile)
 {
     // load color scheme
     ColorEntry table[TABLE_COLORS];
     _colorScheme = ViewManager::colorSchemeForProfile(profile);
     _colorScheme->getColorTable(table, randomSeed());
     setColorTable(table);
     setOpacity(_colorScheme->opacity());
     setWallpaper(_colorScheme->wallpaper());
 
     // load font
     _antialiasText = profile->antiAliasFonts();
     _boldIntense = profile->boldIntense();
     _useFontLineCharacters = profile->useFontLineCharacters();
     setVTFont(profile->font());
 
     // set scroll-bar position
     setScrollBarPosition(Enum::ScrollBarPositionEnum(profile->property<int>(Profile::ScrollBarPosition)));
     setScrollFullPage(profile->property<bool>(Profile::ScrollFullPage));
 
     // show hint about terminal size after resizing
     _showTerminalSizeHint = profile->showTerminalSizeHint();
     _dimWhenInactive = profile->dimWhenInactive();
 
     // terminal features
     setBlinkingCursorEnabled(profile->blinkingCursorEnabled());
     setBlinkingTextEnabled(profile->blinkingTextEnabled());
     _tripleClickMode = Enum::TripleClickModeEnum(profile->property<int>(Profile::TripleClickMode));
     setAutoCopySelectedText(profile->autoCopySelectedText());
     _ctrlRequiredForDrag = profile->property<bool>(Profile::CtrlRequiredForDrag);
     _dropUrlsAsText = profile->property<bool>(Profile::DropUrlsAsText);
     _bidiEnabled = profile->bidiRenderingEnabled();
     setLineSpacing(uint(profile->lineSpacing()));
     _trimLeadingSpaces = profile->property<bool>(Profile::TrimLeadingSpacesInSelectedText);
     _trimTrailingSpaces = profile->property<bool>(Profile::TrimTrailingSpacesInSelectedText);
     _openLinksByDirectClick = profile->property<bool>(Profile::OpenLinksByDirectClickEnabled);
     _urlHintsModifiers = Qt::KeyboardModifiers(profile->property<int>(Profile::UrlHintsModifiers));
     _reverseUrlHints = profile->property<bool>(Profile::ReverseUrlHints);
     setMiddleClickPasteMode(Enum::MiddleClickPasteModeEnum(profile->property<int>(Profile::MiddleClickPasteMode)));
     setCopyTextAsHTML(profile->property<bool>(Profile::CopyTextAsHTML));
 
     // margin/center
     setMargin(profile->property<int>(Profile::TerminalMargin));
     setCenterContents(profile->property<bool>(Profile::TerminalCenter));
 
     // cursor shape
     setKeyboardCursorShape(Enum::CursorShapeEnum(profile->property<int>(Profile::CursorShape)));
 
     // cursor color
     // an invalid QColor is used to inform the view widget to
     // draw the cursor using the default color( matching the text)
     setKeyboardCursorColor(profile->useCustomCursorColor() ? profile->customCursorColor() : QColor());
 
     // word characters
     setWordCharacters(profile->wordCharacters());
 
     // bell mode
     setBellMode(profile->property<int>(Profile::BellMode));
 
     // mouse wheel zoom
     _mouseWheelZoom = profile->mouseWheelZoomEnabled();
     setAlternateScrolling(profile->property<bool>(Profile::AlternateScrolling));
 }
diff --git a/src/main.cpp b/src/main.cpp
index b477109f..151cdb4d 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,406 +1,405 @@
 /*
     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 "Application.h"
 #include "MainWindow.h"
 #include "config-konsole.h"
 #include "KonsoleSettings.h"
 #include "ViewManager.h"
 #include "ViewContainer.h"
 
 // OS specific
 #include <qplatformdefs.h>
 #include <QApplication>
 #include <QCommandLineParser>
 #include <QProxyStyle>
 #include <QStandardPaths>
 #include <QDir>
 #include <memory>
 
 // KDE
 #include <KAboutData>
 #include <KLocalizedString>
 #include <KCrash>
 #include <Kdelibs4ConfigMigrator>
 #include <Kdelibs4Migration>
 #include <kdbusservice.h>
 
 using Konsole::Application;
 
 // fill the KAboutData structure with information about contributors to Konsole.
 void fillAboutData(KAboutData &aboutData);
 
 // check and report whether this konsole instance should use a new konsole
 // process, or re-use an existing konsole process.
 bool shouldUseNewProcess(int argc, char *argv[]);
 
 // restore sessions saved by KDE.
 void restoreSession(Application &app);
 
 // Workaround for a bug in KDBusService: https://bugs.kde.org/show_bug.cgi?id=355545
 // It calls exit(), but the program can't exit before the QApplication is deleted:
 // https://bugreports.qt.io/browse/QTBUG-48709
 static bool needToDeleteQApplication = false;
 void deleteQApplication()
 {
     if (needToDeleteQApplication) {
         delete qApp;
     }
 }
 
 // This override resolves following problem: since some qt version if
 // XDG_CURRENT_DESKTOP ≠ kde, then pressing and immediately releasing Alt
 // key makes focus get stuck in QMenu.
 // Upstream report: https://bugreports.qt.io/browse/QTBUG-77355
 class MenuStyle : public QProxyStyle {
 public:
     int styleHint(const StyleHint stylehint,
                   const QStyleOption *opt,
                   const QWidget *widget,
                   QStyleHintReturn *returnData) const override {
         return (stylehint == QStyle::SH_MenuBar_AltKeyNavigation)
             ? 0 : QProxyStyle::styleHint(stylehint, opt, widget, returnData);
     }
 };
 
 // ***
 // Entry point into the Konsole terminal application.
 // ***
 extern "C" int Q_DECL_EXPORT kdemain(int argc, char *argv[])
 {
     // enable high dpi support
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps, true);
     QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling, true);
 
     // Check if any of the arguments makes it impossible to re-use an existing process.
     // We need to do this manually and before creating a QApplication, because
     // QApplication takes/removes the Qt specific arguments that are incompatible.
     KDBusService::StartupOption startupOption = KDBusService::Unique;
     if (shouldUseNewProcess(argc, argv)) {
         startupOption = KDBusService::Multiple;
     } else {
         needToDeleteQApplication = true;
     }
 
 #if defined(Q_OS_LINUX) && (QT_VERSION < QT_VERSION_CHECK(5, 11, 2))
     // Workaround for https://bugreports.qt.io/browse/QTBUG-48344
     // See also https://bugs.kde.org/show_bug.cgi?id=230184
     // The Qt glib event loop doesn't let timers deliver events if there are a
     // lot of other events.
     const QByteArray qtUseGLibOld = qgetenv("QT_NO_GLIB");
     qputenv("QT_NO_GLIB", "1");
 #endif
 
     // Allocate QApplication on the heap for the KDBusService workaround
     auto app = std::unique_ptr<QApplication>(new QApplication(argc, argv));
     app->setStyle(new MenuStyle());
 
 #if defined(Q_OS_LINUX) && (QT_VERSION < QT_VERSION_CHECK(5, 11, 2))
     if (qtUseGLibOld.isNull()) {
         qunsetenv("QT_NO_GLIB");
     } else {
         qputenv("QT_NO_GLIB", qtUseGLibOld);
     }
 #endif
 
 #if defined(Q_OS_MACOS)
     // this ensures that Ctrl and Meta are not swapped, so CTRL-C and friends
     // will work correctly in the terminal
     app->setAttribute(Qt::AA_MacDontSwapCtrlAndMeta);
 
     // KDE's menuBar()->isTopLevel() hasn't worked in a while.
     // For now, put menus inside Konsole window; this also make
     // the keyboard shortcut to show menus look reasonable.
     app->setAttribute(Qt::AA_DontUseNativeMenuBar);
 #endif
 
     app->setWindowIcon(QIcon::fromTheme(QStringLiteral("utilities-terminal")));
 
     KLocalizedString::setApplicationDomain("konsole");
 
     KAboutData about(QStringLiteral("konsole"),
                      i18nc("@title", "Konsole"),
                      QStringLiteral(KONSOLE_VERSION),
                      i18nc("@title", "Terminal emulator"),
                      KAboutLicense::GPL_V2,
                      i18nc("@info:credit", "(c) 1997-2019, The Konsole Developers"),
                      QString(),
                      QStringLiteral("https://konsole.kde.org/"));
     fillAboutData(about);
 
     KAboutData::setApplicationData(about);
 
     KCrash::initialize();
 
     QSharedPointer<QCommandLineParser> parser(new QCommandLineParser);
     parser->setApplicationDescription(about.shortDescription());
     parser->addHelpOption();
     parser->addVersionOption();
     about.setupCommandLine(parser.data());
 
     QStringList args = app->arguments();
     QStringList customCommand = Application::getCustomCommand(args);
 
     Application::populateCommandLineParser(parser.data());
 
     parser->process(args);
     about.processCommandLine(parser.data());
 
     // Enable user to force multiple instances, unless a new tab is requested
     if (!Konsole::KonsoleSettings::useSingleInstance()
         && !parser->isSet(QStringLiteral("new-tab"))) {
         startupOption = KDBusService::Multiple;
     } else if (Konsole::KonsoleSettings::useSingleInstance()) {
         startupOption = KDBusService::Unique;
     }
 
     atexit(deleteQApplication);
     // Ensure that we only launch a new instance if we need to
     // If there is already an instance running, we will quit here
     KDBusService dbusService(startupOption | KDBusService::NoExitOnFailure);
 
     needToDeleteQApplication = false;
 
     Kdelibs4ConfigMigrator migrate(QStringLiteral("konsole"));
     migrate.setConfigFiles(QStringList() << QStringLiteral("konsolerc")
                                          << QStringLiteral("konsole.notifyrc"));
     migrate.setUiFiles(QStringList() << QStringLiteral("sessionui.rc") << QStringLiteral("partui.rc") << QStringLiteral("konsoleui.rc"));
 
     if (migrate.migrate()) {
         Kdelibs4Migration dataMigrator;
         const QString sourceBasePath = dataMigrator.saveLocation("data", QStringLiteral("konsole"));
         const QString targetBasePath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QStringLiteral("/konsole/");
         QString targetFilePath;
 
         QDir sourceDir(sourceBasePath);
         QDir targetDir(targetBasePath);
 
         if (sourceDir.exists()) {
             if (!targetDir.exists()) {
                 QDir().mkpath(targetBasePath);
             }
-            QStringList fileNames = sourceDir.entryList(
-                QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks);
-            foreach (const QString &fileName, fileNames) {
+            const QStringList fileNames = sourceDir.entryList(QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks);
+            for (const QString &fileName : fileNames) {
                 targetFilePath = targetBasePath + fileName;
                 if (!QFile::exists(targetFilePath)) {
                     QFile::copy(sourceBasePath + fileName, targetFilePath);
                 }
             }
         }
     }
 
     // If we reach this location, there was no existing copy of Konsole
     // running, so create a new instance.
     Application konsoleApp(parser, customCommand);
 
     // The activateRequested() signal is emitted when a second instance
     // of Konsole is started.
     QObject::connect(&dbusService, &KDBusService::activateRequested, &konsoleApp,
                      &Application::slotActivateRequested);
 
     if (app->isSessionRestored()) {
         restoreSession(konsoleApp);
     } else {
         // Do not finish starting Konsole due to:
         // 1. An argument was given to just printed info
         // 2. An invalid situation occurred
         const bool continueStarting = (konsoleApp.newInstance() != 0);
         if (!continueStarting) {
             return 0;
         }
     }
 
     int ret = app->exec();
     return ret;
 }
 
 bool shouldUseNewProcess(int argc, char *argv[])
 {
     // The "unique process" model of konsole is incompatible with some or all
     // Qt/KDE options. When those incompatible options are given, konsole must
     // use new process
     //
     // TODO: make sure the existing list is OK and add more incompatible options.
 
     // We need to manually parse the arguments because QApplication removes the
     // Qt specific arguments (like --reverse)
     QStringList arguments;
     arguments.reserve(argc);
     for (int i = 0; i < argc; i++) {
         arguments.append(QString::fromLocal8Bit(argv[i]));
     }
 
     // take Qt options into consideration
     QStringList qtProblematicOptions;
     qtProblematicOptions << QStringLiteral("--session")
                          << QStringLiteral("--name")
                          << QStringLiteral("--reverse")
                          << QStringLiteral("--stylesheet")
                          << QStringLiteral("--graphicssystem");
 #if HAVE_X11
     qtProblematicOptions << QStringLiteral("--display")
                          << QStringLiteral("--visual");
 #endif
-    foreach (const QString &option, qtProblematicOptions) {
+    for (const QString &option : qAsConst(qtProblematicOptions)) {
         if (arguments.contains(option)) {
             return true;
         }
     }
 
     // take KDE options into consideration
     QStringList kdeProblematicOptions;
     kdeProblematicOptions << QStringLiteral("--config")
                           << QStringLiteral("--style");
 #if HAVE_X11
     kdeProblematicOptions << QStringLiteral("--waitforwm");
 #endif
 
-    foreach (const QString &option, kdeProblematicOptions) {
+    for (const QString &option : qAsConst(kdeProblematicOptions)) {
         if (arguments.contains(option)) {
             return true;
         }
     }
 
     // if users have explictly requested starting a new process
     // Support --nofork to retain argument compatibility with older
     // versions.
     if (arguments.contains(QLatin1String("--separate"))
         || arguments.contains(QLatin1String("--nofork"))) {
         return true;
     }
 
     // the only way to create new tab is to reuse existing Konsole process.
     if (arguments.contains(QLatin1String("--new-tab"))) {
         return false;
     }
 
     // when starting Konsole from a terminal, a new process must be used
     // so that the current environment is propagated into the shells of the new
     // Konsole and any debug output or warnings from Konsole are written to
     // the current terminal
     bool hasControllingTTY = false;
     const int fd = QT_OPEN("/dev/tty", O_RDONLY);
     if (fd != -1) {
         hasControllingTTY = true;
         close(fd);
     }
 
     return hasControllingTTY;
 }
 
 void fillAboutData(KAboutData &aboutData)
 {
     aboutData.setOrganizationDomain("kde.org");
 
     aboutData.addAuthor(i18nc("@info:credit", "Kurt Hindenburg"),
                         i18nc("@info:credit", "General maintainer, bug fixes and general"
                                               " improvements"),
                         QStringLiteral("kurt.hindenburg@gmail.com"));
     aboutData.addAuthor(i18nc("@info:credit", "Robert Knight"),
                         i18nc("@info:credit", "Previous maintainer, ported to KDE4"),
                         QStringLiteral("robertknight@gmail.com"));
     aboutData.addAuthor(i18nc("@info:credit", "Lars Doelle"),
                         i18nc("@info:credit", "Original author"),
                         QStringLiteral("lars.doelle@on-line.de"));
     aboutData.addCredit(i18nc("@info:credit", "Jekyll Wu"),
                         i18nc("@info:credit", "Bug fixes and general improvements"),
                         QStringLiteral("adaptee@gmail.com"));
     aboutData.addCredit(i18nc("@info:credit", "Waldo Bastian"),
                         i18nc("@info:credit", "Bug fixes and general improvements"),
                         QStringLiteral("bastian@kde.org"));
     aboutData.addCredit(i18nc("@info:credit", "Stephan Binner"),
                         i18nc("@info:credit", "Bug fixes and general improvements"),
                         QStringLiteral("binner@kde.org"));
     aboutData.addCredit(i18nc("@info:credit", "Thomas Dreibholz"),
                         i18nc("@info:credit", "General improvements"),
                         QStringLiteral("dreibh@iem.uni-due.de"));
     aboutData.addCredit(i18nc("@info:credit", "Chris Machemer"),
                         i18nc("@info:credit", "Bug fixes"),
                         QStringLiteral("machey@ceinetworks.com"));
     aboutData.addCredit(i18nc("@info:credit", "Francesco Cecconi"),
                         i18nc("@info:credit", "Bug fixes"),
                         QStringLiteral("francesco.cecconi@gmail.com"));
     aboutData.addCredit(i18nc("@info:credit", "Stephan Kulow"),
                         i18nc("@info:credit", "Solaris support and history"),
                         QStringLiteral("coolo@kde.org"));
     aboutData.addCredit(i18nc("@info:credit", "Alexander Neundorf"),
                         i18nc("@info:credit", "Bug fixes and improved startup performance"),
                         QStringLiteral("neundorf@kde.org"));
     aboutData.addCredit(i18nc("@info:credit", "Peter Silva"),
                         i18nc("@info:credit", "Marking improvements"),
                         QStringLiteral("Peter.A.Silva@gmail.com"));
     aboutData.addCredit(i18nc("@info:credit", "Lotzi Boloni"),
                         i18nc("@info:credit", "Embedded Konsole\n"
                                               "Toolbar and session names"),
                         QStringLiteral("boloni@cs.purdue.edu"));
     aboutData.addCredit(i18nc("@info:credit", "David Faure"),
                         i18nc("@info:credit", "Embedded Konsole\n"
                                               "General improvements"),
                         QStringLiteral("faure@kde.org"));
     aboutData.addCredit(i18nc("@info:credit", "Antonio Larrosa"),
                         i18nc("@info:credit", "Visual effects"),
                         QStringLiteral("larrosa@kde.org"));
     aboutData.addCredit(i18nc("@info:credit", "Matthias Ettrich"),
                         i18nc("@info:credit", "Code from the kvt project\n"
                                               "General improvements"),
                         QStringLiteral("ettrich@kde.org"));
     aboutData.addCredit(i18nc("@info:credit", "Warwick Allison"),
                         i18nc("@info:credit", "Schema and text selection improvements"),
                         QStringLiteral("warwick@troll.no"));
     aboutData.addCredit(i18nc("@info:credit", "Dan Pilone"),
                         i18nc("@info:credit", "SGI port"),
                         QStringLiteral("pilone@slac.com"));
     aboutData.addCredit(i18nc("@info:credit", "Kevin Street"),
                         i18nc("@info:credit", "FreeBSD port"),
                         QStringLiteral("street@iname.com"));
     aboutData.addCredit(i18nc("@info:credit", "Sven Fischer"),
                         i18nc("@info:credit", "Bug fixes"),
                         QStringLiteral("herpes@kawo2.renditionwth-aachen.de"));
     aboutData.addCredit(i18nc("@info:credit", "Dale M. Flaven"),
                         i18nc("@info:credit", "Bug fixes"),
                         QStringLiteral("dflaven@netport.com"));
     aboutData.addCredit(i18nc("@info:credit", "Martin Jones"),
                         i18nc("@info:credit", "Bug fixes"),
                         QStringLiteral("mjones@powerup.com.au"));
     aboutData.addCredit(i18nc("@info:credit", "Lars Knoll"),
                         i18nc("@info:credit", "Bug fixes"),
                         QStringLiteral("knoll@mpi-hd.mpg.de"));
     aboutData.addCredit(i18nc("@info:credit", "Thanks to many others.\n"));
 }
 
 void restoreSession(Application &app)
 {
     int n = 1;
 
     while (KMainWindow::canBeRestored(n)) {
         auto mainWindow = app.newMainWindow();
         mainWindow->restore(n++);
         mainWindow->viewManager()->toggleActionsBasedOnState();
         mainWindow->show();
 
         // TODO: HACK without the code below the sessions would be `uninitialized`
         // and the tabs wouldn't display the correct information.
         auto tabbedContainer = qobject_cast<Konsole::TabbedViewContainer*>(mainWindow->centralWidget());
         for(int i = 0; i < tabbedContainer->count(); i++) {
             tabbedContainer->setCurrentIndex(i);
         }
     }
 }