diff --git a/src/EditProfileDialog.cpp b/src/EditProfileDialog.cpp
index 4fa773d3..7485f350 100644
--- a/src/EditProfileDialog.cpp
+++ b/src/EditProfileDialog.cpp
@@ -1,1953 +1,1953 @@
 /*
     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;
 
     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_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(QStringLiteral("\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());
     _appearanceUi->customTextColorSelectButton->setColor(profile->customCursorTextColor());
 
     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);
     connect(_appearanceUi->customTextColorSelectButton, &KColorButton::changed, this, &Konsole::EditProfileDialog::customCursorTextColorChanged);
 
     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::customCursorTextColorChanged(const QColor &color)
 {
     preview(Profile::CustomCursorTextColor, color);
     updateTempProfileProperty(Profile::CustomCursorTextColor, 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;
 
    const QList<const ColorScheme *> schemeList = ColorSchemeManager::instance()->allColorSchemes();
 
     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
     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/LineBlockCharacters.cpp b/src/LineBlockCharacters.cpp
index c95504a9..23e9b121 100644
--- a/src/LineBlockCharacters.cpp
+++ b/src/LineBlockCharacters.cpp
@@ -1,723 +1,723 @@
 /*
     This file is part of Konsole, a terminal emulator for KDE.
 
     Copyright 2018-2019 by Mariusz Glebocki <mglb@arccos-1.net>
     Copyright 2018 by Martin T. H. Sandsmark <martin.sandsmark@kde.org>
     Copyright 2015-2018 by Kurt Hindenburg <kurt.hindenburg@gmail.com>
     Copyright 2005 by Maksim Orlovich <maksim@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 "LineBlockCharacters.h"
 
 // Qt
 #include <QPainter>
 #include <QPainterPath>
 
 namespace Konsole {
 namespace LineBlockCharacters {
 
 enum LineType {
     LtNone   = 0,
     LtDouble = 1,
     LtLight  = 2,
     LtHeavy  = 3
 };
 
 // PackedLineTypes is an 8-bit number representing types of 4 line character's lines. Each line is
 // represented by 2 bits. Lines order, starting from MSB: top, right, bottom, left.
 static inline constexpr quint8 makePackedLineTypes(LineType top, LineType right, LineType bottom, LineType left)
 {
     return (int(top) & 3) << 6 | (int(right) & 3) << 4 | (int(bottom) & 3) << 2 | (int(left) & 3);
 }
 
 static constexpr const quint8 PackedLineTypesLut[] = {
     //                  top       right     bottom    left
     makePackedLineTypes(LtNone  , LtLight , LtNone  , LtLight ), /* U+2500 ─ */
     makePackedLineTypes(LtNone  , LtHeavy , LtNone  , LtHeavy ), /* U+2501 ━ */
     makePackedLineTypes(LtLight , LtNone  , LtLight , LtNone  ), /* U+2502 │ */
     makePackedLineTypes(LtHeavy , LtNone  , LtHeavy , LtNone  ), /* U+2503 ┃ */
     0, 0, 0, 0, 0, 0, 0, 0, /* U+2504-0x250b */
     makePackedLineTypes(LtNone  , LtLight , LtLight , LtNone  ), /* U+250C ┌ */
     makePackedLineTypes(LtNone  , LtHeavy , LtLight , LtNone  ), /* U+250D ┍ */
     makePackedLineTypes(LtNone  , LtLight , LtHeavy , LtNone  ), /* U+250E ┎ */
     makePackedLineTypes(LtNone  , LtHeavy , LtHeavy , LtNone  ), /* U+250F ┏ */
     makePackedLineTypes(LtNone  , LtNone  , LtLight , LtLight ), /* U+2510 ┐ */
     makePackedLineTypes(LtNone  , LtNone  , LtLight , LtHeavy ), /* U+2511 ┑ */
     makePackedLineTypes(LtNone  , LtNone  , LtHeavy , LtLight ), /* U+2512 ┒ */
     makePackedLineTypes(LtNone  , LtNone  , LtHeavy , LtHeavy ), /* U+2513 ┓ */
     makePackedLineTypes(LtLight , LtLight , LtNone  , LtNone  ), /* U+2514 └ */
     makePackedLineTypes(LtLight , LtHeavy , LtNone  , LtNone  ), /* U+2515 ┕ */
     makePackedLineTypes(LtHeavy , LtLight , LtNone  , LtNone  ), /* U+2516 ┖ */
     makePackedLineTypes(LtHeavy , LtHeavy , LtNone  , LtNone  ), /* U+2517 ┗ */
     makePackedLineTypes(LtLight , LtNone  , LtNone  , LtLight ), /* U+2518 ┘ */
     makePackedLineTypes(LtLight , LtNone  , LtNone  , LtHeavy ), /* U+2519 ┙ */
     makePackedLineTypes(LtHeavy , LtNone  , LtNone  , LtLight ), /* U+251A ┚ */
     makePackedLineTypes(LtHeavy , LtNone  , LtNone  , LtHeavy ), /* U+251B ┛ */
     makePackedLineTypes(LtLight , LtLight , LtLight , LtNone  ), /* U+251C ├ */
     makePackedLineTypes(LtLight , LtHeavy , LtLight , LtNone  ), /* U+251D ┝ */
     makePackedLineTypes(LtHeavy , LtLight , LtLight , LtNone  ), /* U+251E ┞ */
     makePackedLineTypes(LtLight , LtLight , LtHeavy , LtNone  ), /* U+251F ┟ */
     makePackedLineTypes(LtHeavy , LtLight , LtHeavy , LtNone  ), /* U+2520 ┠ */
     makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtNone  ), /* U+2521 ┡ */
     makePackedLineTypes(LtLight , LtHeavy , LtHeavy , LtNone  ), /* U+2522 ┢ */
     makePackedLineTypes(LtHeavy , LtHeavy , LtHeavy , LtNone  ), /* U+2523 ┣ */
     makePackedLineTypes(LtLight , LtNone  , LtLight , LtLight ), /* U+2524 ┤ */
     makePackedLineTypes(LtLight , LtNone  , LtLight , LtHeavy ), /* U+2525 ┥ */
     makePackedLineTypes(LtHeavy , LtNone  , LtLight , LtLight ), /* U+2526 ┦ */
     makePackedLineTypes(LtLight , LtNone  , LtHeavy , LtLight ), /* U+2527 ┧ */
     makePackedLineTypes(LtHeavy , LtNone  , LtHeavy , LtLight ), /* U+2528 ┨ */
     makePackedLineTypes(LtHeavy , LtNone  , LtLight , LtHeavy ), /* U+2529 ┩ */
     makePackedLineTypes(LtLight , LtNone  , LtHeavy , LtHeavy ), /* U+252A ┪ */
     makePackedLineTypes(LtHeavy , LtNone  , LtHeavy , LtHeavy ), /* U+252B ┫ */
     makePackedLineTypes(LtNone  , LtLight , LtLight , LtLight ), /* U+252C ┬ */
     makePackedLineTypes(LtNone  , LtLight , LtLight , LtHeavy ), /* U+252D ┭ */
     makePackedLineTypes(LtNone  , LtHeavy , LtLight , LtLight ), /* U+252E ┮ */
     makePackedLineTypes(LtNone  , LtHeavy , LtLight , LtHeavy ), /* U+252F ┯ */
     makePackedLineTypes(LtNone  , LtLight , LtHeavy , LtLight ), /* U+2530 ┰ */
     makePackedLineTypes(LtNone  , LtLight , LtHeavy , LtHeavy ), /* U+2531 ┱ */
     makePackedLineTypes(LtNone  , LtHeavy , LtHeavy , LtLight ), /* U+2532 ┲ */
     makePackedLineTypes(LtNone  , LtHeavy , LtHeavy , LtHeavy ), /* U+2533 ┳ */
     makePackedLineTypes(LtLight , LtLight , LtNone  , LtLight ), /* U+2534 ┴ */
     makePackedLineTypes(LtLight , LtLight , LtNone  , LtHeavy ), /* U+2535 ┵ */
     makePackedLineTypes(LtLight , LtHeavy , LtNone  , LtLight ), /* U+2536 ┶ */
     makePackedLineTypes(LtLight , LtHeavy , LtNone  , LtHeavy ), /* U+2537 ┷ */
     makePackedLineTypes(LtHeavy , LtLight , LtNone  , LtLight ), /* U+2538 ┸ */
     makePackedLineTypes(LtHeavy , LtLight , LtNone  , LtHeavy ), /* U+2539 ┹ */
     makePackedLineTypes(LtHeavy , LtHeavy , LtNone  , LtLight ), /* U+253A ┺ */
     makePackedLineTypes(LtHeavy , LtHeavy , LtNone  , LtHeavy ), /* U+253B ┻ */
     makePackedLineTypes(LtLight , LtLight , LtLight , LtLight ), /* U+253C ┼ */
     makePackedLineTypes(LtLight , LtLight , LtLight , LtHeavy ), /* U+253D ┽ */
     makePackedLineTypes(LtLight , LtHeavy , LtLight , LtLight ), /* U+253E ┾ */
     makePackedLineTypes(LtLight , LtHeavy , LtLight , LtHeavy ), /* U+253F ┿ */
     makePackedLineTypes(LtHeavy , LtLight , LtLight , LtLight ), /* U+2540 ╀ */
     makePackedLineTypes(LtLight , LtLight , LtHeavy , LtLight ), /* U+2541 ╁ */
     makePackedLineTypes(LtHeavy , LtLight , LtHeavy , LtLight ), /* U+2542 ╂ */
     makePackedLineTypes(LtHeavy , LtLight , LtLight , LtHeavy ), /* U+2543 ╃ */
     makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtLight ), /* U+2544 ╄ */
     makePackedLineTypes(LtLight , LtLight , LtHeavy , LtHeavy ), /* U+2545 ╅ */
     makePackedLineTypes(LtLight , LtHeavy , LtHeavy , LtLight ), /* U+2546 ╆ */
     makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtHeavy ), /* U+2547 ╇ */
     makePackedLineTypes(LtLight , LtHeavy , LtHeavy , LtHeavy ), /* U+2548 ╈ */
     makePackedLineTypes(LtHeavy , LtLight , LtHeavy , LtHeavy ), /* U+2549 ╉ */
     makePackedLineTypes(LtHeavy , LtHeavy , LtHeavy , LtLight ), /* U+254A ╊ */
     makePackedLineTypes(LtHeavy , LtHeavy , LtHeavy , LtHeavy ), /* U+254B ╋ */
     0, 0, 0, 0, /* U+254C - U+254F */
     makePackedLineTypes(LtNone  , LtDouble, LtNone  , LtDouble), /* U+2550 ═ */
     makePackedLineTypes(LtDouble, LtNone  , LtDouble, LtNone  ), /* U+2551 ║ */
     makePackedLineTypes(LtNone  , LtDouble, LtLight , LtNone  ), /* U+2552 ╒ */
     makePackedLineTypes(LtNone  , LtLight , LtDouble, LtNone  ), /* U+2553 ╓ */
     makePackedLineTypes(LtNone  , LtDouble, LtDouble, LtNone  ), /* U+2554 ╔ */
     makePackedLineTypes(LtNone  , LtNone  , LtLight , LtDouble), /* U+2555 ╕ */
     makePackedLineTypes(LtNone  , LtNone  , LtDouble, LtLight ), /* U+2556 ╖ */
     makePackedLineTypes(LtNone  , LtNone  , LtDouble, LtDouble), /* U+2557 ╗ */
     makePackedLineTypes(LtLight , LtDouble, LtNone  , LtNone  ), /* U+2558 ╘ */
     makePackedLineTypes(LtDouble, LtLight , LtNone  , LtNone  ), /* U+2559 ╙ */
     makePackedLineTypes(LtDouble, LtDouble, LtNone  , LtNone  ), /* U+255A ╚ */
     makePackedLineTypes(LtLight , LtNone  , LtNone  , LtDouble), /* U+255B ╛ */
     makePackedLineTypes(LtDouble, LtNone  , LtNone  , LtLight ), /* U+255C ╜ */
     makePackedLineTypes(LtDouble, LtNone  , LtNone  , LtDouble), /* U+255D ╝ */
     makePackedLineTypes(LtLight , LtDouble, LtLight , LtNone  ), /* U+255E ╞ */
     makePackedLineTypes(LtDouble, LtLight , LtDouble, LtNone  ), /* U+255F ╟ */
     makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtNone  ), /* U+2560 ╠ */
     makePackedLineTypes(LtLight , LtNone  , LtLight , LtDouble), /* U+2561 ╡ */
     makePackedLineTypes(LtDouble, LtNone  , LtDouble, LtLight ), /* U+2562 ╢ */
     makePackedLineTypes(LtDouble, LtNone  , LtDouble, LtDouble), /* U+2563 ╣ */
     makePackedLineTypes(LtNone  , LtDouble, LtLight , LtDouble), /* U+2564 ╤ */
     makePackedLineTypes(LtNone  , LtLight , LtDouble, LtLight ), /* U+2565 ╥ */
     makePackedLineTypes(LtNone  , LtDouble, LtDouble, LtDouble), /* U+2566 ╦ */
     makePackedLineTypes(LtLight , LtDouble, LtNone  , LtDouble), /* U+2567 ╧ */
     makePackedLineTypes(LtDouble, LtLight , LtNone  , LtLight ), /* U+2568 ╨ */
     makePackedLineTypes(LtDouble, LtDouble, LtNone  , LtDouble), /* U+2569 ╩ */
     makePackedLineTypes(LtLight , LtDouble, LtLight , LtDouble), /* U+256A ╪ */
     makePackedLineTypes(LtDouble, LtLight , LtDouble, LtLight ), /* U+256B ╫ */
     makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtDouble), /* U+256C ╬ */
     0, 0, 0, 0, 0, 0, 0, /* U+256D - U+2573 */
     makePackedLineTypes(LtNone  , LtNone  , LtNone  , LtLight ), /* U+2574 ╴ */
     makePackedLineTypes(LtLight , LtNone  , LtNone  , LtNone  ), /* U+2575 ╵ */
     makePackedLineTypes(LtNone  , LtLight , LtNone  , LtNone  ), /* U+2576 ╶ */
     makePackedLineTypes(LtNone  , LtNone  , LtLight , LtNone  ), /* U+2577 ╷ */
     makePackedLineTypes(LtNone  , LtNone  , LtNone  , LtHeavy ), /* U+2578 ╸ */
     makePackedLineTypes(LtHeavy , LtNone  , LtNone  , LtNone  ), /* U+2579 ╹ */
     makePackedLineTypes(LtNone  , LtHeavy , LtNone  , LtNone  ), /* U+257A ╺ */
     makePackedLineTypes(LtNone  , LtNone  , LtHeavy , LtNone  ), /* U+257B ╻ */
     makePackedLineTypes(LtNone  , LtHeavy , LtNone  , LtLight ), /* U+257C ╼ */
     makePackedLineTypes(LtLight , LtNone  , LtHeavy , LtNone  ), /* U+257D ╽ */
     makePackedLineTypes(LtNone  , LtLight , LtNone  , LtHeavy ), /* U+257E ╾ */
     makePackedLineTypes(LtHeavy , LtNone  , LtLight , LtNone  ), /* U+257F ╿ */
 };
 
 
 
 // Bitwise rotate left
 template <typename T>
 inline static T rotateBitsLeft(T value, quint8 amount)
 {
     static_assert (std::is_unsigned<T>(), "T must be unsigned type");
     Q_ASSERT(amount < sizeof(value) * 8);
     return value << amount | value >> (sizeof(value) * 8 - amount);
 }
 
 inline static const QPen pen(const QPainter &paint, uint lineWidth)
 {
     return QPen(paint.pen().brush(), lineWidth, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
 }
 
 
 
 static inline uint lineWidth(uint fontWidth, bool heavy, bool bold)
 {
     static const qreal LightWidthToFontWidthRatio = 1.0 / 6.5;
     static const qreal HeavyHalfExtraToLightRatio = 1.0 / 3.0;
     static const qreal BoldCoefficient            = 1.5;
 
     //        ▄▄▄▄▄▄▄ } heavyHalfExtraWidth  ⎫
     // ██████████████ } lightWidth           ⎬ heavyWidth
     //        ▀▀▀▀▀▀▀                        ⎭
     //  light  heavy
 
     const qreal baseWidth           = fontWidth * LightWidthToFontWidthRatio;
     const qreal boldCoeff           = bold ? BoldCoefficient : 1.0;
     // Unless font size is too small, make bold lines at least 1px wider than regular lines
     const qreal minWidth            = bold && fontWidth >= 7 ? baseWidth + 1.0 : 1.0;
     const uint  lightWidth          = qRound(qMax(baseWidth * boldCoeff, minWidth));
     const uint  heavyHalfExtraWidth = qRound(qMax(lightWidth * HeavyHalfExtraToLightRatio, 1.0));
 
     return heavy ? lightWidth + 2 * heavyHalfExtraWidth : lightWidth;
 }
 
 // Draws characters composed of straight solid lines
 static bool drawBasicLineCharacter(QPainter& paint, int x, int y, int w, int h, uchar code,
                                    bool bold)
 {
     quint8 packedLineTypes = code >= sizeof(PackedLineTypesLut) ? 0 : PackedLineTypesLut[code];
     if (packedLineTypes == 0) {
         return false;
     }
 
     const uint lightLineWidth      = lineWidth(w, false, bold);
     const uint heavyLineWidth      = lineWidth(w, true, bold);
     // Distance from double line's parallel axis to each line's parallel axis
     const uint doubleLinesDistance = lightLineWidth;
 
     const QPen lightPen = pen(paint, lightLineWidth);
     const QPen heavyPen = pen(paint, heavyLineWidth);
 
     static constexpr const unsigned LinesNum = 4;
 
     // Pixel aligned center point
     const QPointF center = {
         x + int(w/2) + 0.5 * (lightLineWidth % 2),
         y + int(h/2) + 0.5 * (lightLineWidth % 2),
     };
 
     // Lines starting points, on the cell edges
     const QPointF origin[] = {
         QPointF(center.x(), y             ),
         QPointF(x+w       , center.y()    ),
         QPointF(center.x(), y+h           ),
         QPointF(x         , center.y()    ),
     };
     // Unit vectors with directions from center to the line's origin point
     static const QPointF dir[] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
 
     const auto removeLineType = [&packedLineTypes](quint8 lineId)->void {
         lineId = LinesNum - 1 - lineId % LinesNum;
         packedLineTypes &= ~(3 << (2 * lineId));
     };
     const auto getLineType = [&packedLineTypes](quint8 lineId)->LineType {
         lineId = LinesNum - 1 - lineId % LinesNum;
         return LineType(packedLineTypes >> 2 * lineId & 3);
     };
 
     QPainterPath lightPath; // PainterPath for light lines (Painter Path Light)
     QPainterPath heavyPath; // PainterPath for heavy lines (Painter Path Heavy)
     // Returns ppl or pph depending on line type
     const auto pathForLine = [&](quint8 lineId) -> QPainterPath& {
         Q_ASSERT(getLineType(lineId) != LtNone);
         return getLineType(lineId) == LtHeavy ? heavyPath : lightPath;
     };
 
     // Process all single up-down/left-right lines for every character that has them. Doing it here
     // reduces amount of combinations below.
     // Fully draws: ╋ ╂ ┃ ┿ ┼ │ ━ ─
     for (unsigned int topIndex = 0; topIndex < LinesNum/2; topIndex++) {
         unsigned iB = (topIndex + 2) % LinesNum;
         const bool isSingleLine = (getLineType(topIndex) == LtLight
                                 || getLineType(topIndex) == LtHeavy);
         if (isSingleLine && getLineType(topIndex) == getLineType(iB)) {
             pathForLine(topIndex).moveTo(origin[topIndex]);
             pathForLine(topIndex).lineTo(origin[iB]);
             removeLineType(topIndex);
             removeLineType(iB);
         }
     }
 
     // Find base rotation of a character and map rotated line indices to the original rotation's
     // indices. The base rotation is defined as the one with largest packedLineTypes value. This way
     // we can use the same code for drawing 4 possible character rotations (see switch() below)
 
     uint topIndex = 0; // index of an original top line in a base rotation
     quint8 basePackedLineTypes = packedLineTypes;
     for (uint i = 0; i < LinesNum; i++) {
         const quint8 rotatedPackedLineTypes = rotateBitsLeft(packedLineTypes, i * 2);
         if (rotatedPackedLineTypes > basePackedLineTypes) {
             topIndex = i;
             basePackedLineTypes = rotatedPackedLineTypes;
         }
     }
     uint rightIndex  = (topIndex + 1) % LinesNum;
     uint bottomIndex = (topIndex + 2) % LinesNum;
     uint leftIndex   = (topIndex + 3) % LinesNum;
 
     // Common paths
     const auto drawDoubleUpRightShorterLine = [&](quint8 top, quint8 right) { // ╚
         lightPath.moveTo(origin[top] + dir[right] * doubleLinesDistance);
         lightPath.lineTo(center + (dir[right] + dir[top]) * doubleLinesDistance);
         lightPath.lineTo(origin[right] + dir[top] * doubleLinesDistance);
     };
     const auto drawUpRight = [&](quint8 top, quint8 right) { // └┗
         pathForLine(top).moveTo(origin[top]);
         pathForLine(top).lineTo(center);
         pathForLine(top).lineTo(origin[right]);
     };
 
     switch (basePackedLineTypes) {
     case makePackedLineTypes(LtHeavy , LtNone  , LtLight , LtNone  ): // ╿ ; ╼ ╽ ╾ ╊ ╇ ╉ ╈ ╀ ┾ ╁ ┽
         lightPath.moveTo(origin[bottomIndex]);
         lightPath.lineTo(center + dir[topIndex] * lightLineWidth / 2.0);
         Q_FALLTHROUGH();
     case makePackedLineTypes(LtHeavy , LtNone  , LtNone  , LtNone  ): // ╹ ; ╺ ╻ ╸ ┻ ┣ ┳ ┫ ┸ ┝ ┰ ┥
     case makePackedLineTypes(LtLight , LtNone  , LtNone  , LtNone  ): // ╵ ; ╶ ╷ ╴ ┷ ┠ ┯ ┨ ┴ ├ ┬ ┤
         pathForLine(topIndex).moveTo(origin[topIndex]);
         pathForLine(topIndex).lineTo(center);
         break;
 
     case makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtLight ): // ╄ ; ╃ ╆ ╅
         drawUpRight(bottomIndex, leftIndex);
         Q_FALLTHROUGH();
     case makePackedLineTypes(LtHeavy , LtHeavy , LtNone  , LtNone  ): // ┗ ; ┛ ┏ ┓
     case makePackedLineTypes(LtLight , LtLight , LtNone  , LtNone  ): // └ ; ┘ ┌ ┐
         drawUpRight(topIndex, rightIndex);
         break;
 
     case makePackedLineTypes(LtHeavy , LtLight , LtNone  , LtNone  ): // ┖ ; ┙ ┍ ┒
         qSwap(leftIndex, rightIndex);
         Q_FALLTHROUGH();
     case makePackedLineTypes(LtHeavy , LtNone  , LtNone  , LtLight ): // ┚ ; ┕ ┎ ┑
         lightPath.moveTo(origin[leftIndex]);
         lightPath.lineTo(center);
         heavyPath.moveTo(origin[topIndex]);
         heavyPath.lineTo(center + dir[bottomIndex] * lightLineWidth / 2.0);
         break;
 
     case makePackedLineTypes(LtLight , LtDouble, LtNone  , LtNone  ): // ╘ ; ╜ ╓ ╕
         qSwap(leftIndex, rightIndex);
         Q_FALLTHROUGH();
     case makePackedLineTypes(LtLight , LtNone  , LtNone  , LtDouble): // ╛ ; ╙ ╒ ╖
         lightPath.moveTo(origin[topIndex]);
         lightPath.lineTo(center + dir[bottomIndex] * doubleLinesDistance);
         lightPath.lineTo(origin[leftIndex] + dir[bottomIndex] * doubleLinesDistance);
         lightPath.moveTo(origin[leftIndex] - dir[bottomIndex] * doubleLinesDistance);
         lightPath.lineTo(center - dir[bottomIndex] * doubleLinesDistance);
         break;
 
     case makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtNone  ): // ┡ ; ┹ ┪ ┲
         qSwap(leftIndex, bottomIndex);
         qSwap(rightIndex, topIndex);
         Q_FALLTHROUGH();
     case makePackedLineTypes(LtHeavy , LtHeavy , LtNone  , LtLight ): // ┺ ; ┩ ┢ ┱
         drawUpRight(topIndex, rightIndex);
         lightPath.moveTo(origin[leftIndex]);
         lightPath.lineTo(center);
         break;
 
     case makePackedLineTypes(LtHeavy , LtLight , LtLight , LtNone  ): // ┞ ; ┵ ┧ ┮
         qSwap(leftIndex, rightIndex);
         Q_FALLTHROUGH();
     case makePackedLineTypes(LtHeavy , LtNone  , LtLight , LtLight ): // ┦ ; ┶ ┟ ┭
         heavyPath.moveTo(origin[topIndex]);
         heavyPath.lineTo(center + dir[bottomIndex] * lightLineWidth / 2.0);
         drawUpRight(bottomIndex, leftIndex);
         break;
 
     case makePackedLineTypes(LtLight , LtDouble, LtNone  , LtDouble): // ╧ ; ╟ ╢ ╤
         lightPath.moveTo(origin[topIndex]);
         lightPath.lineTo(center - dir[bottomIndex] * doubleLinesDistance);
         qSwap(leftIndex, bottomIndex);
         qSwap(rightIndex, topIndex);
         Q_FALLTHROUGH();
     case makePackedLineTypes(LtDouble, LtNone  , LtDouble, LtNone  ): // ║ ; ╫ ═ ╪
         lightPath.moveTo(origin[topIndex] + dir[leftIndex] * doubleLinesDistance);
         lightPath.lineTo(origin[bottomIndex] + dir[leftIndex] * doubleLinesDistance);
         lightPath.moveTo(origin[topIndex] + dir[rightIndex] * doubleLinesDistance);
         lightPath.lineTo(origin[bottomIndex] + dir[rightIndex] * doubleLinesDistance);
         break;
 
     case makePackedLineTypes(LtDouble, LtNone  , LtNone  , LtNone  ): // ╨ ; ╞ ╥ ╡
         lightPath.moveTo(origin[topIndex] + dir[leftIndex] * doubleLinesDistance);
         lightPath.lineTo(center + dir[leftIndex] * doubleLinesDistance);
         lightPath.moveTo(origin[topIndex] + dir[rightIndex] * doubleLinesDistance);
         lightPath.lineTo(center + dir[rightIndex] * doubleLinesDistance);
         break;
 
     case makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtDouble): // ╬
         drawDoubleUpRightShorterLine(topIndex, rightIndex);
         drawDoubleUpRightShorterLine(bottomIndex, rightIndex);
         drawDoubleUpRightShorterLine(topIndex, leftIndex);
         drawDoubleUpRightShorterLine(bottomIndex, leftIndex);
         break;
 
     case makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtNone  ): // ╠ ; ╩ ╣ ╦
         lightPath.moveTo(origin[topIndex] + dir[leftIndex] * doubleLinesDistance);
         lightPath.lineTo(origin[bottomIndex] + dir[leftIndex] * doubleLinesDistance);
         drawDoubleUpRightShorterLine(topIndex, rightIndex);
         drawDoubleUpRightShorterLine(bottomIndex, rightIndex);
         break;
 
     case makePackedLineTypes(LtDouble, LtDouble, LtNone  , LtNone  ): // ╚ ; ╝ ╔ ╗
         lightPath.moveTo(origin[topIndex] + dir[leftIndex] * doubleLinesDistance);
         lightPath.lineTo(center + (dir[leftIndex] + dir[bottomIndex]) * doubleLinesDistance);
         lightPath.lineTo(origin[rightIndex] + dir[bottomIndex] * doubleLinesDistance);
         drawDoubleUpRightShorterLine(topIndex, rightIndex);
         break;
     }
 
     // Draw paths
     if (!lightPath.isEmpty()) {
         paint.strokePath(lightPath, lightPen);
     }
     if (!heavyPath.isEmpty()) {
         paint.strokePath(heavyPath, heavyPen);
     }
 
     return true;
 }
 
 static inline bool drawDashedLineCharacter(QPainter &paint, int x, int y, int w, int h, uchar code,
                                            bool bold)
 {
     if (!((0x04 <= code && code <= 0x0B) || (0x4C <= code && code <= 0x4F))) {
         return false;
     }
 
     const uint lightLineWidth = lineWidth(w, false, bold);
     const uint heavyLineWidth = lineWidth(w, true, bold);
 
     const auto lightPen = pen(paint, lightLineWidth);
     const auto heavyPen = pen(paint, heavyLineWidth);
 
     // Pixel aligned center point
     const QPointF center = {
         int(x + w/2.0) + 0.5 * (lightLineWidth%2),
         int(y + h/2.0) + 0.5 * (lightLineWidth%2),
     };
 
     const qreal halfGapH   = qMax(w / 20.0, 0.5);
     const qreal halfGapV   = qMax(h / 26.0, 0.5);
     // For some reason vertical double dash has bigger gap
     const qreal halfGapDDV = qMax(h / 14.0, 0.5);
 
     static const int LinesNumMax = 4;
 
     enum Orientation {Horizontal, Vertical};
     struct {
         int         linesNum;
         Orientation orientation;
         QPen        pen;
         qreal       halfGap;
     } lineProps;
 
     switch (code) {
     case 0x4C: lineProps = {2, Horizontal, lightPen, halfGapH  }; break; // ╌
     case 0x4D: lineProps = {2, Horizontal, heavyPen, halfGapH  }; break; // ╍
     case 0x4E: lineProps = {2, Vertical  , lightPen, halfGapDDV}; break; // ╎
     case 0x4F: lineProps = {2, Vertical  , heavyPen, halfGapDDV}; break; // ╏
     case 0x04: lineProps = {3, Horizontal, lightPen, halfGapH  }; break; // ┄
     case 0x05: lineProps = {3, Horizontal, heavyPen, halfGapH  }; break; // ┅
     case 0x06: lineProps = {3, Vertical  , lightPen, halfGapV  }; break; // ┆
     case 0x07: lineProps = {3, Vertical  , heavyPen, halfGapV  }; break; // ┇
     case 0x08: lineProps = {4, Horizontal, lightPen, halfGapH  }; break; // ┈
     case 0x09: lineProps = {4, Horizontal, heavyPen, halfGapH  }; break; // ┉
     case 0x0A: lineProps = {4, Vertical  , lightPen, halfGapV  }; break; // ┊
     case 0x0B: lineProps = {4, Vertical  , heavyPen, halfGapV  }; break; // ┋
     }
 
     Q_ASSERT(lineProps.linesNum <= LinesNumMax);
     const int size = (lineProps.orientation == Horizontal ? w : h);
     const int pos  = (lineProps.orientation == Horizontal ? x : y);
     QLineF lines[LinesNumMax];
 
     for (int i = 0; i < lineProps.linesNum; i++) {
         const qreal start = pos + qreal(size * (i  )) / lineProps.linesNum;
         const qreal end   = pos + qreal(size * (i+1)) / lineProps.linesNum;
         if (lineProps.orientation == Horizontal) {
             lines[i] = QLineF{start + lineProps.halfGap, center.y(),
                               end   - lineProps.halfGap, center.y()};
         } else {
             lines[i] = QLineF{center.x(), start + lineProps.halfGap,
                               center.x(), end   - lineProps.halfGap};
         }
     }
 
     const auto origPen = paint.pen();
 
     paint.setPen(lineProps.pen);
     paint.drawLines(lines, lineProps.linesNum);
 
     paint.setPen(origPen);
     return true;
 }
 
 static inline bool drawRoundedCornerLineCharacter(QPainter &paint, int x, int y, int w, int h,
                                                   uchar code, bool bold)
 {
     if (!(0x6D <= code && code <= 0x70)) {
         return false;
     }
 
     const uint lightLineWidth = lineWidth(w, false, bold);
     const auto lightPen = pen(paint, lightLineWidth);
 
     // Pixel aligned center point
     const QPointF center = {
         int(x + w/2.0) + 0.5 * (lightLineWidth%2),
         int(y + h/2.0) + 0.5 * (lightLineWidth%2),
     };
 
     const int r = w * 3 / 8;
     const int d = 2 * r;
 
     QPainterPath path;
 
     // lineTo() between moveTo and arcTo is redundant - arcTo() draws line
     // to the arc's starting point
     switch (code) {
     case 0x6D: // BOX DRAWINGS LIGHT ARC DOWN AND RIGHT
         path.moveTo(center.x(), y + h);
         path.arcTo(center.x(), center.y(), d, d, 180, -90);
         path.lineTo(x + w, center.y());
         break;
     case 0x6E: // BOX DRAWINGS LIGHT ARC DOWN AND LEFT
         path.moveTo(center.x(), y + h);
         path.arcTo(center.x() - d, center.y(), d, d, 0, 90);
         path.lineTo(x, center.y());
         break;
     case 0x6F: // BOX DRAWINGS LIGHT ARC UP AND LEFT
         path.moveTo(center.x(), y);
         path.arcTo(center.x() - d, center.y() - d, d, d, 0, -90);
         path.lineTo(x, center.y());
         break;
     case 0x70: // BOX DRAWINGS LIGHT ARC UP AND RIGHT
         path.moveTo(center.x(), y);
         path.arcTo(center.x(), center.y() - d, d, d, 180, 90);
         path.lineTo(x + w, center.y());
         break;
     }
     paint.strokePath(path, lightPen);
 
     return true;
 }
 
 static inline bool drawDiagonalLineCharacter(QPainter &paint, int x, int y, int w, int h,
                                              uchar code, bool bold)
 {
     if (!(0x71 <= code && code <= 0x73)) {
         return false;
     }
 
     const uint lightLineWidth = lineWidth(w, false, bold);
     const auto lightPen = pen(paint, lightLineWidth);
 
     const QLineF lines[] = {
         QLineF(x+w, y, x  , y+h), // '/'
         QLineF(x  , y, x+w, y+h), // '\'
     };
 
     const auto origPen = paint.pen();
 
     paint.setPen(lightPen);
     switch (code) {
     case 0x71: // BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT
         paint.drawLine(lines[0]);
         break;
     case 0x72: // BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT
         paint.drawLine(lines[1]);
         break;
     case 0x73: // BOX DRAWINGS LIGHT DIAGONAL CROSS
         paint.drawLines(lines, 2);
         break;
     }
 
     paint.setPen(origPen);
     return true;
 }
 
 static inline bool drawBlockCharacter(QPainter &paint, int x, int y, int w, int h, uchar code,
                                       bool bold)
 {
-    Q_UNUSED(bold);
+    Q_UNUSED(bold)
 
     const QColor color = paint.pen().color();
 
     // Center point
     const QPointF center = {
         x + w/2.0,
         y + h/2.0,
     };
 
     // Default rect fills entire cell
     QRectF rect(x, y, w, h);
 
     // LOWER ONE EIGHTH BLOCK to LEFT ONE EIGHTH BLOCK
     if (code >= 0x81 && code <= 0x8f) {
         if (code < 0x88) { // Horizontal
             const qreal height = h * (0x88 - code) / 8.0;
             rect.setY(y + height);
             rect.setHeight(h - height);
         } else if (code > 0x88) { // Vertical
             const qreal width = w * (0x90 - code) / 8.0;
             rect.setWidth(width);
         }
         paint.fillRect(rect, color);
 
         return true;
     }
 
     // Combinations of quarter squares
     // LEFT ONE EIGHTH BLOCK to QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT
     if (code >= 0x96 && code <= 0x9F) {
         const QRectF upperLeft (x         , y         , w/2.0, h/2.0);
         const QRectF upperRight(center.x(), y         , w/2.0, h/2.0);
         const QRectF lowerLeft (x         , center.y(), w/2.0, h/2.0);
         const QRectF lowerRight(center.x(), center.y(), w/2.0, h/2.0);
 
         QPainterPath path;
 
         switch (code) {
         case 0x96: // ▖
             path.addRect(lowerLeft);
             break;
         case 0x97: // ▗
             path.addRect(lowerRight);
             break;
         case 0x98: // ▘
             path.addRect(upperLeft);
             break;
         case 0x99: // ▙
             path.addRect(upperLeft);
             path.addRect(lowerLeft);
             path.addRect(lowerRight);
             break;
         case 0x9a: // ▚
             path.addRect(upperLeft);
             path.addRect(lowerRight);
             break;
         case 0x9b: // ▛
             path.addRect(upperLeft);
             path.addRect(upperRight);
             path.addRect(lowerLeft);
             break;
         case 0x9c: // ▜
             path.addRect(upperLeft);
             path.addRect(upperRight);
             path.addRect(lowerRight);
             break;
         case 0x9d: // ▝
             path.addRect(upperRight);
             break;
         case 0x9e: // ▞
             path.addRect(upperRight);
             path.addRect(lowerLeft);
             break;
         case 0x9f: // ▟
             path.addRect(upperRight);
             path.addRect(lowerLeft);
             path.addRect(lowerRight);
             break;
         }
         paint.fillPath(path, color);
 
         return true;
     }
 
     QBrush lightShade, mediumShade, darkShade;
     if (paint.testRenderHint(QPainter::Antialiasing)) {
         lightShade  = QColor(color.red(), color.green(), color.blue(), 64);
         mediumShade = QColor(color.red(), color.green(), color.blue(), 128);
         darkShade   = QColor(color.red(), color.green(), color.blue(), 192);
     } else {
         lightShade  = QBrush(color, Qt::Dense6Pattern);
         mediumShade = QBrush(color, Qt::Dense4Pattern);
         darkShade   = QBrush(color, Qt::Dense2Pattern);
     }
     // And the random stuff
     switch (code) {
     case 0x80: // Top half block
         rect.setHeight(h/2.0);
         paint.fillRect(rect, color);
         return true;
     case 0x90: // Right half block
         rect.moveLeft(center.x());
         paint.fillRect(rect, color);
         return true;
     case 0x94: // Top one eighth block
         rect.setHeight(h/8.0);
         paint.fillRect(rect, color);
         return true;
     case 0x95: { // Right one eighth block
             const qreal width = 7 * w / 8.0;
             rect.moveLeft(x + width);
             paint.fillRect(rect, color);
             return true;
         }
     case 0x91: // Light shade
         paint.fillRect(rect, lightShade);
         return true;
     case 0x92: // Medium shade
         paint.fillRect(rect, mediumShade);
         return true;
     case 0x93: // Dark shade
         paint.fillRect(rect, darkShade);
         return true;
 
     default:
         return false;
     }
 }
 
 void draw(QPainter &paint, const QRect &cellRect, const QChar &chr, bool bold)
 {
     static const ushort FirstBoxDrawingCharacterCodePoint = 0x2500;
     const uchar code = chr.unicode() - FirstBoxDrawingCharacterCodePoint;
 
     int x = cellRect.x();
     int y = cellRect.y();
     int w = cellRect.width();
     int h = cellRect.height();
 
     // Each function below returns true when it has drawn the character, false otherwise.
     drawBasicLineCharacter(paint, x, y, w, h, code, bold)
             || drawDashedLineCharacter(paint, x, y, w, h, code, bold)
             || drawRoundedCornerLineCharacter(paint, x, y, w, h, code, bold)
             || drawDiagonalLineCharacter(paint, x, y, w, h, code, bold)
             || drawBlockCharacter(paint, x, y, w, h, code, bold);
 }
 
 } // namespace LineBlockCharacters
 } // namespace Konsole
diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
index b0a070cf..69127346 100644
--- a/src/MainWindow.cpp
+++ b/src/MainWindow.cpp
@@ -1,928 +1,928 @@
 /*
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "MainWindow.h"
 
 // Qt
 #include <QMouseEvent>
 
 // KDE
 #include <KAcceleratorManager>
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KShortcutsDialog>
 #include <KLocalizedString>
 #include <KWindowEffects>
 
 #include <QMenu>
 #include <QMenuBar>
 #include <KMessageBox>
 #include <KStandardAction>
 #include <KStandardGuiItem>
 #include <KWindowSystem>
 #include <KXMLGUIFactory>
 #include <KNotifyConfigWidget>
 #include <KIconLoader>
 
 // Konsole
 #include "BookmarkHandler.h"
 #include "SessionController.h"
 #include "ProfileList.h"
 #include "Session.h"
 #include "ViewContainer.h"
 #include "ViewManager.h"
 #include "SessionManager.h"
 #include "ProfileManager.h"
 #include "KonsoleSettings.h"
 #include "WindowSystemInfo.h"
 #include "TerminalDisplay.h"
 #include "settings/ConfigurationDialog.h"
 #include "settings/TemporaryFilesSettings.h"
 #include "settings/GeneralSettings.h"
 #include "settings/ProfileSettings.h"
 #include "settings/TabBarSettings.h"
 
 using namespace Konsole;
 
 MainWindow::MainWindow() :
     KXmlGuiWindow(),
     _viewManager(nullptr),
     _bookmarkHandler(nullptr),
     _toggleMenuBarAction(nullptr),
     _newTabMenuAction(nullptr),
     _pluggedController(nullptr),
     _menuBarInitialVisibility(true),
     _menuBarInitialVisibilityApplied(false)
 {
     if (!KonsoleSettings::saveGeometryOnExit()) {
         // If we are not using the global Konsole save geometry on exit,
         // remove all Height and Width from [MainWindow] from konsolerc
         // Each screen resolution will have entries (Width 1280=619)
         KSharedConfigPtr konsoleConfig = KSharedConfig::openConfig(QStringLiteral("konsolerc"));
         KConfigGroup group = konsoleConfig->group("MainWindow");
         QMap<QString, QString> configEntries = group.entryMap();
         QMapIterator<QString, QString> i(configEntries);
         while (i.hasNext()) {
             i.next();
             if (i.key().startsWith(QLatin1String("Width"))
                 || i.key().startsWith(QLatin1String("Height"))) {
                 group.deleteEntry(i.key());
             }
         }
     }
 
     updateUseTransparency();
 
     // create actions for menus
     setupActions();
 
     // create view manager
     _viewManager = new ViewManager(this, actionCollection());
     connect(_viewManager, &Konsole::ViewManager::empty, this, &Konsole::MainWindow::close);
     connect(_viewManager, &Konsole::ViewManager::activeViewChanged, this,
             &Konsole::MainWindow::activeViewChanged);
     connect(_viewManager, &Konsole::ViewManager::unplugController, this,
             &Konsole::MainWindow::disconnectController);
     connect(_viewManager, &Konsole::ViewManager::viewPropertiesChanged,
             bookmarkHandler(), &Konsole::BookmarkHandler::setViews);
     connect(_viewManager, &Konsole::ViewManager::blurSettingChanged,
             this, &Konsole::MainWindow::setBlur);
 
     connect(_viewManager, &Konsole::ViewManager::updateWindowIcon, this,
             &Konsole::MainWindow::updateWindowIcon);
     connect(_viewManager, &Konsole::ViewManager::newViewWithProfileRequest,
             this, &Konsole::MainWindow::newFromProfile);
     connect(_viewManager, &Konsole::ViewManager::newViewRequest,
             this, &Konsole::MainWindow::newTab);
     connect(_viewManager, &Konsole::ViewManager::terminalsDetached, this,
             &Konsole::MainWindow::terminalsDetached);
 
     setCentralWidget(_viewManager->widget());
 
     // disable automatically generated accelerators in top-level
     // menu items - to avoid conflicting with Alt+[Letter] shortcuts
     // in terminal applications
     KAcceleratorManager::setNoAccel(menuBar());
 
     // create menus
     createGUI();
 
     // remember the original menu accelerators for later use
     rememberMenuAccelerators();
 
     // replace standard shortcuts which cannot be used in a terminal
     // emulator (as they are reserved for use by terminal applications)
     correctStandardShortcuts();
 
     setProfileList(new ProfileList(true, this));
 
     // this must come at the end
     applyKonsoleSettings();
     connect(KonsoleSettings::self(), &Konsole::KonsoleSettings::configChanged, this,
             &Konsole::MainWindow::applyKonsoleSettings);
 }
 
 void MainWindow::updateUseTransparency()
 {
     if (!WindowSystemInfo::HAVE_TRANSPARENCY) {
         return;
     }
 
     bool useTranslucency = KWindowSystem::compositingActive();
 
     setAttribute(Qt::WA_TranslucentBackground, useTranslucency);
     setAttribute(Qt::WA_NoSystemBackground, false);
     WindowSystemInfo::HAVE_TRANSPARENCY = useTranslucency;
 }
 
 void MainWindow::rememberMenuAccelerators()
 {
     const QList<QAction *> actions = menuBar()->actions();
     for (QAction *menuItem : actions) {
         QString itemText = menuItem->text();
         menuItem->setData(itemText);
     }
 }
 
 // remove accelerators for standard menu items (eg. &File, &View, &Edit)
 // etc. which are defined in kdelibs/kdeui/xmlgui/ui_standards.rc, again,
 // to avoid conflicting with Alt+[Letter] terminal shortcuts
 //
 // TODO - Modify XMLGUI so that it allows the text for standard actions
 // defined in ui_standards.rc to be re-defined in the local application
 // XMLGUI file (konsoleui.rc in this case) - the text for standard items
 // can then be redefined there to exclude the standard accelerators
 void MainWindow::removeMenuAccelerators()
 {
     const QList<QAction *> actions = menuBar()->actions();
     for (QAction *menuItem : actions) {
         menuItem->setText(menuItem->text().replace(QLatin1Char('&'), QString()));
     }
 }
 
 void MainWindow::restoreMenuAccelerators()
 {
     const QList<QAction *> actions = menuBar()->actions();
     for (QAction *menuItem : actions) {
         QString itemText = menuItem->data().toString();
         menuItem->setText(itemText);
     }
 }
 
 void MainWindow::correctStandardShortcuts()
 {
     // replace F1 shortcut for help contents
     QAction *helpAction = actionCollection()->action(QStringLiteral("help_contents"));
     if (helpAction != nullptr) {
         actionCollection()->setDefaultShortcut(helpAction, QKeySequence());
     }
 
     // replace Ctrl+B shortcut for bookmarks only if user hasn't already
     // changed the shortcut; however, if the user changed it to Ctrl+B
     // this will still get changed to Ctrl+Shift+B
     QAction *bookmarkAction = actionCollection()->action(QStringLiteral("add_bookmark"));
     if ((bookmarkAction != nullptr)
         && bookmarkAction->shortcut() == QKeySequence(Konsole::ACCEL + Qt::Key_B)) {
         actionCollection()->setDefaultShortcut(bookmarkAction,
                                                Konsole::ACCEL + Qt::SHIFT + Qt::Key_B);
     }
 }
 
 ViewManager *MainWindow::viewManager() const
 {
     return _viewManager;
 }
 
 void MainWindow::disconnectController(SessionController *controller)
 {
     disconnect(controller, &Konsole::SessionController::titleChanged,
                this, &Konsole::MainWindow::activeViewTitleChanged);
     disconnect(controller, &Konsole::SessionController::rawTitleChanged,
                this, &Konsole::MainWindow::updateWindowCaption);
     disconnect(controller, &Konsole::SessionController::iconChanged,
                this, &Konsole::MainWindow::updateWindowIcon);
 
     if (auto view = controller->view()) {
         view->removeEventFilter(this);
     }
 
     // KXmlGuiFactory::removeClient() will try to access actions associated
     // with the controller internally, which may not be valid after the controller
     // itself is no longer valid (after the associated session and or view have
     // been destroyed)
     if (controller->isValid()) {
         guiFactory()->removeClient(controller);
     }
 
     if (_pluggedController == controller) {
         _pluggedController = nullptr;
     }
 }
 
 void MainWindow::activeViewChanged(SessionController *controller)
 {
     if (!SessionManager::instance()->sessionProfile(controller->session())) {
         return;
     }
     // associate bookmark menu with current session
     bookmarkHandler()->setActiveView(controller);
     disconnect(bookmarkHandler(), &Konsole::BookmarkHandler::openUrl, nullptr, nullptr);
     connect(bookmarkHandler(), &Konsole::BookmarkHandler::openUrl, controller,
             &Konsole::SessionController::openUrl);
 
     if (!_pluggedController.isNull()) {
         disconnectController(_pluggedController);
     }
 
     Q_ASSERT(controller);
     _pluggedController = controller;
     _pluggedController->view()->installEventFilter(this);
 
     setBlur(ViewManager::profileHasBlurEnabled(SessionManager::instance()->sessionProfile(_pluggedController->session())));
 
     // listen for title changes from the current session
     connect(controller, &Konsole::SessionController::titleChanged, this,
             &Konsole::MainWindow::activeViewTitleChanged);
     connect(controller, &Konsole::SessionController::rawTitleChanged, this,
             &Konsole::MainWindow::updateWindowCaption);
     connect(controller, &Konsole::SessionController::iconChanged, this,
             &Konsole::MainWindow::updateWindowIcon);
 
     controller->setShowMenuAction(_toggleMenuBarAction);
     guiFactory()->addClient(controller);
 
     // update session title to match newly activated session
     activeViewTitleChanged(controller);
 
     // Update window icon to newly activated session's icon
     updateWindowIcon();
 }
 
 void MainWindow::activeViewTitleChanged(ViewProperties *properties)
 {
-    Q_UNUSED(properties);
+    Q_UNUSED(properties)
     updateWindowCaption();
 }
 
 void MainWindow::updateWindowCaption()
 {
     if (_pluggedController.isNull()) {
         return;
     }
 
     const QString &title = _pluggedController->title();
     const QString &userTitle = _pluggedController->userTitle();
 
     // use tab title as caption by default
     QString caption = title;
 
     // use window title as caption when this setting is enabled
     // if the userTitle is empty, use a blank space (using an empty string
     // removes the dash — before the application name; leaving the dash
     // looks better)
     if (KonsoleSettings::showWindowTitleOnTitleBar()) {
         !userTitle.isEmpty() ? caption = userTitle : caption = QStringLiteral(" ");
     }
 
     setCaption(caption);
 }
 
 void MainWindow::updateWindowIcon()
 {
     if ((!_pluggedController.isNull()) && !_pluggedController->icon().isNull()) {
         setWindowIcon(_pluggedController->icon());
     }
 }
 
 void MainWindow::setupActions()
 {
     KActionCollection *collection = actionCollection();
 
     // File Menu
     _newTabMenuAction = new KActionMenu(QIcon::fromTheme(QStringLiteral("tab-new")),
                                         i18nc("@action:inmenu", "&New Tab"), collection);
     collection->setDefaultShortcut(_newTabMenuAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_T);
     collection->setShortcutsConfigurable(_newTabMenuAction, true);
     _newTabMenuAction->setAutoRepeat(false);
     connect(_newTabMenuAction, &KActionMenu::triggered, this, &MainWindow::newTab);
     collection->addAction(QStringLiteral("new-tab"), _newTabMenuAction);
     collection->setShortcutsConfigurable(_newTabMenuAction, true);
 
     QAction* menuAction = collection->addAction(QStringLiteral("clone-tab"));
     menuAction->setIcon(QIcon::fromTheme(QStringLiteral("tab-duplicate")));
     menuAction->setText(i18nc("@action:inmenu", "&Clone Tab"));
     collection->setDefaultShortcut(menuAction, QKeySequence());
     menuAction->setAutoRepeat(false);
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::cloneTab);
 
     menuAction = collection->addAction(QStringLiteral("new-window"));
     menuAction->setIcon(QIcon::fromTheme(QStringLiteral("window-new")));
     menuAction->setText(i18nc("@action:inmenu", "New &Window"));
     collection->setDefaultShortcut(menuAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_N);
     menuAction->setAutoRepeat(false);
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::newWindow);
 
     menuAction = collection->addAction(QStringLiteral("close-window"));
     menuAction->setIcon(QIcon::fromTheme(QStringLiteral("window-close")));
     menuAction->setText(i18nc("@action:inmenu", "Close Window"));
     collection->setDefaultShortcut(menuAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_Q);
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::close);
 
     // Bookmark Menu
     KActionMenu *bookmarkMenu = new KActionMenu(i18nc("@title:menu", "&Bookmarks"), collection);
     _bookmarkHandler = new BookmarkHandler(collection, bookmarkMenu->menu(), true, this);
     collection->addAction(QStringLiteral("bookmark"), bookmarkMenu);
     connect(_bookmarkHandler, &Konsole::BookmarkHandler::openUrls, this,
             &Konsole::MainWindow::openUrls);
 
     // Settings Menu
     _toggleMenuBarAction = KStandardAction::showMenubar(menuBar(), SLOT(setVisible(bool)), collection);
     collection->setDefaultShortcut(_toggleMenuBarAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_M);
 
     // Full Screen
     menuAction = KStandardAction::fullScreen(this, SLOT(viewFullScreen(bool)), this, collection);
     collection->setDefaultShortcut(menuAction, Qt::Key_F11);
 
     KStandardAction::configureNotifications(this, SLOT(configureNotifications()), collection);
     KStandardAction::keyBindings(this, SLOT(showShortcutsDialog()), collection);
     KStandardAction::preferences(this, SLOT(showSettingsDialog()), collection);
 
     menuAction = collection->addAction(QStringLiteral("manage-profiles"));
     menuAction->setText(i18nc("@action:inmenu", "Manage Profiles..."));
     menuAction->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::showManageProfilesDialog);
 
     // Set up an shortcut-only action for activating menu bar.
     menuAction = collection->addAction(QStringLiteral("activate-menu"));
     menuAction->setText(i18nc("@item", "Activate Menu"));
     collection->setDefaultShortcut(menuAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_F10);
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::activateMenuBar);
 }
 
 void MainWindow::viewFullScreen(bool fullScreen)
 {
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);
     }
 }
 
 BookmarkHandler *MainWindow::bookmarkHandler() const
 {
     return _bookmarkHandler;
 }
 
 void MainWindow::setProfileList(ProfileList *list)
 {
     profileListChanged(list->actions());
 
     connect(list, &Konsole::ProfileList::profileSelected, this, &MainWindow::newFromProfile);
     connect(list, &Konsole::ProfileList::actionsChanged, this, &Konsole::MainWindow::profileListChanged);
 }
 
 void MainWindow::profileListChanged(const QList<QAction *> &sessionActions)
 {
     // If only 1 profile is to be shown in the menu, only display
     // it if it is the non-default profile.
     if (sessionActions.size() > 2) {
         // Update the 'New Tab' KActionMenu
         if (_newTabMenuAction->menu() != nullptr) {
             _newTabMenuAction->menu()->clear();
         } else {
             _newTabMenuAction->setMenu(new QMenu());
         }
         for (QAction *sessionAction : sessionActions) {
             _newTabMenuAction->menu()->addAction(sessionAction);
 
             // NOTE: defaultProfile seems to not work here, sigh.
             Profile::Ptr profile = ProfileManager::instance()->defaultProfile();
             if (profile && profile->name() == sessionAction->text().remove(QLatin1Char('&'))) {
                 QIcon icon(KIconLoader::global()->loadIcon(profile->icon(), KIconLoader::Small, 0, KIconLoader::DefaultState, QStringList(QStringLiteral("emblem-favorite"))));
                 sessionAction->setIcon(icon);
                 _newTabMenuAction->menu()->setDefaultAction(sessionAction);
                 QFont actionFont = sessionAction->font();
                 actionFont.setBold(true);
                 sessionAction->setFont(actionFont);
             }
         }
     } else {
         if (_newTabMenuAction->menu() != nullptr) {
             _newTabMenuAction->menu()->clear();
         } else {
             _newTabMenuAction->setMenu(new QMenu());
         }
         Profile::Ptr profile = ProfileManager::instance()->defaultProfile();
 
         // NOTE: Compare names w/o any '&'
         if (sessionActions.size() == 2
             && sessionActions[1]->text().remove(QLatin1Char('&')) != profile->name()) {
             _newTabMenuAction->menu()->addAction(sessionActions[1]);
         } else {
             _newTabMenuAction->menu()->deleteLater();
         }
     }
 }
 
 QString MainWindow::activeSessionDir() const
 {
     if (!_pluggedController.isNull()) {
         if (Session *session = _pluggedController->session()) {
             // For new tabs to get the correct working directory,
             // force the updating of the currentWorkingDirectory.
             session->getDynamicTitle();
         }
         return _pluggedController->currentDir();
     } else {
         return QString();
     }
 }
 
 void MainWindow::openUrls(const QList<QUrl> &urls)
 {
     Profile::Ptr defaultProfile = ProfileManager::instance()->defaultProfile();
 
     for (const auto &url : urls) {
         if (url.isLocalFile()) {
             createSession(defaultProfile, url.path());
         } else if (url.scheme() == QLatin1String("ssh")) {
             createSSHSession(defaultProfile, url);
         }
     }
 }
 
 void MainWindow::newTab()
 {
     Profile::Ptr defaultProfile = ProfileManager::instance()->defaultProfile();
     createSession(defaultProfile, activeSessionDir());
 }
 
 void MainWindow::cloneTab()
 {
     Q_ASSERT(_pluggedController);
 
     Session *session = _pluggedController->session();
     Profile::Ptr profile = SessionManager::instance()->sessionProfile(session);
     if (profile) {
         createSession(profile, activeSessionDir());
     } else {
         // something must be wrong: every session should be associated with profile
         Q_ASSERT(false);
         newTab();
     }
 }
 
 Session *MainWindow::createSession(Profile::Ptr profile, const QString &directory)
 {
     if (!profile) {
         profile = ProfileManager::instance()->defaultProfile();
     }
 
     const QString newSessionDirectory = profile->startInCurrentSessionDir() ? directory : QString();
     Session *session = _viewManager->createSession(profile, newSessionDirectory);
 
     // create view before starting the session process so that the session
     // doesn't suffer a change in terminal size right after the session
     // starts.  Some applications such as GNU Screen and Midnight Commander
     // don't like this happening
     auto newView = _viewManager->createView(session);
     _viewManager->activeContainer()->addView(newView);
     return session;
 }
 
 Session *MainWindow::createSSHSession(Profile::Ptr profile, const QUrl &url)
 {
     if (!profile) {
         profile = ProfileManager::instance()->defaultProfile();
     }
 
     Session *session = SessionManager::instance()->createSession(profile);
 
     QString sshCommand = QStringLiteral("ssh ");
     if (url.port() > -1) {
         sshCommand += QStringLiteral("-p %1 ").arg(url.port());
     }
     if (!url.userName().isEmpty()) {
         sshCommand += (url.userName() + QLatin1Char('@'));
     }
     if (!url.host().isEmpty()) {
         sshCommand += url.host();
     }
 
     session->sendTextToTerminal(sshCommand, QLatin1Char('\r'));
 
     // create view before starting the session process so that the session
     // doesn't suffer a change in terminal size right after the session
     // starts.  some applications such as GNU Screen and Midnight Commander
     // don't like this happening
     auto newView = _viewManager->createView(session);
     _viewManager->activeContainer()->addView(newView);
     return session;
 }
 
 void MainWindow::setFocus()
 {
     _viewManager->activeView()->setFocus();
 }
 
 void MainWindow::newWindow()
 {
     Profile::Ptr defaultProfile = ProfileManager::instance()->defaultProfile();
     emit newWindowRequest(defaultProfile, activeSessionDir());
 }
 
 bool MainWindow::queryClose()
 {
     // Do not ask for confirmation during log out and power off
     // TODO: rework the dealing of this case to make it has its own confirmation
     // dialog.
     if (qApp->isSavingSession()) {
         return true;
     }
 
     // Check what processes are running, excluding the shell
     QStringList processesRunning;
     const auto uniqueSessions = QSet<Session*>::fromList(_viewManager->sessions());
 
     for (Session *session : uniqueSessions) {
         if ((session == nullptr) || !session->isForegroundProcessActive()) {
             continue;
         }
 
         const QString defaultProc = session->program().split(QLatin1Char('/')).last();
         const QString currentProc = session->foregroundProcessName().split(QLatin1Char('/')).last();
 
         if (currentProc.isEmpty()) {
             continue;
         }
 
         if (defaultProc != currentProc) {
             processesRunning.append(currentProc);
         }
     }
 
     // Get number of open tabs
     const int openTabs = _viewManager->viewProperties().count();
 
     // If no processes running (except the shell) and no extra tabs, just close
     if (processesRunning.count() == 0 && openTabs < 2) {
         return true;
     }
 
     // NOTE: Some, if not all, of the below KWindowSystem calls are only
     //       implemented under x11 (KDE4.8 kdelibs/kdeui/windowmanagement).
 
     // make sure the window is shown on current desktop and is not minimized
     KWindowSystem::setOnDesktop(winId(), KWindowSystem::currentDesktop());
     if (isMinimized()) {
         KWindowSystem::unminimizeWindow(winId());
     }
     int result;
 
     if (!processesRunning.isEmpty()) {
         if (openTabs == 1) {
             result = KMessageBox::warningYesNoList(this,
                                                          i18ncp("@info",
                                                                 "There is a process running in this window. "
                                                                 "Do you still want to quit?",
                                                                 "There are %1 processes running in this window. "
                                                                 "Do you still want to quit?",
                                                                 processesRunning.count()),
                                                          processesRunning,
                                                          i18nc("@title", "Confirm Close"),
                                                          KGuiItem(i18nc("@action:button",
                                                                         "Close &Window"),
                                                                   QStringLiteral("window-close")),
                                                          KStandardGuiItem::cancel(),
                                                          // don't ask again name is wrong but I can't update.
                                                          // this is not about tabs anymore. it's about empty tabs *or* splits.
                                                          QStringLiteral("CloseAllTabs"));
             if (result == KMessageBox::No) // No is equal to cancel closing
                 result = KMessageBox::Cancel;
         } else {
             result = KMessageBox::warningYesNoCancelList(this,
                                                          i18ncp("@info",
                                                                 "There is a process running in this window. "
                                                                 "Do you still want to quit?",
                                                                 "There are %1 processes running in this window. "
                                                                 "Do you still want to quit?",
                                                                 processesRunning.count()),
                                                          processesRunning,
                                                          i18nc("@title", "Confirm Close"),
                                                          KGuiItem(i18nc("@action:button",
                                                                         "Close &Window"),
                                                                   QStringLiteral("window-close")),
                                                          KGuiItem(i18nc("@action:button",
                                                                         "Close Current &Tab"),
                                                                   QStringLiteral("tab-close")),
                                                          KStandardGuiItem::cancel(),
                                                          // don't ask again name is wrong but I can't update.
                                                          // this is not about tabs anymore. it's about empty tabs *or* splits.
                                                          QStringLiteral("CloseAllTabs"));
         }
     } else {
         result = KMessageBox::warningYesNoCancel(this,
                                                  i18nc("@info",
                                                        "There are %1 open terminals in this window. "
                                                        "Do you still want to quit?",
                                                        openTabs),
                                                  i18nc("@title", "Confirm Close"),
                                                  KGuiItem(i18nc("@action:button", "Close &Window"),
                                                           QStringLiteral("window-close")),
                                                  KGuiItem(i18nc("@action:button",
                                                                 "Close Current &Tab"),
                                                           QStringLiteral("tab-close")),
                                                  KStandardGuiItem::cancel(),
                                                  // don't ask again name is wrong but I can't update.
                                                  // this is not about tabs anymore. it's about empty tabs *or* splits.
                                                  QStringLiteral("CloseAllEmptyTabs"));
     }
 
     switch (result) {
     case KMessageBox::Yes:
         return true;
     case KMessageBox::No:
         if ((!_pluggedController.isNull()) && (!_pluggedController->session().isNull())) {
             if (!(_pluggedController->session()->closeInNormalWay())) {
                 if (_pluggedController->confirmForceClose()) {
                     _pluggedController->session()->closeInForceWay();
                 }
             }
         }
         return false;
     case KMessageBox::Cancel:
         return false;
     }
 
     return true;
 }
 
 void MainWindow::saveProperties(KConfigGroup &group)
 {
     _viewManager->saveSessions(group);
 }
 
 void MainWindow::readProperties(const KConfigGroup &group)
 {
     _viewManager->restoreSessions(group);
 }
 
 void MainWindow::saveGlobalProperties(KConfig *config)
 {
     SessionManager::instance()->saveSessions(config);
 }
 
 void MainWindow::readGlobalProperties(KConfig *config)
 {
     SessionManager::instance()->restoreSessions(config);
 }
 
 void MainWindow::syncActiveShortcuts(KActionCollection *dest, const KActionCollection *source)
 {
     const QList<QAction *> actionsList = source->actions();
     for (QAction *qAction : actionsList) {
         if (QAction *destQAction = dest->action(qAction->objectName())) {
             destQAction->setShortcut(qAction->shortcut());
         }
     }
 }
 
 void MainWindow::showShortcutsDialog()
 {
     KShortcutsDialog dialog(KShortcutsEditor::AllActions,
                             KShortcutsEditor::LetterShortcutsDisallowed, this);
 
     // add actions from this window and the current session controller
     const QList<KXMLGUIClient *> clientsList = guiFactory()->clients();
     for (KXMLGUIClient *client : clientsList) {
         dialog.addCollection(client->actionCollection());
     }
 
     if (dialog.configure()) {
         // sync shortcuts for non-session actions (defined in "konsoleui.rc") in other main windows
         const QList<QWidget *> widgets = QApplication::topLevelWidgets();
         for (QWidget *mainWindowWidget : widgets) {
             auto *mainWindow = qobject_cast<MainWindow *>(mainWindowWidget);
             if ((mainWindow != nullptr) && mainWindow != this) {
                 syncActiveShortcuts(mainWindow->actionCollection(), actionCollection());
             }
         }
         // sync shortcuts for session actions (defined in "sessionui.rc") in other session controllers.
         // Controllers which are currently plugged in (ie. their actions are part of the current menu)
         // must be updated immediately via syncActiveShortcuts().  Other controllers will be updated
         // when they are plugged into a main window.
         const QSet<SessionController *> allControllers = SessionController::allControllers();
         for (SessionController *controller : allControllers) {
             controller->reloadXML();
             if ((controller->factory() != nullptr) && controller != _pluggedController) {
                 syncActiveShortcuts(controller->actionCollection(), _pluggedController->actionCollection());
             }
         }
     }
 }
 
 void MainWindow::newFromProfile(const Profile::Ptr &profile)
 {
     createSession(profile, activeSessionDir());
 }
 
 void MainWindow::showManageProfilesDialog()
 {
     showSettingsDialog(true);
 }
 
 void MainWindow::showSettingsDialog(const bool showProfilePage)
 {
     static ConfigurationDialog *confDialog = nullptr;
     if (confDialog != nullptr) {
         confDialog->show();
         return;
     }
 
     confDialog = new ConfigurationDialog(this, KonsoleSettings::self());
 
     const QString generalPageName = i18nc("@title Preferences page name", "General");
     auto *generalPage = new KPageWidgetItem(new GeneralSettings(confDialog), generalPageName);
     generalPage->setIcon(QIcon::fromTheme(QStringLiteral("utilities-terminal")));
     confDialog->addPage(generalPage, true);
 
     const QString profilePageName = i18nc("@title Preferences page name", "Profiles");
     auto profilePage = new KPageWidgetItem(new ProfileSettings(confDialog), profilePageName);
     profilePage->setIcon(QIcon::fromTheme(QStringLiteral("preferences-system-profiles")));
     confDialog->addPage(profilePage, true);
 
     const QString tabBarPageName = i18nc("@title Preferences page name", "Tab Bar");
     auto tabBarPage = new KPageWidgetItem(new TabBarSettings(confDialog), tabBarPageName);
     tabBarPage->setIcon(QIcon::fromTheme(QStringLiteral("system-run")));
     confDialog->addPage(tabBarPage, true);
 
     const QString temporaryFilesPageName = i18nc("@title Preferences page name", "Temporary Files");
     auto temporaryFilesPage = new KPageWidgetItem(new TemporaryFilesSettings(confDialog), temporaryFilesPageName);
     temporaryFilesPage->setIcon(QIcon::fromTheme(QStringLiteral("folder-temp")));
     confDialog->addPage(temporaryFilesPage, true);
 
     if (showProfilePage) {
         confDialog->setCurrentPage(profilePage);
     }
 
     confDialog->show();
 }
 
 void MainWindow::applyKonsoleSettings()
 {
     setMenuBarInitialVisibility(KonsoleSettings::showMenuBarByDefault());
     setRemoveWindowTitleBarAndFrame(KonsoleSettings::removeWindowTitleBarAndFrame());
     if (KonsoleSettings::allowMenuAccelerators()) {
         restoreMenuAccelerators();
     } else {
         removeMenuAccelerators();
     }
 
     _viewManager->activeContainer()->setNavigationBehavior(KonsoleSettings::newTabBehavior());
     setAutoSaveSettings(QStringLiteral("MainWindow"), KonsoleSettings::saveGeometryOnExit());
     updateWindowCaption();
 }
 
 void MainWindow::activateMenuBar()
 {
     const QList<QAction *> menuActions = menuBar()->actions();
 
     if (menuActions.isEmpty()) {
         return;
     }
 
     // Show menubar if it is hidden at the moment
     if (menuBar()->isHidden()) {
         menuBar()->setVisible(true);
         _toggleMenuBarAction->setChecked(true);
     }
 
     // First menu action should be 'File'
     QAction *menuAction = menuActions.first();
 
     // TODO: Handle when menubar is top level (MacOS)
     menuBar()->setActiveAction(menuAction);
 }
 
 void MainWindow::configureNotifications()
 {
     KNotifyConfigWidget::configure(this);
 }
 
 void MainWindow::setBlur(bool blur)
 {
     if (_pluggedController.isNull()) {
         return;
     }
 
     if (!_pluggedController->isKonsolePart()) {
         KWindowEffects::enableBlurBehind(winId(), blur);
     }
 }
 
 void MainWindow::setMenuBarInitialVisibility(bool visible)
 {
     _menuBarInitialVisibility = visible;
 }
 
 void MainWindow::setRemoveWindowTitleBarAndFrame(bool frameless)
 {
     Qt::WindowFlags newFlags = frameless ? Qt::FramelessWindowHint : Qt::Window;
 
     // The window is not yet visible
     if (!isVisible()) {
         setWindowFlags(newFlags);
 
     // The window is visible and the setting changed
     } else if (windowFlags().testFlag(Qt::FramelessWindowHint) != frameless) {
         const auto oldGeometry = saveGeometry();
         // This happens for every Konsole window. It depends on
         // the fact that every window is processed in single thread
         const auto oldActiveWindow = KWindowSystem::activeWindow();
 
         setWindowFlags(newFlags);
 
         // The setWindowFlags() has hidden the window. Show it again
         // with previous geometry
         restoreGeometry(oldGeometry);
         setVisible(true);
         KWindowSystem::activateWindow(oldActiveWindow);
     }
 }
 
 void MainWindow::showEvent(QShowEvent *event)
 {
     // Make sure the 'initial' visibility is applied only once.
     if (!_menuBarInitialVisibilityApplied) {
         // the initial visibility of menubar should be applied at this last
         // moment. Otherwise, the initial visibility will be determined by
         // what KMainWindow has automatically stored in konsolerc, but not by
         // what users has explicitly configured .
         menuBar()->setVisible(_menuBarInitialVisibility);
         _toggleMenuBarAction->setChecked(_menuBarInitialVisibility);
         _menuBarInitialVisibilityApplied = true;
         if (!KonsoleSettings::saveGeometryOnExit()) {
             resize(sizeHint());
         }
     }
 
     // Call parent method
     KXmlGuiWindow::showEvent(event);
 }
 
 void MainWindow::triggerAction(const QString &name) const
 {
     if (auto action = actionCollection()->action(name)) {
         if (action->isEnabled()) {
             action->trigger();
         }
     }
 }
 
 bool MainWindow::eventFilter(QObject *obj, QEvent *event)
 {
     if (!_pluggedController.isNull() && obj == _pluggedController->view()) {
         switch(event->type()) {
             case QEvent::MouseButtonPress:
             case QEvent::MouseButtonDblClick:
             switch(static_cast<QMouseEvent*>(event)->button()) {
                 case Qt::ForwardButton:
                     triggerAction(QStringLiteral("next-view"));
                     break;
                 case Qt::BackButton:
                     triggerAction(QStringLiteral("previous-view"));
                     break;
                 default: ;
             }
             default: ;
         }
     }
 
     return KXmlGuiWindow::eventFilter(obj, event);
 }
 
 bool MainWindow::focusNextPrevChild(bool)
 {
     // In stand-alone konsole, always disable implicit focus switching
     // through 'Tab' and 'Shift+Tab'
     //
     // Kpart is another different story
     return false;
 }
diff --git a/src/ProcessInfo.cpp b/src/ProcessInfo.cpp
index 9104b8a7..c06b655c 100644
--- a/src/ProcessInfo.cpp
+++ b/src/ProcessInfo.cpp
@@ -1,1195 +1,1195 @@
 /*
     Copyright 2007-2008 by Robert Knight <robertknight@gmail.countm>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Config
 #include "config-konsole.h"
 
 // Own
 #include "ProcessInfo.h"
 
 // Unix
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <unistd.h>
 #include <pwd.h>
 #include <sys/param.h>
 #include <cerrno>
 
 // Qt
 #include <QDir>
 #include <QFileInfo>
 #include <QTextStream>
 #include <QStringList>
 #include <QHostInfo>
 
 // KDE
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KUser>
 
 #if defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD) || defined(Q_OS_MACOS)
 #include <sys/sysctl.h>
 #endif
 
 #if defined(Q_OS_MACOS)
 #include <libproc.h>
 #include <qplatformdefs.h>
 #endif
 
 #if defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
 #include <sys/types.h>
 #include <sys/user.h>
 #include <sys/syslimits.h>
 #   if defined(Q_OS_FREEBSD)
 #   include <libutil.h>
 #   include <sys/param.h>
 #   include <sys/queue.h>
 #   endif
 #endif
 
 using namespace Konsole;
 
 ProcessInfo::ProcessInfo(int pid) :
     _fields(ARGUMENTS)     // arguments
     // are currently always valid,
     // they just return an empty
     // vector / map respectively
     // if no arguments
     // have been explicitly set
     ,
     _pid(pid),
     _parentPid(0),
     _foregroundPid(0),
     _userId(0),
     _lastError(NoError),
     _name(QString()),
     _userName(QString()),
     _userHomeDir(QString()),
     _currentDir(QString()),
     _userNameRequired(true),
     _arguments(QVector<QString>())
 {
 }
 
 ProcessInfo::Error ProcessInfo::error() const
 {
     return _lastError;
 }
 
 void ProcessInfo::setError(Error error)
 {
     _lastError = error;
 }
 
 void ProcessInfo::update()
 {
     readCurrentDir(_pid);
 }
 
 QString ProcessInfo::validCurrentDir() const
 {
     bool ok = false;
 
     // read current dir, if an error occurs try the parent as the next
     // best option
     int currentPid = parentPid(&ok);
     QString dir = currentDir(&ok);
     while (!ok && currentPid != 0) {
         ProcessInfo *current = ProcessInfo::newInstance(currentPid);
         current->update();
         currentPid = current->parentPid(&ok);
         dir = current->currentDir(&ok);
         delete current;
     }
 
     return dir;
 }
 
 QSet<QString> ProcessInfo::_commonDirNames;
 
 QSet<QString> ProcessInfo::commonDirNames()
 {
     static bool forTheFirstTime = true;
 
     if (forTheFirstTime) {
         const KSharedConfigPtr &config = KSharedConfig::openConfig();
         const KConfigGroup &configGroup = config->group("ProcessInfo");
         _commonDirNames = QSet<QString>::fromList(configGroup.readEntry("CommonDirNames", QStringList()));
 
         forTheFirstTime = false;
     }
 
     return _commonDirNames;
 }
 
 QString ProcessInfo::formatShortDir(const QString &input) const
 {
     if(input == QStringLiteral("/")) {
         return QStringLiteral("/");
     }
 
     QString result;
 
     const QStringList &parts = input.split(QDir::separator());
 
     QSet<QString> dirNamesToShorten = commonDirNames();
 
     QListIterator<QString> iter(parts);
     iter.toBack();
 
     // go backwards through the list of the path's parts
     // adding abbreviations of common directory names
     // and stopping when we reach a dir name which is not
     // in the commonDirNames set
     while (iter.hasPrevious()) {
         const QString &part = iter.previous();
 
         if (dirNamesToShorten.contains(part)) {
             result.prepend(QDir::separator() + part[0]);
         } else {
             result.prepend(part);
             break;
         }
     }
 
     return result;
 }
 
 QVector<QString> ProcessInfo::arguments(bool *ok) const
 {
     *ok = _fields.testFlag(ARGUMENTS);
 
     return _arguments;
 }
 
 bool ProcessInfo::isValid() const
 {
     return _fields.testFlag(PROCESS_ID);
 }
 
 int ProcessInfo::pid(bool *ok) const
 {
     *ok = _fields.testFlag(PROCESS_ID);
 
     return _pid;
 }
 
 int ProcessInfo::parentPid(bool *ok) const
 {
     *ok = _fields.testFlag(PARENT_PID);
 
     return _parentPid;
 }
 
 int ProcessInfo::foregroundPid(bool *ok) const
 {
     *ok = _fields.testFlag(FOREGROUND_PID);
 
     return _foregroundPid;
 }
 
 QString ProcessInfo::name(bool *ok) const
 {
     *ok = _fields.testFlag(NAME);
 
     return _name;
 }
 
 int ProcessInfo::userId(bool *ok) const
 {
     *ok = _fields.testFlag(UID);
 
     return _userId;
 }
 
 QString ProcessInfo::userName() const
 {
     return _userName;
 }
 
 QString ProcessInfo::userHomeDir() const
 {
     return _userHomeDir;
 }
 
 QString ProcessInfo::localHost()
 {
     return QHostInfo::localHostName();
 }
 
 void ProcessInfo::setPid(int pid)
 {
     _pid = pid;
     _fields |= PROCESS_ID;
 }
 
 void ProcessInfo::setUserId(int uid)
 {
     _userId = uid;
     _fields |= UID;
 }
 
 void ProcessInfo::setUserName(const QString &name)
 {
     _userName = name;
     setUserHomeDir();
 }
 
 void ProcessInfo::setUserHomeDir()
 {
     const QString &usersName = userName();
     if (!usersName.isEmpty()) {
         _userHomeDir = KUser(usersName).homeDir();
     } else {
         _userHomeDir = QDir::homePath();
     }
 }
 
 void ProcessInfo::setParentPid(int pid)
 {
     _parentPid = pid;
     _fields |= PARENT_PID;
 }
 
 void ProcessInfo::setForegroundPid(int pid)
 {
     _foregroundPid = pid;
     _fields |= FOREGROUND_PID;
 }
 
 void ProcessInfo::setUserNameRequired(bool need)
 {
     _userNameRequired = need;
 }
 
 bool ProcessInfo::userNameRequired() const
 {
     return _userNameRequired;
 }
 
 QString ProcessInfo::currentDir(bool *ok) const
 {
     if (ok != nullptr) {
         *ok = (_fields & CURRENT_DIR) != 0;
     }
 
     return _currentDir;
 }
 
 void ProcessInfo::setCurrentDir(const QString &dir)
 {
     _fields |= CURRENT_DIR;
     _currentDir = dir;
 }
 
 void ProcessInfo::setName(const QString &name)
 {
     _name = name;
     _fields |= NAME;
 }
 
 void ProcessInfo::addArgument(const QString &argument)
 {
     _arguments << argument;
 }
 
 void ProcessInfo::clearArguments()
 {
     _arguments.clear();
 }
 
 void ProcessInfo::setFileError(QFile::FileError error)
 {
     switch (error) {
     case QFile::PermissionsError:
         setError(ProcessInfo::PermissionsError);
         break;
     case QFile::NoError:
         setError(ProcessInfo::NoError);
         break;
     default:
         setError(ProcessInfo::UnknownError);
     }
 }
 
 //
 // ProcessInfo::newInstance() is way at the bottom so it can see all of the
 // implementations of the UnixProcessInfo abstract class.
 //
 
 NullProcessInfo::NullProcessInfo(int pid) :
     ProcessInfo(pid)
 {
 }
 
 void NullProcessInfo::readProcessInfo(int /*pid*/)
 {
 }
 
 bool NullProcessInfo::readCurrentDir(int /*pid*/)
 {
     return false;
 }
 
 void NullProcessInfo::readUserName()
 {
 }
 
 #if !defined(Q_OS_WIN)
 UnixProcessInfo::UnixProcessInfo(int pid) :
     ProcessInfo(pid)
 {
     setUserNameRequired(true);
 }
 
 void UnixProcessInfo::readProcessInfo(int pid)
 {
     // prevent _arguments from growing longer and longer each time this
     // method is called.
     clearArguments();
 
     if (readProcInfo(pid)) {
         readArguments(pid);
         readCurrentDir(pid);
 
         bool ok = false;
         const QString &processNameString = name(&ok);
 
         if (ok && processNameString == QLatin1String("sudo")) {
             //Append process name along with sudo
             const QVector<QString> &args = arguments(&ok);
 
             if (ok && args.size() > 1) {
                 setName(processNameString + QStringLiteral(" ") + args[1]);
             }
         }
     }
 }
 
 void UnixProcessInfo::readUserName()
 {
     bool ok = false;
     const int uid = userId(&ok);
     if (!ok) {
         return;
     }
 
     struct passwd passwdStruct;
     struct passwd *getpwResult;
     char *getpwBuffer;
     long getpwBufferSize;
     int getpwStatus;
 
     getpwBufferSize = sysconf(_SC_GETPW_R_SIZE_MAX);
     if (getpwBufferSize == -1) {
         getpwBufferSize = 16384;
     }
 
     getpwBuffer = new char[getpwBufferSize];
     if (getpwBuffer == nullptr) {
         return;
     }
     getpwStatus = getpwuid_r(uid, &passwdStruct, getpwBuffer, getpwBufferSize, &getpwResult);
     if ((getpwStatus == 0) && (getpwResult != nullptr)) {
         setUserName(QLatin1String(passwdStruct.pw_name));
     } else {
         setUserName(QString());
         qWarning() << "getpwuid_r returned error : " << getpwStatus;
     }
     delete [] getpwBuffer;
 }
 
 #endif
 
 #if defined(Q_OS_LINUX)
 class LinuxProcessInfo : public UnixProcessInfo
 {
 public:
     LinuxProcessInfo(int pid) :
         UnixProcessInfo(pid)
     {
     }
 
 protected:
     bool readCurrentDir(int pid) override
     {
         char path_buffer[MAXPATHLEN + 1];
         path_buffer[MAXPATHLEN] = 0;
         QByteArray procCwd = QFile::encodeName(QStringLiteral("/proc/%1/cwd").arg(pid));
         const auto length = static_cast<int>(readlink(procCwd.constData(), path_buffer, MAXPATHLEN));
         if (length == -1) {
             setError(UnknownError);
             return false;
         }
 
         path_buffer[length] = '\0';
         QString path = QFile::decodeName(path_buffer);
 
         setCurrentDir(path);
         return true;
     }
 
 private:
     bool readProcInfo(int pid) override
     {
         // indicies of various fields within the process status file which
         // contain various information about the process
         const int PARENT_PID_FIELD = 3;
         const int PROCESS_NAME_FIELD = 1;
         const int GROUP_PROCESS_FIELD = 7;
 
         QString parentPidString;
         QString processNameString;
         QString foregroundPidString;
         QString uidLine;
         QString uidString;
         QStringList uidStrings;
 
         // For user id read process status file ( /proc/<pid>/status )
         //  Can not use getuid() due to it does not work for 'su'
         QFile statusInfo(QStringLiteral("/proc/%1/status").arg(pid));
         if (statusInfo.open(QIODevice::ReadOnly)) {
             QTextStream stream(&statusInfo);
             QString statusLine;
             do {
                 statusLine = stream.readLine();
                 if (statusLine.startsWith(QLatin1String("Uid:"))) {
                     uidLine = statusLine;
                 }
             } while (!statusLine.isNull() && uidLine.isNull());
 
             uidStrings << uidLine.split(QLatin1Char('\t'), QString::SkipEmptyParts);
             // Must be 5 entries: 'Uid: %d %d %d %d' and
             // uid string must be less than 5 chars (uint)
             if (uidStrings.size() == 5) {
                 uidString = uidStrings[1];
             }
             if (uidString.size() > 5) {
                 uidString.clear();
             }
 
             bool ok = false;
             const int uid = uidString.toInt(&ok);
             if (ok) {
                 setUserId(uid);
             }
             // This will cause constant opening of /etc/passwd
             if (userNameRequired()) {
                 readUserName();
                 setUserNameRequired(false);
             }
         } else {
             setFileError(statusInfo.error());
             return false;
         }
 
         // read process status file ( /proc/<pid/stat )
         //
         // the expected file format is a list of fields separated by spaces, using
         // parentheses to escape fields such as the process name which may itself contain
         // spaces:
         //
         // FIELD FIELD (FIELD WITH SPACES) FIELD FIELD
         //
         QFile processInfo(QStringLiteral("/proc/%1/stat").arg(pid));
         if (processInfo.open(QIODevice::ReadOnly)) {
             QTextStream stream(&processInfo);
             const QString &data = stream.readAll();
 
             int stack = 0;
             int field = 0;
             int pos = 0;
 
             while (pos < data.count()) {
                 QChar c = data[pos];
 
                 if (c == QLatin1Char('(')) {
                     stack++;
                 } else if (c == QLatin1Char(')')) {
                     stack--;
                 } else if (stack == 0 && c == QLatin1Char(' ')) {
                     field++;
                 } else {
                     switch (field) {
                     case PARENT_PID_FIELD:
                         parentPidString.append(c);
                         break;
                     case PROCESS_NAME_FIELD:
                         processNameString.append(c);
                         break;
                     case GROUP_PROCESS_FIELD:
                         foregroundPidString.append(c);
                         break;
                     }
                 }
 
                 pos++;
             }
         } else {
             setFileError(processInfo.error());
             return false;
         }
 
         // check that data was read successfully
         bool ok = false;
         const int foregroundPid = foregroundPidString.toInt(&ok);
         if (ok) {
             setForegroundPid(foregroundPid);
         }
 
         const int parentPid = parentPidString.toInt(&ok);
         if (ok) {
             setParentPid(parentPid);
         }
 
         if (!processNameString.isEmpty()) {
             setName(processNameString);
         }
 
         // update object state
         setPid(pid);
 
         return ok;
     }
 
     bool readArguments(int pid) override
     {
         // read command-line arguments file found at /proc/<pid>/cmdline
         // the expected format is a list of strings delimited by null characters,
         // and ending in a double null character pair.
 
         QFile argumentsFile(QStringLiteral("/proc/%1/cmdline").arg(pid));
         if (argumentsFile.open(QIODevice::ReadOnly)) {
             QTextStream stream(&argumentsFile);
             const QString &data = stream.readAll();
 
             const QStringList &argList = data.split(QLatin1Char('\0'));
 
             for (const QString &entry : argList) {
                 if (!entry.isEmpty()) {
                     addArgument(entry);
                 }
             }
         } else {
             setFileError(argumentsFile.error());
         }
 
         return true;
     }
 };
 
 #elif defined(Q_OS_FREEBSD)
 class FreeBSDProcessInfo : public UnixProcessInfo
 {
 public:
     FreeBSDProcessInfo(int pid) :
         UnixProcessInfo(pid)
     {
     }
 
 protected:
     bool readCurrentDir(int pid) override
     {
 #if defined(HAVE_OS_DRAGONFLYBSD)
         char buf[PATH_MAX];
         int managementInfoBase[4];
         size_t len;
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC;
         managementInfoBase[2] = KERN_PROC_CWD;
         managementInfoBase[3] = pid;
 
         len = sizeof(buf);
         if (sysctl(managementInfoBase, 4, buf, &len, NULL, 0) == -1) {
             return false;
         }
 
         setCurrentDir(QString::fromUtf8(buf));
 
         return true;
 #else
         int numrecords;
         struct kinfo_file *info = nullptr;
 
         info = kinfo_getfile(pid, &numrecords);
 
         if (!info) {
             return false;
         }
 
         for (int i = 0; i < numrecords; ++i) {
             if (info[i].kf_fd == KF_FD_TYPE_CWD) {
                 setCurrentDir(QString::fromUtf8(info[i].kf_path));
 
                 free(info);
                 return true;
             }
         }
 
         free(info);
         return false;
 #endif
     }
 
 private:
     bool readProcInfo(int pid) override
     {
         int managementInfoBase[4];
         size_t mibLength;
         struct kinfo_proc *kInfoProc;
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC;
         managementInfoBase[2] = KERN_PROC_PID;
         managementInfoBase[3] = pid;
 
         if (sysctl(managementInfoBase, 4, NULL, &mibLength, NULL, 0) == -1) {
             return false;
         }
 
         kInfoProc = new struct kinfo_proc [mibLength];
 
         if (sysctl(managementInfoBase, 4, kInfoProc, &mibLength, NULL, 0) == -1) {
             delete [] kInfoProc;
             return false;
         }
 
 #if defined(HAVE_OS_DRAGONFLYBSD)
         setName(QString::fromUtf8(kInfoProc->kp_comm));
         setPid(kInfoProc->kp_pid);
         setParentPid(kInfoProc->kp_ppid);
         setForegroundPid(kInfoProc->kp_pgid);
         setUserId(kInfoProc->kp_uid);
 #else
         setName(QString::fromUtf8(kInfoProc->ki_comm));
         setPid(kInfoProc->ki_pid);
         setParentPid(kInfoProc->ki_ppid);
         setForegroundPid(kInfoProc->ki_pgid);
         setUserId(kInfoProc->ki_uid);
 #endif
 
         readUserName();
 
         delete [] kInfoProc;
         return true;
     }
 
     bool readArguments(int pid) override
     {
         char args[ARG_MAX];
         int managementInfoBase[4];
         size_t len;
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC;
         managementInfoBase[2] = KERN_PROC_ARGS;
         managementInfoBase[3] = pid;
 
         len = sizeof(args);
         if (sysctl(managementInfoBase, 4, args, &len, NULL, 0) == -1) {
             return false;
         }
 
         // len holds the length of the string
         const QStringList argurments = QString::fromLocal8Bit(args, len).split(QLatin1Char('\u0000'));
         for (const QString &value : argurments) {
             if (!value.isEmpty()) {
                 addArgument(value);
             }
         }
 
         return true;
     }
 };
 
 #elif defined(Q_OS_OPENBSD)
 class OpenBSDProcessInfo : public UnixProcessInfo
 {
 public:
     OpenBSDProcessInfo(int pid) :
         UnixProcessInfo(pid)
     {
     }
 
 protected:
     bool readCurrentDir(int pid) override
     {
         char buf[PATH_MAX];
         int managementInfoBase[3];
         size_t len;
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC_CWD;
         managementInfoBase[2] = pid;
 
         len = sizeof(buf);
         if (::sysctl(managementInfoBase, 3, buf, &len, NULL, 0) == -1) {
             qWarning() << "sysctl() call failed with code" << errno;
             return false;
         }
 
         setCurrentDir(QString::fromUtf8(buf));
         return true;
     }
 
 private:
     bool readProcInfo(int pid) override
     {
         int managementInfoBase[6];
         size_t mibLength;
         struct kinfo_proc *kInfoProc;
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC;
         managementInfoBase[2] = KERN_PROC_PID;
         managementInfoBase[3] = pid;
         managementInfoBase[4] = sizeof(struct kinfo_proc);
         managementInfoBase[5] = 1;
 
         if (::sysctl(managementInfoBase, 6, NULL, &mibLength, NULL, 0) == -1) {
             qWarning() << "first sysctl() call failed with code" << errno;
             return false;
         }
 
         kInfoProc = (struct kinfo_proc *)malloc(mibLength);
 
         if (::sysctl(managementInfoBase, 6, kInfoProc, &mibLength, NULL, 0) == -1) {
             qWarning() << "second sysctl() call failed with code" << errno;
             free(kInfoProc);
             return false;
         }
 
         setName(kInfoProc->p_comm);
         setPid(kInfoProc->p_pid);
         setParentPid(kInfoProc->p_ppid);
         setForegroundPid(kInfoProc->p_tpgid);
         setUserId(kInfoProc->p_uid);
         setUserName(kInfoProc->p_login);
 
         free(kInfoProc);
         return true;
     }
 
     char **readProcArgs(int pid, int whatMib)
     {
         void *buf = NULL;
         void *nbuf;
         size_t len = 4096;
         int rc = -1;
         int managementInfoBase[4];
 
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC_ARGS;
         managementInfoBase[2] = pid;
         managementInfoBase[3] = whatMib;
 
         do {
             len *= 2;
             nbuf = realloc(buf, len);
             if (nbuf == NULL) {
                 break;
             }
 
             buf = nbuf;
             rc = ::sysctl(managementInfoBase, 4, buf, &len, NULL, 0);
             qWarning() << "sysctl() call failed with code" << errno;
         } while (rc == -1 && errno == ENOMEM);
 
         if (nbuf == NULL || rc == -1) {
             free(buf);
             return NULL;
         }
 
         return (char **)buf;
     }
 
     bool readArguments(int pid) override
     {
         char **argv;
 
         argv = readProcArgs(pid, KERN_PROC_ARGV);
         if (argv == NULL) {
             return false;
         }
 
         for (char **p = argv; *p != NULL; p++) {
             addArgument(QString(*p));
         }
         free(argv);
         return true;
     }
 };
 
 #elif defined(Q_OS_MACOS)
 class MacProcessInfo : public UnixProcessInfo
 {
 public:
     MacProcessInfo(int pid) :
         UnixProcessInfo(pid)
     {
     }
 
 protected:
     bool readCurrentDir(int pid) override
     {
         struct proc_vnodepathinfo vpi;
         const int nb = proc_pidinfo(pid, PROC_PIDVNODEPATHINFO, 0, &vpi, sizeof(vpi));
         if (nb == sizeof(vpi)) {
             setCurrentDir(QString::fromUtf8(vpi.pvi_cdir.vip_path));
             return true;
         }
         return false;
     }
 
 private:
     bool readProcInfo(int pid) override
     {
         int managementInfoBase[4];
         size_t mibLength;
         struct kinfo_proc *kInfoProc;
         QT_STATBUF statInfo;
 
         // Find the tty device of 'pid' (Example: /dev/ttys001)
         managementInfoBase[0] = CTL_KERN;
         managementInfoBase[1] = KERN_PROC;
         managementInfoBase[2] = KERN_PROC_PID;
         managementInfoBase[3] = pid;
 
         if (sysctl(managementInfoBase, 4, nullptr, &mibLength, nullptr, 0) == -1) {
             return false;
         } else {
             kInfoProc = new struct kinfo_proc [mibLength];
             if (sysctl(managementInfoBase, 4, kInfoProc, &mibLength, nullptr, 0) == -1) {
                 delete [] kInfoProc;
                 return false;
             } else {
                 const QString deviceNumber = QString::fromUtf8(devname(((&kInfoProc->kp_eproc)->e_tdev), S_IFCHR));
                 const QString fullDeviceName = QStringLiteral("/dev/")
                                                + deviceNumber.rightJustified(3, QLatin1Char('0'));
                 delete [] kInfoProc;
 
                 const QByteArray deviceName = fullDeviceName.toLatin1();
                 const char *ttyName = deviceName.data();
 
                 if (QT_STAT(ttyName, &statInfo) != 0) {
                     return false;
                 }
 
                 // Find all processes attached to ttyName
                 managementInfoBase[0] = CTL_KERN;
                 managementInfoBase[1] = KERN_PROC;
                 managementInfoBase[2] = KERN_PROC_TTY;
                 managementInfoBase[3] = statInfo.st_rdev;
 
                 mibLength = 0;
                 if (sysctl(managementInfoBase, sizeof(managementInfoBase) / sizeof(int), nullptr,
                            &mibLength, nullptr, 0) == -1) {
                     return false;
                 }
 
                 kInfoProc = new struct kinfo_proc [mibLength];
                 if (sysctl(managementInfoBase, sizeof(managementInfoBase) / sizeof(int), kInfoProc,
                            &mibLength, nullptr, 0) == -1) {
                     return false;
                 }
 
                 // The foreground program is the first one
                 setName(QString::fromUtf8(kInfoProc->kp_proc.p_comm));
 
                 delete [] kInfoProc;
             }
             setPid(pid);
         }
         return true;
     }
 
     bool readArguments(int pid) override
     {
-        Q_UNUSED(pid);
+        Q_UNUSED(pid)
         return false;
     }
 };
 
 #elif defined(Q_OS_SOLARIS)
 // The procfs structure definition requires off_t to be
 // 32 bits, which only applies if FILE_OFFSET_BITS=32.
 // Futz around here to get it to compile regardless,
 // although some of the structure sizes might be wrong.
 // Fortunately, the structures we actually use don't use
 // off_t, and we're safe.
 #if defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
 #undef _FILE_OFFSET_BITS
 #endif
 #include <procfs.h>
 
 class SolarisProcessInfo : public UnixProcessInfo
 {
 public:
     SolarisProcessInfo(int pid) :
         UnixProcessInfo(pid)
     {
     }
 
 protected:
     // FIXME: This will have the same issues as BKO 251351; the Linux
     // version uses readlink.
     bool readCurrentDir(int pid) override
     {
         QFileInfo info(QString("/proc/%1/path/cwd").arg(pid));
         const bool readable = info.isReadable();
 
         if (readable && info.isSymLink()) {
             setCurrentDir(info.symLinkTarget());
             return true;
         } else {
             if (!readable) {
                 setError(PermissionsError);
             } else {
                 setError(UnknownError);
             }
 
             return false;
         }
     }
 
 private:
     bool readProcInfo(int pid) override
     {
         QFile psinfo(QString("/proc/%1/psinfo").arg(pid));
         if (psinfo.open(QIODevice::ReadOnly)) {
             struct psinfo info;
             if (psinfo.read((char *)&info, sizeof(info)) != sizeof(info)) {
                 return false;
             }
 
             setParentPid(info.pr_ppid);
             setForegroundPid(info.pr_pgid);
             setName(info.pr_fname);
             setPid(pid);
 
             // Bogus, because we're treating the arguments as one single string
             info.pr_psargs[PRARGSZ - 1] = 0;
             addArgument(info.pr_psargs);
         }
         return true;
     }
 
     bool readArguments(int /*pid*/) override
     {
         // Handled in readProcInfo()
         return false;
     }
 };
 #endif
 
 SSHProcessInfo::SSHProcessInfo(const ProcessInfo &process) :
     _process(process),
     _user(QString()),
     _host(QString()),
     _port(QString()),
     _command(QString())
 {
     bool ok = false;
 
     // check that this is a SSH process
     const QString &name = _process.name(&ok);
 
     if (!ok || name != QLatin1String("ssh")) {
         if (!ok) {
             qWarning() << "Could not read process info";
         } else {
             qWarning() << "Process is not a SSH process";
         }
 
         return;
     }
 
     // read arguments
     const QVector<QString> &args = _process.arguments(&ok);
 
     // SSH options
     // these are taken from the SSH manual ( accessed via 'man ssh' )
 
     // options which take no arguments
     static const QString noArgumentOptions(QStringLiteral("1246AaCfgKkMNnqsTtVvXxYy"));
     // options which take one argument
     static const QString singleArgumentOptions(QStringLiteral("bcDeFIiLlmOopRSWw"));
 
     if (ok) {
         // find the username, host and command arguments
         //
         // the username/host is assumed to be the first argument
         // which is not an option
         // ( ie. does not start with a dash '-' character )
         // or an argument to a previous option.
         //
         // the command, if specified, is assumed to be the argument following
         // the username and host
         //
         // note that we skip the argument at index 0 because that is the
         // program name ( expected to be 'ssh' in this case )
         for (int i = 1; i < args.count(); i++) {
             // If this one is an option ...
             // Most options together with its argument will be skipped.
             if (args[i].startsWith(QLatin1Char('-'))) {
                 const QChar optionChar = (args[i].length() > 1) ? args[i][1] : QLatin1Char('\0');
                 // for example: -p2222 or -p 2222 ?
                 const bool optionArgumentCombined = args[i].length() > 2;
 
                 if (noArgumentOptions.contains(optionChar)) {
                     continue;
                 } else if (singleArgumentOptions.contains(optionChar)) {
                     QString argument;
                     if (optionArgumentCombined) {
                         argument = args[i].mid(2);
                     } else {
                         // Verify correct # arguments are given
                         if ((i + 1) < args.count()) {
                             argument = args[i + 1];
                         }
                         i++;
                     }
 
                     // support using `-l user` to specify username.
                     if (optionChar == QLatin1Char('l')) {
                         _user = argument;
                     }
                     // support using `-p port` to specify port.
                     else if (optionChar == QLatin1Char('p')) {
                         _port = argument;
                     }
 
                     continue;
                 }
             }
 
             // check whether the host has been found yet
             // if not, this must be the username/host argument
             if (_host.isEmpty()) {
                 // check to see if only a hostname is specified, or whether
                 // both a username and host are specified ( in which case they
                 // are separated by an '@' character:  username@host )
 
                 const int separatorPosition = args[i].indexOf(QLatin1Char('@'));
                 if (separatorPosition != -1) {
                     // username and host specified
                     _user = args[i].left(separatorPosition);
                     _host = args[i].mid(separatorPosition + 1);
                 } else {
                     // just the host specified
                     _host = args[i];
                 }
             } else {
                 // host has already been found, this must be part of the
                 // command arguments.
                 // Note this is not 100% correct.  If any of the above
                 // noArgumentOptions or singleArgumentOptions are found, this
                 // will not be correct (example ssh server top -i 50)
                 // Suggest putting ssh command in quotes
                 if (_command.isEmpty()) {
                     _command = args[i];
                 } else {
                     _command = _command + QLatin1Char(' ') + args[i];
                 }
             }
         }
     } else {
         qWarning() << "Could not read arguments";
 
         return;
     }
 }
 
 QString SSHProcessInfo::userName() const
 {
     return _user;
 }
 
 QString SSHProcessInfo::host() const
 {
     return _host;
 }
 
 QString SSHProcessInfo::port() const
 {
     return _port;
 }
 
 QString SSHProcessInfo::command() const
 {
     return _command;
 }
 
 QString SSHProcessInfo::format(const QString &input) const
 {
     QString output(input);
 
     // search for and replace known markers
     output.replace(QLatin1String("%u"), _user);
 
     // provide 'user@' if user is defined -- this makes nicer
     // remote tabs possible: "%U%h %c" => User@Host Command
     //                                 => Host Command
     // Depending on whether -l was passed to ssh (which is mostly not the
     // case due to ~/.ssh/config).
     if (_user.isEmpty()) {
         output.remove(QLatin1String("%U"));
     } else {
         output.replace(QLatin1String("%U"), _user + QLatin1Char('@'));
     }
 
     // test whether host is an ip address
     // in which case 'short host' and 'full host'
     // markers in the input string are replaced with
     // the full address
     struct in_addr address;
     const bool isIpAddress = inet_aton(_host.toLocal8Bit().constData(), &address) != 0;
     if (isIpAddress) {
         output.replace(QLatin1String("%h"), _host);
     } else {
         output.replace(QLatin1String("%h"), _host.left(_host.indexOf(QLatin1Char('.'))));
     }
 
     output.replace(QLatin1String("%H"), _host);
     output.replace(QLatin1String("%c"), _command);
 
     return output;
 }
 
 ProcessInfo *ProcessInfo::newInstance(int pid)
 {
     ProcessInfo *info;
 #if defined(Q_OS_LINUX)
     info = new LinuxProcessInfo(pid);
 #elif defined(Q_OS_SOLARIS)
     info = new SolarisProcessInfo(pid);
 #elif defined(Q_OS_MACOS)
     info = new MacProcessInfo(pid);
 #elif defined(Q_OS_FREEBSD)
     info = new FreeBSDProcessInfo(pid);
 #elif defined(Q_OS_OPENBSD)
     info = new OpenBSDProcessInfo(pid);
 #else
     info = new NullProcessInfo(pid);
 #endif
     info->readProcessInfo(pid);
     return info;
 }
diff --git a/src/Pty.cpp b/src/Pty.cpp
index 6ce3a824..b75544ab 100644
--- a/src/Pty.cpp
+++ b/src/Pty.cpp
@@ -1,341 +1,341 @@
 /*
     This file is part of Konsole, an X terminal.
     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 "Pty.h"
 
 #include "konsoledebug.h"
 
 // System
 #include <termios.h>
 #include <csignal>
 
 // Qt
 #include <QStringList>
 #include <qplatformdefs.h>
 
 // KDE
 #include <KPtyDevice>
 
 using Konsole::Pty;
 
 Pty::Pty(int masterFd, QObject *aParent) :
     KPtyProcess(masterFd, aParent)
 {
     init();
 }
 
 Pty::Pty(QObject *aParent) :
     KPtyProcess(aParent)
 {
     init();
 }
 
 void Pty::init()
 {
     _windowColumns = 0;
     _windowLines = 0;
     _eraseChar = 0;
     _xonXoff = true;
     _utf8 = true;
 
     setEraseChar(_eraseChar);
     setFlowControlEnabled(_xonXoff);
     setUtf8Mode(_utf8);
 
     setWindowSize(_windowColumns, _windowLines);
 
     setUseUtmp(true);
     setPtyChannels(KPtyProcess::AllChannels);
 
     connect(pty(), &KPtyDevice::readyRead, this, &Konsole::Pty::dataReceived);
 }
 
 Pty::~Pty() = default;
 
 void Pty::sendData(const QByteArray &data)
 {
     if (data.isEmpty()) {
         return;
     }
 
     if (pty()->write(data) == -1) {
         qCDebug(KonsoleDebug) << "Could not send input data to terminal process.";
         return;
     }
 }
 
 void Pty::dataReceived()
 {
     QByteArray data = pty()->readAll();
     if (data.isEmpty()) {
         return;
     }
 
     emit receivedData(data.constData(), data.count());
 }
 
 void Pty::setWindowSize(int columns, int lines)
 {
     _windowColumns = columns;
     _windowLines = lines;
 
     if (pty()->masterFd() >= 0) {
         pty()->setWinSize(lines, columns);
     }
 }
 
 QSize Pty::windowSize() const
 {
     return {_windowColumns, _windowLines};
 }
 
 void Pty::setFlowControlEnabled(bool enable)
 {
     _xonXoff = enable;
 
     if (pty()->masterFd() >= 0) {
         struct ::termios ttmode;
         pty()->tcGetAttr(&ttmode);
         if (enable) {
             ttmode.c_iflag |= (IXOFF | IXON);
         } else {
             ttmode.c_iflag &= ~(IXOFF | IXON);
         }
 
         if (!pty()->tcSetAttr(&ttmode)) {
             qCDebug(KonsoleDebug) << "Unable to set terminal attributes.";
         }
     }
 }
 
 bool Pty::flowControlEnabled() const
 {
     if (pty()->masterFd() >= 0) {
         struct ::termios ttmode;
         pty()->tcGetAttr(&ttmode);
         return ((ttmode.c_iflag & IXOFF) != 0u)
                && ((ttmode.c_iflag & IXON) != 0u);
     } else {
         qCDebug(KonsoleDebug) << "Unable to get flow control status, terminal not connected.";
         return _xonXoff;
     }
 }
 
 void Pty::setUtf8Mode(bool enable)
 {
 #if defined(IUTF8) // XXX not a reasonable place to check it.
     _utf8 = enable;
 
     if (pty()->masterFd() >= 0) {
         struct ::termios ttmode;
         pty()->tcGetAttr(&ttmode);
         if (enable) {
             ttmode.c_iflag |= IUTF8;
         } else {
             ttmode.c_iflag &= ~IUTF8;
         }
 
         if (!pty()->tcSetAttr(&ttmode)) {
             qCDebug(KonsoleDebug) << "Unable to set terminal attributes.";
         }
     }
 #else
-    Q_UNUSED(enable);
+    Q_UNUSED(enable)
 #endif
 }
 
 void Pty::setEraseChar(char eChar)
 {
     _eraseChar = eChar;
 
     if (pty()->masterFd() >= 0) {
         struct ::termios ttmode;
         pty()->tcGetAttr(&ttmode);
         ttmode.c_cc[VERASE] = eChar;
 
         if (!pty()->tcSetAttr(&ttmode)) {
             qCDebug(KonsoleDebug) << "Unable to set terminal attributes.";
         }
     }
 }
 
 char Pty::eraseChar() const
 {
     if (pty()->masterFd() >= 0) {
         struct ::termios ttyAttributes;
         pty()->tcGetAttr(&ttyAttributes);
         return ttyAttributes.c_cc[VERASE];
     } else {
         qCDebug(KonsoleDebug) << "Unable to get erase char attribute, terminal not connected.";
         return _eraseChar;
     }
 }
 
 void Pty::setInitialWorkingDirectory(const QString &dir)
 {
     QString pwd = dir;
 
     // remove trailing slash in the path when appropriate
     // example: /usr/share/icons/ ==> /usr/share/icons
     if (pwd.length() > 1 && pwd.endsWith(QLatin1Char('/'))) {
         pwd.chop(1);
     }
 
     setWorkingDirectory(pwd);
 
     // setting PWD to "." will cause problem for bash & zsh
     if (pwd != QLatin1String(".")) {
         setEnv(QStringLiteral("PWD"), pwd);
     }
 }
 
 void Pty::addEnvironmentVariables(const QStringList &environmentVariables)
 {
     bool isTermEnvAdded = false;
 
     for (const QString &pair : environmentVariables) {
         // split on the first '=' character
         const int separator = pair.indexOf(QLatin1Char('='));
 
         if (separator >= 0) {
             QString variable = pair.left(separator);
             QString value = pair.mid(separator + 1);
 
             setEnv(variable, value);
 
             if (variable == QLatin1String("TERM")) {
                 isTermEnvAdded = true;
             }
         }
     }
 
     // extra safeguard to make sure $TERM is always set
     if (!isTermEnvAdded) {
         setEnv(QStringLiteral("TERM"), QStringLiteral("xterm-256color"));
     }
 }
 
 int Pty::start(const QString &programName, const QStringList &programArguments,
                const QStringList &environmentList)
 {
     clearProgram();
 
     // For historical reasons, the first argument in programArguments is the
     // name of the program to execute, so create a list consisting of all
     // but the first argument to pass to setProgram()
     Q_ASSERT(programArguments.count() >= 1);
     setProgram(programName, programArguments.mid(1));
 
     addEnvironmentVariables(environmentList);
 
     // unless the LANGUAGE environment variable has been set explicitly
     // set it to a null string
     // this fixes the problem where KCatalog sets the LANGUAGE environment
     // variable during the application's startup to something which
     // differs from LANG,LC_* etc. and causes programs run from
     // the terminal to display messages in the wrong language
     //
     // this can happen if LANG contains a language which KDE
     // does not have a translation for
     //
     // BR:149300
     setEnv(QStringLiteral("LANGUAGE"), QString(),
            false /* do not overwrite existing value if any */);
 
     KProcess::start();
 
     if (waitForStarted()) {
         return 0;
     } else {
         return -1;
     }
 }
 
 void Pty::setWriteable(bool writeable)
 {
     QT_STATBUF sbuf;
     if (QT_STAT(pty()->ttyName(), &sbuf) == 0) {
         if (writeable) {
             if (::chmod(pty()->ttyName(), sbuf.st_mode | S_IWGRP) < 0) {
                 qCDebug(KonsoleDebug) << "Could not set writeable on "<<pty()->ttyName();
             }
         } else {
             if (::chmod(pty()->ttyName(), sbuf.st_mode & ~(S_IWGRP | S_IWOTH)) < 0) {
                 qCDebug(KonsoleDebug) << "Could not unset writeable on "<<pty()->ttyName();
             }
         }
     } else {
         qCDebug(KonsoleDebug) << "Could not stat "<<pty()->ttyName();
     }
 }
 
 void Pty::closePty()
 {
     pty()->close();
 }
 
 void Pty::sendEof()
 {
     if (pty()->masterFd() < 0) {
         qCDebug(KonsoleDebug) << "Unable to get eof char attribute, terminal not connected.";
         return;
     }
     struct ::termios ttyAttributes;
     pty()->tcGetAttr(&ttyAttributes);
     char eofChar = ttyAttributes.c_cc[VEOF];
     if (pty()->write(QByteArray(1, eofChar)) == -1) {
         qCDebug(KonsoleDebug) << "Unable to send EOF";
     }
 
     pty()->waitForBytesWritten();
 }
 
 int Pty::foregroundProcessGroup() const
 {
     const int master_fd = pty()->masterFd();
 
     if (master_fd >= 0) {
         int foregroundPid = tcgetpgrp(master_fd);
 
         if (foregroundPid != -1) {
             return foregroundPid;
         }
     }
 
     return 0;
 }
 
 void Pty::setupChildProcess()
 {
     KPtyProcess::setupChildProcess();
 
     // reset all signal handlers
     // this ensures that terminal applications respond to
     // signals generated via key sequences such as Ctrl+C
     // (which sends SIGINT)
     struct sigaction action;
     sigemptyset(&action.sa_mask);
     action.sa_handler = SIG_DFL;
     action.sa_flags = 0;
     for (int signal = 1; signal < NSIG; signal++) {
         sigaction(signal, &action, nullptr);
     }
 }
diff --git a/src/Screen.cpp b/src/Screen.cpp
index 1efdd7da..98913f59 100644
--- a/src/Screen.cpp
+++ b/src/Screen.cpp
@@ -1,1503 +1,1503 @@
 /*
    This file is part of Konsole, an X terminal.
 
    Copyright 2007-2008 by Robert Knight <robert.knight@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 "Screen.h"
 
 // Qt
 #include <QTextStream>
 
 // Konsole
 #include "TerminalCharacterDecoder.h"
 #include "History.h"
 #include "ExtendedCharTable.h"
 
 using namespace Konsole;
 
 //Macro to convert x,y position on screen to position within an image.
 //
 //Originally the image was stored as one large contiguous block of
 //memory, so a position within the image could be represented as an
 //offset from the beginning of the block.  For efficiency reasons this
 //is no longer the case.
 //Many internal parts of this class still use this representation for parameters and so on,
 //notably moveImage() and clearImage().
 //This macro converts from an X,Y position into an image offset.
 #ifndef loc
 #define loc(X,Y) ((Y)*_columns+(X))
 #endif
 
 const Character Screen::DefaultChar = Character(' ',
                                       CharacterColor(COLOR_SPACE_DEFAULT, DEFAULT_FORE_COLOR),
                                       CharacterColor(COLOR_SPACE_DEFAULT, DEFAULT_BACK_COLOR),
                                       DEFAULT_RENDITION,
                                       false);
 
 Screen::Screen(int lines, int columns):
     _currentTerminalDisplay(nullptr),
     _lines(lines),
     _columns(columns),
     _screenLines(new ImageLine[_lines + 1]),
     _screenLinesSize(_lines),
     _scrolledLines(0),
     _lastScrolledRegion(QRect()),
     _droppedLines(0),
     _lineProperties(QVarLengthArray<LineProperty, 64>()),
     _history(new HistoryScrollNone()),
     _cuX(0),
     _cuY(0),
     _currentForeground(CharacterColor()),
     _currentBackground(CharacterColor()),
     _currentRendition(DEFAULT_RENDITION),
     _topMargin(0),
     _bottomMargin(0),
     _tabStops(QBitArray()),
     _selBegin(0),
     _selTopLeft(0),
     _selBottomRight(0),
     _blockSelectionMode(false),
     _effectiveForeground(CharacterColor()),
     _effectiveBackground(CharacterColor()),
     _effectiveRendition(DEFAULT_RENDITION),
     _lastPos(-1),
     _lastDrawnChar(0)
 {
     _lineProperties.resize(_lines + 1);
     for (int i = 0; i < _lines + 1; i++) {
         _lineProperties[i] = LINE_DEFAULT;
     }
 
     initTabStops();
     clearSelection();
     reset();
 }
 
 Screen::~Screen()
 {
     delete[] _screenLines;
     delete _history;
 }
 
 void Screen::cursorUp(int n)
 //=CUU
 {
     if (n == 0) {
         n = 1; // Default
     }
     const int stop = _cuY < _topMargin ? 0 : _topMargin;
     _cuX = qMin(_columns - 1, _cuX); // nowrap!
     _cuY = qMax(stop, _cuY - n);
 }
 
 void Screen::cursorDown(int n)
 //=CUD
 {
     if (n == 0) {
        n = 1; // Default
     }
     const int stop = _cuY > _bottomMargin ? _lines - 1 : _bottomMargin;
     _cuX = qMin(_columns - 1, _cuX); // nowrap!
     _cuY = qMin(stop, _cuY + n);
 }
 
 void Screen::cursorLeft(int n)
 //=CUB
 {
     if (n == 0) {
         n = 1; // Default
     }
     _cuX = qMin(_columns - 1, _cuX); // nowrap!
     _cuX = qMax(0, _cuX - n);
 }
 
 void Screen::cursorRight(int n)
 //=CUF
 {
     if (n == 0) {
         n = 1; // Default
     }
     _cuX = qMin(_columns - 1, _cuX + n);
 }
 
 void Screen::setMargins(int top, int bot)
 //=STBM
 {
     if (top == 0) {
         top = 1;      // Default
     }
     if (bot == 0) {
         bot = _lines;  // Default
     }
     top = top - 1;              // Adjust to internal lineno
     bot = bot - 1;              // Adjust to internal lineno
     if (!(0 <= top && top < bot && bot < _lines)) {
         //Debug()<<" setRegion("<<top<<","<<bot<<") : bad range.";
         return;                   // Default error action: ignore
     }
     _topMargin = top;
     _bottomMargin = bot;
     _cuX = 0;
     _cuY = getMode(MODE_Origin) ? top : 0;
 }
 
 int Screen::topMargin() const
 {
     return _topMargin;
 }
 int Screen::bottomMargin() const
 {
     return _bottomMargin;
 }
 
 void Screen::index()
 //=IND
 {
     if (_cuY == _bottomMargin) {
         scrollUp(1);
     } else if (_cuY < _lines - 1) {
         _cuY += 1;
     }
 }
 
 void Screen::reverseIndex()
 //=RI
 {
     if (_cuY == _topMargin) {
         scrollDown(_topMargin, 1);
     } else if (_cuY > 0) {
         _cuY -= 1;
     }
 }
 
 void Screen::nextLine()
 //=NEL
 {
     toStartOfLine();
     index();
 }
 
 void Screen::eraseChars(int n)
 {
     if (n == 0) {
         n = 1; // Default
     }
     const int p = qMax(0, qMin(_cuX + n - 1, _columns - 1));
     clearImage(loc(_cuX, _cuY), loc(p, _cuY), ' ');
 }
 
 void Screen::deleteChars(int n)
 {
     Q_ASSERT(n >= 0);
 
     // always delete at least one char
     if (n == 0) {
         n = 1;
     }
 
     // if cursor is beyond the end of the line there is nothing to do
     if (_cuX >= _screenLines[_cuY].count()) {
         return;
     }
 
     if (_cuX + n > _screenLines[_cuY].count()) {
         n = _screenLines[_cuY].count() - _cuX;
     }
 
     Q_ASSERT(n >= 0);
     Q_ASSERT(_cuX + n <= _screenLines[_cuY].count());
 
     _screenLines[_cuY].remove(_cuX, n);
 
     // Append space(s) with current attributes
     Character spaceWithCurrentAttrs(' ', _effectiveForeground,
                                     _effectiveBackground,
                                     _effectiveRendition, false);
 
     for (int i = 0; i < n; i++) {
         _screenLines[_cuY].append(spaceWithCurrentAttrs);
     }
 }
 
 void Screen::insertChars(int n)
 {
     if (n == 0) {
         n = 1; // Default
     }
 
     if (_screenLines[_cuY].size() < _cuX) {
         _screenLines[_cuY].resize(_cuX);
     }
 
     _screenLines[_cuY].insert(_cuX, n, Character(' '));
 
     if (_screenLines[_cuY].count() > _columns) {
         _screenLines[_cuY].resize(_columns);
     }
 }
 
 void Screen::repeatChars(int n)
 {
     if (n == 0) {
         n = 1; // Default
     }
 
     // From ECMA-48 version 5, section 8.3.103:
     // "If the character preceding REP is a control function or part of a
     // control function, the effect of REP is not defined by this Standard."
     //
     // So, a "normal" program should always use REP immediately after a visible
     // character (those other than escape sequences). So, _lastDrawnChar can be
     // safely used.
     for (int i = 0; i < n; i++) {
         displayCharacter(_lastDrawnChar);
     }
 }
 
 void Screen::deleteLines(int n)
 {
     if (n == 0) {
         n = 1; // Default
     }
     scrollUp(_cuY, n);
 }
 
 void Screen::insertLines(int n)
 {
     if (n == 0) {
         n = 1; // Default
     }
     scrollDown(_cuY, n);
 }
 
 void Screen::setMode(int m)
 {
     _currentModes[m] = 1;
     switch (m) {
     case MODE_Origin :
         _cuX = 0;
         _cuY = _topMargin;
         break; //FIXME: home
     }
 }
 
 void Screen::resetMode(int m)
 {
     _currentModes[m] = 0;
     switch (m) {
     case MODE_Origin :
         _cuX = 0;
         _cuY = 0;
         break; //FIXME: home
     }
 }
 
 void Screen::saveMode(int m)
 {
     _savedModes[m] = _currentModes[m];
 }
 
 void Screen::restoreMode(int m)
 {
     _currentModes[m] = _savedModes[m];
 }
 
 bool Screen::getMode(int m) const
 {
     return _currentModes[m] != 0;
 }
 
 void Screen::saveCursor()
 {
     _savedState.cursorColumn = _cuX;
     _savedState.cursorLine  = _cuY;
     _savedState.rendition = _currentRendition;
     _savedState.foreground = _currentForeground;
     _savedState.background = _currentBackground;
 }
 
 void Screen::restoreCursor()
 {
     _cuX     = qMin(_savedState.cursorColumn, _columns - 1);
     _cuY     = qMin(_savedState.cursorLine, _lines - 1);
     _currentRendition   = _savedState.rendition;
     _currentForeground   = _savedState.foreground;
     _currentBackground   = _savedState.background;
     updateEffectiveRendition();
 }
 
 void Screen::resizeImage(int new_lines, int new_columns)
 {
     if ((new_lines == _lines) && (new_columns == _columns)) {
         return;
     }
 
     if (_cuY > new_lines - 1) {
         // attempt to preserve focus and _lines
         _bottomMargin = _lines - 1; //FIXME: margin lost
         for (int i = 0; i < _cuY - (new_lines - 1); i++) {
             addHistLine();
             scrollUp(0, 1);
         }
     }
 
     // create new screen _lines and copy from old to new
 
     auto newScreenLines = new ImageLine[new_lines + 1];
     for (int i = 0; i < qMin(_lines, new_lines + 1) ; i++) {
         newScreenLines[i] = _screenLines[i];
     }
 
     _lineProperties.resize(new_lines + 1);
     for (int i = _lines; (i > 0) && (i < new_lines + 1); i++) {
         _lineProperties[i] = LINE_DEFAULT;
     }
 
     clearSelection();
 
     delete[] _screenLines;
     _screenLines = newScreenLines;
     _screenLinesSize = new_lines;
 
     _lines = new_lines;
     _columns = new_columns;
     _cuX = qMin(_cuX, _columns - 1);
     _cuY = qMin(_cuY, _lines - 1);
 
     // FIXME: try to keep values, evtl.
     _topMargin = 0;
     _bottomMargin = _lines - 1;
     initTabStops();
     clearSelection();
 }
 
 void Screen::setDefaultMargins()
 {
     _topMargin = 0;
     _bottomMargin = _lines - 1;
 }
 
 /*
    Clarifying rendition here and in the display.
 
    The rendition attributes are
 
    attribute
    --------------
    RE_UNDERLINE
    RE_BLINK
    RE_BOLD
    RE_REVERSE
    RE_TRANSPARENT
    RE_FAINT
    RE_STRIKEOUT
    RE_CONCEAL
    RE_OVERLINE
 
    Depending on settings, bold may be rendered as a heavier font
    in addition to a different color.
    */
 
 void Screen::reverseRendition(Character& p) const
 {
     CharacterColor f = p.foregroundColor;
     CharacterColor b = p.backgroundColor;
 
     p.foregroundColor = b;
     p.backgroundColor = f; //p->r &= ~RE_TRANSPARENT;
 }
 
 void Screen::updateEffectiveRendition()
 {
     _effectiveRendition = _currentRendition;
     if ((_currentRendition & RE_REVERSE) != 0) {
         _effectiveForeground = _currentBackground;
         _effectiveBackground = _currentForeground;
     } else {
         _effectiveForeground = _currentForeground;
         _effectiveBackground = _currentBackground;
     }
 
     if ((_currentRendition & RE_BOLD) != 0) {
         if ((_currentRendition & RE_FAINT) == 0) {
             _effectiveForeground.setIntensive();
         }
     } else {
         if ((_currentRendition & RE_FAINT) != 0) {
             _effectiveForeground.setFaint();
         }
     }
 }
 
 void Screen::copyFromHistory(Character* dest, int startLine, int count) const
 {
     Q_ASSERT(startLine >= 0 && count > 0 && startLine + count <= _history->getLines());
 
     for (int line = startLine; line < startLine + count; line++) {
         const int length = qMin(_columns, _history->getLineLen(line));
         const int destLineOffset  = (line - startLine) * _columns;
 
         _history->getCells(line, 0, length, dest + destLineOffset);
 
         for (int column = length; column < _columns; column++) {
             dest[destLineOffset + column] = Screen::DefaultChar;
         }
 
         // invert selected text
         if (_selBegin != -1) {
             for (int column = 0; column < _columns; column++) {
                 if (isSelected(column, line)) {
                     reverseRendition(dest[destLineOffset + column]);
                 }
             }
         }
     }
 }
 
 void Screen::copyFromScreen(Character* dest , int startLine , int count) const
 {
     Q_ASSERT(startLine >= 0 && count > 0 && startLine + count <= _lines);
 
     for (int line = startLine; line < (startLine + count) ; line++) {
         int srcLineStartIndex  = line * _columns;
         int destLineStartIndex = (line - startLine) * _columns;
 
         for (int column = 0; column < _columns; column++) {
             int srcIndex = srcLineStartIndex + column;
             int destIndex = destLineStartIndex + column;
 
             dest[destIndex] = _screenLines[srcIndex / _columns].value(srcIndex % _columns, Screen::DefaultChar);
 
             // invert selected text
             if (_selBegin != -1 && isSelected(column, line + _history->getLines())) {
                 reverseRendition(dest[destIndex]);
             }
         }
     }
 }
 
 void Screen::getImage(Character* dest, int size, int startLine, int endLine) const
 {
     Q_ASSERT(startLine >= 0);
     Q_ASSERT(endLine >= startLine && endLine < _history->getLines() + _lines);
 
     const int mergedLines = endLine - startLine + 1;
 
     Q_ASSERT(size >= mergedLines * _columns);
-    Q_UNUSED(size);
+    Q_UNUSED(size)
 
     const int linesInHistoryBuffer = qBound(0, _history->getLines() - startLine, mergedLines);
     const int linesInScreenBuffer = mergedLines - linesInHistoryBuffer;
 
     // copy _lines from history buffer
     if (linesInHistoryBuffer > 0) {
         copyFromHistory(dest, startLine, linesInHistoryBuffer);
     }
 
     // copy _lines from screen buffer
     if (linesInScreenBuffer > 0) {
         copyFromScreen(dest + linesInHistoryBuffer * _columns,
                        startLine + linesInHistoryBuffer - _history->getLines(),
                        linesInScreenBuffer);
     }
 
     // invert display when in screen mode
     if (getMode(MODE_Screen)) {
         for (int i = 0; i < mergedLines * _columns; i++) {
             reverseRendition(dest[i]); // for reverse display
         }
     }
 
     int visX = qMin(_cuX, _columns - 1);
     // mark the character at the current cursor position
     int cursorIndex = loc(visX, _cuY + linesInHistoryBuffer);
     if (getMode(MODE_Cursor) && cursorIndex < _columns * mergedLines) {
         dest[cursorIndex].rendition |= RE_CURSOR;
     }
 }
 
 QVector<LineProperty> Screen::getLineProperties(int startLine , int endLine) const
 {
     Q_ASSERT(startLine >= 0);
     Q_ASSERT(endLine >= startLine && endLine < _history->getLines() + _lines);
 
     const int mergedLines = endLine - startLine + 1;
     const int linesInHistory = qBound(0, _history->getLines() - startLine, mergedLines);
     const int linesInScreen = mergedLines - linesInHistory;
 
     QVector<LineProperty> result(mergedLines);
     int index = 0;
 
     // copy properties for _lines in history
     for (int line = startLine; line < startLine + linesInHistory; line++) {
         //TODO Support for line properties other than wrapped _lines
         if (_history->isWrappedLine(line)) {
             result[index] = static_cast<LineProperty>(result[index] | LINE_WRAPPED);
         }
         index++;
     }
 
     // copy properties for _lines in screen buffer
     const int firstScreenLine = startLine + linesInHistory - _history->getLines();
     for (int line = firstScreenLine; line < firstScreenLine + linesInScreen; line++) {
         result[index] = _lineProperties[line];
         index++;
     }
 
     return result;
 }
 
 void Screen::reset()
 {
     // Clear screen, but preserve the current line
     scrollUp(0, _cuY);
     _cuY = 0;
 
     _currentModes[MODE_Origin] = 0;
     _savedModes[MODE_Origin] = 0;
 
     setMode(MODE_Wrap);
     saveMode(MODE_Wrap);      // wrap at end of margin
 
     resetMode(MODE_Insert);
     saveMode(MODE_Insert);  // overstroke
 
     setMode(MODE_Cursor);                         // cursor visible
     resetMode(MODE_Screen);                         // screen not inverse
     resetMode(MODE_NewLine);
 
     _topMargin = 0;
     _bottomMargin = _lines - 1;
 
     // Other terminal emulators reset the entire scroll history during a reset
 //    setScroll(getScroll(), false);
 
     setDefaultRendition();
     saveCursor();
 }
 
 void Screen::backspace()
 {
     _cuX = qMin(_columns - 1, _cuX); // nowrap!
     _cuX = qMax(0, _cuX - 1);
 
     if (_screenLines[_cuY].size() < _cuX + 1) {
         _screenLines[_cuY].resize(_cuX + 1);
     }
 }
 
 void Screen::tab(int n)
 {
     // note that TAB is a format effector (does not write ' ');
     if (n == 0) {
         n = 1;
     }
     while ((n > 0) && (_cuX < _columns - 1)) {
         cursorRight(1);
         while ((_cuX < _columns - 1) && !_tabStops[_cuX]) {
             cursorRight(1);
         }
         n--;
     }
 }
 
 void Screen::backtab(int n)
 {
     // note that TAB is a format effector (does not write ' ');
     if (n == 0) {
         n = 1;
     }
     while ((n > 0) && (_cuX > 0)) {
         cursorLeft(1);
         while ((_cuX > 0) && !_tabStops[_cuX]) {
             cursorLeft(1);
         }
         n--;
     }
 }
 
 void Screen::clearTabStops()
 {
     for (int i = 0; i < _columns; i++) {
         _tabStops[i] = false;
     }
 }
 
 void Screen::changeTabStop(bool set)
 {
     if (_cuX >= _columns) {
         return;
     }
 
     _tabStops[_cuX] = set;
 }
 
 void Screen::initTabStops()
 {
     _tabStops.resize(_columns);
 
     // The 1st tabstop has to be one longer than the other.
     // i.e. the kids start counting from 0 instead of 1.
     // Other programs might behave correctly. Be aware.
     for (int i = 0; i < _columns; i++) {
         _tabStops[i] = (i % 8 == 0 && i != 0);
     }
 }
 
 void Screen::newLine()
 {
     if (getMode(MODE_NewLine)) {
         toStartOfLine();
     }
 
     index();
 }
 
 void Screen::checkSelection(int from, int to)
 {
     if (_selBegin == -1) {
         return;
     }
     const int scr_TL = loc(0, _history->getLines());
     //Clear entire selection if it overlaps region [from, to]
     if ((_selBottomRight >= (from + scr_TL)) && (_selTopLeft <= (to + scr_TL))) {
         clearSelection();
     }
 }
 
 void Screen::displayCharacter(uint c)
 {
     // Note that VT100 does wrapping BEFORE putting the character.
     // This has impact on the assumption of valid cursor positions.
     // We indicate the fact that a newline has to be triggered by
     // putting the cursor one right to the last column of the screen.
 
     int w = Character::width(c);
 
     if (w < 0) {
         // Non-printable character
         return;
     } else if (w == 0) {
         const QChar::Category category = QChar::category(c);
         if (category != QChar::Mark_NonSpacing && category != QChar::Letter_Other) {
             return;
         }
         // Find previous "real character" to try to combine with
         int charToCombineWithX = qMin(_cuX, _screenLines[_cuY].length());
         int charToCombineWithY = _cuY;
         do {
             if (charToCombineWithX > 0) {
                 charToCombineWithX--;
             } else if (charToCombineWithY > 0) { // Try previous line
                 charToCombineWithY--;
                 charToCombineWithX = _screenLines[charToCombineWithY].length() - 1;
             } else {
                 // Give up
                 return;
             }
 
             // Failsafe
             if (charToCombineWithX < 0) {
                 return;
             }
         } while(!_screenLines[charToCombineWithY][charToCombineWithX].isRealCharacter);
 
         Character& currentChar = _screenLines[charToCombineWithY][charToCombineWithX];
         if ((currentChar.rendition & RE_EXTENDED_CHAR) == 0) {
             const uint chars[2] = { currentChar.character, c };
             currentChar.rendition |= RE_EXTENDED_CHAR;
             currentChar.character = ExtendedCharTable::instance.createExtendedChar(chars, 2);
         } else {
             ushort extendedCharLength;
             const uint* oldChars = ExtendedCharTable::instance.lookupExtendedChar(currentChar.character, extendedCharLength);
             Q_ASSERT(oldChars);
             if (((oldChars) != nullptr) && extendedCharLength < 3) {
                 Q_ASSERT(extendedCharLength > 1);
                 Q_ASSERT(extendedCharLength < 65535); // redundant due to above check
                 auto chars = new uint[extendedCharLength + 1];
                 memcpy(chars, oldChars, sizeof(uint) * extendedCharLength);
                 chars[extendedCharLength] = c;
                 currentChar.character = ExtendedCharTable::instance.createExtendedChar(chars, extendedCharLength + 1);
                 delete[] chars;
             }
         }
         return;
     }
 
     if (_cuX + w > _columns) {
         if (getMode(MODE_Wrap)) {
             _lineProperties[_cuY] = static_cast<LineProperty>(_lineProperties[_cuY] | LINE_WRAPPED);
             nextLine();
         } else {
             _cuX = qMax(_columns - w, 0);
         }
     }
 
     // ensure current line vector has enough elements
     if (_screenLines[_cuY].size() < _cuX + w) {
         _screenLines[_cuY].resize(_cuX + w);
     }
 
     if (getMode(MODE_Insert)) {
         insertChars(w);
     }
 
     _lastPos = loc(_cuX, _cuY);
 
     // check if selection is still valid.
     checkSelection(_lastPos, _lastPos);
 
     Character& currentChar = _screenLines[_cuY][_cuX];
 
     currentChar.character = c;
     currentChar.foregroundColor = _effectiveForeground;
     currentChar.backgroundColor = _effectiveBackground;
     currentChar.rendition = _effectiveRendition;
     currentChar.isRealCharacter = true;
 
     _lastDrawnChar = c;
 
     int i = 0;
     const int newCursorX = _cuX + w--;
     while (w != 0) {
         i++;
 
         if (_screenLines[_cuY].size() < _cuX + i + 1) {
             _screenLines[_cuY].resize(_cuX + i + 1);
         }
 
         Character& ch = _screenLines[_cuY][_cuX + i];
         ch.character = 0;
         ch.foregroundColor = _effectiveForeground;
         ch.backgroundColor = _effectiveBackground;
         ch.rendition = _effectiveRendition;
         ch.isRealCharacter = false;
 
         w--;
     }
     _cuX = newCursorX;
 }
 
 int Screen::scrolledLines() const
 {
     return _scrolledLines;
 }
 int Screen::droppedLines() const
 {
     return _droppedLines;
 }
 void Screen::resetDroppedLines()
 {
     _droppedLines = 0;
 }
 void Screen::resetScrolledLines()
 {
     _scrolledLines = 0;
 }
 
 void Screen::scrollUp(int n)
 {
     if (n == 0) {
         n = 1; // Default
     }
     if (_topMargin == 0) {
         addHistLine(); // history.history
     }
     scrollUp(_topMargin, n);
 }
 
 QRect Screen::lastScrolledRegion() const
 {
     return _lastScrolledRegion;
 }
 
 void Screen::scrollUp(int from, int n)
 {
     if (n <= 0) {
         return;
     }
     if (from > _bottomMargin) {
         return;
     }
     if (from + n > _bottomMargin) {
         n = _bottomMargin + 1 - from;
     }
 
     _scrolledLines -= n;
     _lastScrolledRegion = QRect(0, _topMargin, _columns - 1, (_bottomMargin - _topMargin));
 
     //FIXME: make sure `topMargin', `bottomMargin', `from', `n' is in bounds.
     moveImage(loc(0, from), loc(0, from + n), loc(_columns, _bottomMargin));
     clearImage(loc(0, _bottomMargin - n + 1), loc(_columns - 1, _bottomMargin), ' ');
 }
 
 void Screen::scrollDown(int n)
 {
     if (n == 0) {
         n = 1; // Default
     }
     scrollDown(_topMargin, n);
 }
 
 void Screen::scrollDown(int from, int n)
 {
     _scrolledLines += n;
 
     //FIXME: make sure `topMargin', `bottomMargin', `from', `n' is in bounds.
     if (n <= 0) {
         return;
     }
     if (from > _bottomMargin) {
         return;
     }
     if (from + n > _bottomMargin) {
         n = _bottomMargin - from;
     }
     moveImage(loc(0, from + n), loc(0, from), loc(_columns - 1, _bottomMargin - n));
     clearImage(loc(0, from), loc(_columns - 1, from + n - 1), ' ');
 }
 
 void Screen::setCursorYX(int y, int x)
 {
     setCursorY(y);
     setCursorX(x);
 }
 
 void Screen::setCursorX(int x)
 {
     if (x == 0) {
         x = 1; // Default
     }
     x -= 1; // Adjust
     _cuX = qMax(0, qMin(_columns - 1, x));
 }
 
 void Screen::setCursorY(int y)
 {
     if (y == 0) {
         y = 1; // Default
     }
     y -= 1; // Adjust
     _cuY = qMax(0, qMin(_lines  - 1, y + (getMode(MODE_Origin) ? _topMargin : 0)));
 }
 
 void Screen::toStartOfLine()
 {
     _cuX = 0;
 }
 
 int Screen::getCursorX() const
 {
     return qMin(_cuX, _columns - 1);
 }
 
 int Screen::getCursorY() const
 {
     return _cuY;
 }
 
 void Screen::clearImage(int loca, int loce, char c)
 {
     const int scr_TL = loc(0, _history->getLines());
     //FIXME: check positions
 
     //Clear entire selection if it overlaps region to be moved...
     if ((_selBottomRight > (loca + scr_TL)) && (_selTopLeft < (loce + scr_TL))) {
         clearSelection();
     }
 
     const int topLine = loca / _columns;
     const int bottomLine = loce / _columns;
 
     Character clearCh(uint(c), _currentForeground, _currentBackground, DEFAULT_RENDITION, false);
 
     //if the character being used to clear the area is the same as the
     //default character, the affected _lines can simply be shrunk.
     const bool isDefaultCh = (clearCh == Screen::DefaultChar);
 
     for (int y = topLine; y <= bottomLine; y++) {
         _lineProperties[y] = 0;
 
         const int endCol = (y == bottomLine) ? loce % _columns : _columns - 1;
         const int startCol = (y == topLine) ? loca % _columns : 0;
 
         QVector<Character>& line = _screenLines[y];
 
         if (isDefaultCh && endCol == _columns - 1) {
             line.resize(startCol);
         } else {
             if (line.size() < endCol + 1) {
                 line.resize(endCol + 1);
             }
 
             Character* data = line.data();
             for (int i = startCol; i <= endCol; i++) {
                 data[i] = clearCh;
             }
         }
     }
 }
 
 void Screen::moveImage(int dest, int sourceBegin, int sourceEnd)
 {
     Q_ASSERT(sourceBegin <= sourceEnd);
 
     const int lines = (sourceEnd - sourceBegin) / _columns;
 
     //move screen image and line properties:
     //the source and destination areas of the image may overlap,
     //so it matters that we do the copy in the right order -
     //forwards if dest < sourceBegin or backwards otherwise.
     //(search the web for 'memmove implementation' for details)
     if (dest < sourceBegin) {
         for (int i = 0; i <= lines; i++) {
             _screenLines[(dest / _columns) + i ] = _screenLines[(sourceBegin / _columns) + i ];
             _lineProperties[(dest / _columns) + i] = _lineProperties[(sourceBegin / _columns) + i];
         }
     } else {
         for (int i = lines; i >= 0; i--) {
             _screenLines[(dest / _columns) + i ] = _screenLines[(sourceBegin / _columns) + i ];
             _lineProperties[(dest / _columns) + i] = _lineProperties[(sourceBegin / _columns) + i];
         }
     }
 
     if (_lastPos != -1) {
         const int diff = dest - sourceBegin; // Scroll by this amount
         _lastPos += diff;
         if ((_lastPos < 0) || (_lastPos >= (lines * _columns))) {
             _lastPos = -1;
         }
     }
 
     // Adjust selection to follow scroll.
     if (_selBegin != -1) {
         const bool beginIsTL = (_selBegin == _selTopLeft);
         const int diff = dest - sourceBegin; // Scroll by this amount
         const int scr_TL = loc(0, _history->getLines());
         const int srca = sourceBegin + scr_TL; // Translate index from screen to global
         const int srce = sourceEnd + scr_TL; // Translate index from screen to global
         const int desta = srca + diff;
         const int deste = srce + diff;
 
         if ((_selTopLeft >= srca) && (_selTopLeft <= srce)) {
             _selTopLeft += diff;
         } else if ((_selTopLeft >= desta) && (_selTopLeft <= deste)) {
             _selBottomRight = -1; // Clear selection (see below)
         }
 
         if ((_selBottomRight >= srca) && (_selBottomRight <= srce)) {
             _selBottomRight += diff;
         } else if ((_selBottomRight >= desta) && (_selBottomRight <= deste)) {
             _selBottomRight = -1; // Clear selection (see below)
         }
 
         if (_selBottomRight < 0) {
             clearSelection();
         } else {
             if (_selTopLeft < 0) {
                 _selTopLeft = 0;
             }
         }
 
         if (beginIsTL) {
             _selBegin = _selTopLeft;
         } else {
             _selBegin = _selBottomRight;
         }
     }
 }
 
 void Screen::clearToEndOfScreen()
 {
     clearImage(loc(_cuX, _cuY), loc(_columns - 1, _lines - 1), ' ');
 }
 
 void Screen::clearToBeginOfScreen()
 {
     clearImage(loc(0, 0), loc(_cuX, _cuY), ' ');
 }
 
 void Screen::clearEntireScreen()
 {
     clearImage(loc(0, 0), loc(_columns - 1, _lines - 1), ' ');
 }
 
 /*! fill screen with 'E'
   This is to aid screen alignment
   */
 
 void Screen::helpAlign()
 {
     clearImage(loc(0, 0), loc(_columns - 1, _lines - 1), 'E');
 }
 
 void Screen::clearToEndOfLine()
 {
     clearImage(loc(_cuX, _cuY), loc(_columns - 1, _cuY), ' ');
 }
 
 void Screen::clearToBeginOfLine()
 {
     clearImage(loc(0, _cuY), loc(_cuX, _cuY), ' ');
 }
 
 void Screen::clearEntireLine()
 {
     clearImage(loc(0, _cuY), loc(_columns - 1, _cuY), ' ');
 }
 
 void Screen::setRendition(RenditionFlags rendition)
 {
     _currentRendition |= rendition;
     updateEffectiveRendition();
 }
 
 void Screen::resetRendition(RenditionFlags rendition)
 {
     _currentRendition &= ~rendition;
     updateEffectiveRendition();
 }
 
 void Screen::setDefaultRendition()
 {
     setForeColor(COLOR_SPACE_DEFAULT, DEFAULT_FORE_COLOR);
     setBackColor(COLOR_SPACE_DEFAULT, DEFAULT_BACK_COLOR);
     _currentRendition   = DEFAULT_RENDITION;
     updateEffectiveRendition();
 }
 
 void Screen::setForeColor(int space, int color)
 {
     _currentForeground = CharacterColor(quint8(space), color);
 
     if (_currentForeground.isValid()) {
         updateEffectiveRendition();
     } else {
         setForeColor(COLOR_SPACE_DEFAULT, DEFAULT_FORE_COLOR);
     }
 }
 
 void Screen::setBackColor(int space, int color)
 {
     _currentBackground = CharacterColor(quint8(space), color);
 
     if (_currentBackground.isValid()) {
         updateEffectiveRendition();
     } else {
         setBackColor(COLOR_SPACE_DEFAULT, DEFAULT_BACK_COLOR);
     }
 }
 
 void Screen::clearSelection()
 {
     _selBottomRight = -1;
     _selTopLeft = -1;
     _selBegin = -1;
 }
 
 void Screen::getSelectionStart(int& column , int& line) const
 {
     if (_selTopLeft != -1) {
         column = _selTopLeft % _columns;
         line = _selTopLeft / _columns;
     } else {
         column = _cuX + getHistLines();
         line = _cuY + getHistLines();
     }
 }
 void Screen::getSelectionEnd(int& column , int& line) const
 {
     if (_selBottomRight != -1) {
         column = _selBottomRight % _columns;
         line = _selBottomRight / _columns;
     } else {
         column = _cuX + getHistLines();
         line = _cuY + getHistLines();
     }
 }
 void Screen::setSelectionStart(const int x, const int y, const bool blockSelectionMode)
 {
     _selBegin = loc(x, y);
     /* FIXME, HACK to correct for x too far to the right... */
     if (x == _columns) {
         _selBegin--;
     }
 
     _selBottomRight = _selBegin;
     _selTopLeft = _selBegin;
     _blockSelectionMode = blockSelectionMode;
 }
 
 void Screen::setSelectionEnd(const int x, const int y)
 {
     if (_selBegin == -1) {
         return;
     }
 
     int endPos =  loc(x, y);
 
     if (endPos < _selBegin) {
         _selTopLeft = endPos;
         _selBottomRight = _selBegin;
     } else {
         /* FIXME, HACK to correct for x too far to the right... */
         if (x == _columns) {
             endPos--;
         }
 
         _selTopLeft = _selBegin;
         _selBottomRight = endPos;
     }
 
     // Normalize the selection in column mode
     if (_blockSelectionMode) {
         const int topRow = _selTopLeft / _columns;
         const int topColumn = _selTopLeft % _columns;
         const int bottomRow = _selBottomRight / _columns;
         const int bottomColumn = _selBottomRight % _columns;
 
         _selTopLeft = loc(qMin(topColumn, bottomColumn), topRow);
         _selBottomRight = loc(qMax(topColumn, bottomColumn), bottomRow);
     }
 }
 
 bool Screen::isSelected(const int x, const int y) const
 {
     bool columnInSelection = true;
     if (_blockSelectionMode) {
         columnInSelection = x >= (_selTopLeft % _columns) &&
                             x <= (_selBottomRight % _columns);
     }
 
     const int pos = loc(x, y);
     return pos >= _selTopLeft && pos <= _selBottomRight && columnInSelection;
 }
 
 QString Screen::selectedText(const DecodingOptions options) const
 {
     if (!isSelectionValid()) {
         return QString();
     }
 
     return text(_selTopLeft, _selBottomRight, options);
 }
 
 QString Screen::text(int startIndex, int endIndex, const DecodingOptions options) const
 {
     QString result;
     QTextStream stream(&result, QIODevice::ReadWrite);
 
     HTMLDecoder htmlDecoder;
     PlainTextDecoder plainTextDecoder;
 
     TerminalCharacterDecoder *decoder;
     if((options & ConvertToHtml) != 0u) {
         decoder = &htmlDecoder;
     } else {
         decoder = &plainTextDecoder;
     }
 
     decoder->begin(&stream);
     writeToStream(decoder, startIndex, endIndex, options);
     decoder->end();
 
     return result;
 }
 
 bool Screen::isSelectionValid() const
 {
     return _selTopLeft >= 0 && _selBottomRight >= 0;
 }
 
 void Screen::writeToStream(TerminalCharacterDecoder* decoder,
                            int startIndex, int endIndex,
                            const DecodingOptions options) const
 {
     const int top = startIndex / _columns;
     const int left = startIndex % _columns;
 
     const int bottom = endIndex / _columns;
     const int right = endIndex % _columns;
 
     Q_ASSERT(top >= 0 && left >= 0 && bottom >= 0 && right >= 0);
 
     for (int y = top; y <= bottom; y++) {
         int start = 0;
         if (y == top || _blockSelectionMode) {
             start = left;
         }
 
         int count = -1;
         if (y == bottom || _blockSelectionMode) {
             count = right - start + 1;
         }
 
         const bool appendNewLine = (y != bottom);
         int copied = copyLineToStream(y,
                                       start,
                                       count,
                                       decoder,
                                       appendNewLine,
                                       options);
 
         // if the selection goes beyond the end of the last line then
         // append a new line character.
         //
         // this makes it possible to 'select' a trailing new line character after
         // the text on a line.
         if (y == bottom &&
                 copied < count &&
                 !options.testFlag(TrimTrailingWhitespace)) {
             Character newLineChar('\n');
             decoder->decodeLine(&newLineChar, 1, 0);
         }
     }
 }
 
 int Screen::copyLineToStream(int line ,
                              int start,
                              int count,
                              TerminalCharacterDecoder* decoder,
                              bool appendNewLine,
                              const DecodingOptions options) const
 {
     //buffer to hold characters for decoding
     //the buffer is static to avoid initializing every
     //element on each call to copyLineToStream
     //(which is unnecessary since all elements will be overwritten anyway)
     static const int MAX_CHARS = 1024;
     static Character characterBuffer[MAX_CHARS];
 
     Q_ASSERT(count < MAX_CHARS);
 
     LineProperty currentLineProperties = 0;
 
     //determine if the line is in the history buffer or the screen image
     if (line < _history->getLines()) {
         const int lineLength = _history->getLineLen(line);
 
         // ensure that start position is before end of line
         start = qMin(start, qMax(0, lineLength - 1));
 
         // retrieve line from history buffer.  It is assumed
         // that the history buffer does not store trailing white space
         // at the end of the line, so it does not need to be trimmed here
         if (count == -1) {
             count = lineLength - start;
         } else {
             count = qMin(start + count, lineLength) - start;
         }
 
         // safety checks
         Q_ASSERT(start >= 0);
         Q_ASSERT(count >= 0);
         Q_ASSERT((start + count) <= _history->getLineLen(line));
 
         _history->getCells(line, start, count, characterBuffer);
 
         if (_history->isWrappedLine(line)) {
             currentLineProperties |= LINE_WRAPPED;
         }
     } else {
         if (count == -1) {
             count = _columns - start;
         }
 
         Q_ASSERT(count >= 0);
 
         int screenLine = line - _history->getLines();
 
         Q_ASSERT(screenLine <= _screenLinesSize);
 
         screenLine = qMin(screenLine, _screenLinesSize);
 
         Character* data = _screenLines[screenLine].data();
         int length = _screenLines[screenLine].count();
 
         // Don't remove end spaces in lines that wrap
         if (options.testFlag(TrimTrailingWhitespace) && ((_lineProperties[screenLine] & LINE_WRAPPED) == 0))
         {
             // ignore trailing white space at the end of the line
             for (int i = length-1; i >= 0; i--)
             {
                 if (QChar(data[i].character).isSpace()) {
                     length--;
                 } else {
                     break;
                 }
             }
         }
 
         //retrieve line from screen image
         for (int i = start; i < qMin(start + count, length); i++) {
             characterBuffer[i - start] = data[i];
         }
 
         // count cannot be any greater than length
         count = qBound(0, count, length - start);
 
         Q_ASSERT(screenLine < _lineProperties.count());
         currentLineProperties |= _lineProperties[screenLine];
     }
 
     if (appendNewLine && (count + 1 < MAX_CHARS)) {
         if ((currentLineProperties & LINE_WRAPPED) != 0) {
             // do nothing extra when this line is wrapped.
         } else {
             // When users ask not to preserve the linebreaks, they usually mean:
             // `treat LINEBREAK as SPACE, thus joining multiple _lines into
             // single line in the same way as 'J' does in VIM.`
             characterBuffer[count] = options.testFlag(PreserveLineBreaks) ? Character('\n') : Character(' ');
             count++;
         }
     }
 
     if ((options & TrimLeadingWhitespace) != 0u) {
         int spacesCount = 0;
         for (spacesCount = 0; spacesCount < count; spacesCount++) {
             if (QChar::category(characterBuffer[spacesCount].character) != QChar::Category::Separator_Space) {
                 break;
             }
         }
 
         if (spacesCount >= count) {
             return 0;
         }
 
         for (int i=0; i < count - spacesCount; i++) {
             characterBuffer[i] = characterBuffer[i + spacesCount];
         }
 
         count -= spacesCount;
     }
 
     //decode line and write to text stream
     decoder->decodeLine(characterBuffer,
                         count, currentLineProperties);
 
     return count;
 }
 
 void Screen::writeLinesToStream(TerminalCharacterDecoder* decoder, int fromLine, int toLine) const
 {
     writeToStream(decoder, loc(0, fromLine), loc(_columns - 1, toLine), PreserveLineBreaks);
 }
 
 void Screen::addHistLine()
 {
     // add line to history buffer
     // we have to take care about scrolling, too...
 
     if (hasScroll()) {
         const int oldHistLines = _history->getLines();
 
         _history->addCellsVector(_screenLines[0]);
         _history->addLine((_lineProperties[0] & LINE_WRAPPED) != 0);
 
         const int newHistLines = _history->getLines();
 
         const bool beginIsTL = (_selBegin == _selTopLeft);
 
         // If the history is full, increment the count
         // of dropped _lines
         if (newHistLines == oldHistLines) {
             _droppedLines++;
         }
 
         // Adjust selection for the new point of reference
         if (newHistLines > oldHistLines) {
             if (_selBegin != -1) {
                 _selTopLeft += _columns;
                 _selBottomRight += _columns;
             }
         }
 
         if (_selBegin != -1) {
             // Scroll selection in history up
             const int top_BR = loc(0, 1 + newHistLines);
 
             if (_selTopLeft < top_BR) {
                 _selTopLeft -= _columns;
             }
 
             if (_selBottomRight < top_BR) {
                 _selBottomRight -= _columns;
             }
 
             if (_selBottomRight < 0) {
                 clearSelection();
             } else {
                 if (_selTopLeft < 0) {
                     _selTopLeft = 0;
                 }
             }
 
             if (beginIsTL) {
                 _selBegin = _selTopLeft;
             } else {
                 _selBegin = _selBottomRight;
             }
         }
     }
 }
 
 int Screen::getHistLines() const
 {
     return _history->getLines();
 }
 
 void Screen::setScroll(const HistoryType& t , bool copyPreviousScroll)
 {
     clearSelection();
 
     if (copyPreviousScroll) {
         _history = t.scroll(_history);
     } else {
         HistoryScroll* oldScroll = _history;
         _history = t.scroll(nullptr);
         delete oldScroll;
     }
 }
 
 bool Screen::hasScroll() const
 {
     return _history->hasScroll();
 }
 
 const HistoryType& Screen::getScroll() const
 {
     return _history->getType();
 }
 
 void Screen::setLineProperty(LineProperty property , bool enable)
 {
     if (enable) {
         _lineProperties[_cuY] = static_cast<LineProperty>(_lineProperties[_cuY] | property);
     } else {
         _lineProperties[_cuY] = static_cast<LineProperty>(_lineProperties[_cuY] & ~property);
     }
 }
 void Screen::fillWithDefaultChar(Character* dest, int count)
 {
     for (int i = 0; i < count; i++) {
         dest[i] = Screen::DefaultChar;
     }
 }
diff --git a/src/TerminalDisplay.cpp b/src/TerminalDisplay.cpp
index f1716221..8f2f98ea 100644
--- a/src/TerminalDisplay.cpp
+++ b/src/TerminalDisplay.cpp
@@ -1,4028 +1,4028 @@
 /*
     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();
 }
 
 QColor TerminalDisplay::getForegroundColor() const
 {
     return _colorTable[DEFAULT_FORE_COLOR];
 }
 
 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())
     , _cursorTextColor(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;
 }
 
 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;
 }
 
 void TerminalDisplay::setKeyboardCursorTextColor(const QColor& color)
 {
     _cursorTextColor = color;
 }
 
 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,
                                  QColor& characterColor)
 {
     // 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 the cursor text color is valid then use it to draw the character under the cursor,
             // otherwise invert the color used to draw the text to ensure that the character at
             // the cursor position is readable
             characterColor = _cursorTextColor.isValid() ? _cursorTextColor : backgroundColor;
         }
     } 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,
                                      const QColor& characterColor)
 {
     // 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 QColor foregroundColor = style->foregroundColor.color(_colorTable);
     const QColor color = characterColor.isValid() ? characterColor : foregroundColor;
     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
     QColor characterColor;
     if ((style->rendition & RE_CURSOR) != 0) {
         drawCursor(painter, rect, foregroundColor, backgroundColor, characterColor);
     }
 
     // draw text
     drawCharacters(painter, rect, text, style, characterColor);
 }
 
 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, QColor());
 }
 
 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 auto &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;
     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);
 
     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);
     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
 
     const auto spots = _filterChain->hotSpots();
     int urlNumber, urlNumInc;
     if (_reverseUrlHints) {
         urlNumber = spots.size() + 1;
         urlNumInc = -1;
     } else {
         urlNumber = 0;
         urlNumInc = 1;
     }
     for (const auto &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);
             }
         }
     }
 }
 
 static uint baseCodePoint(const Character &ch) {
     if (ch.rendition & RE_EXTENDED_CHAR) {
         // sequence of characters
         ushort extendedCharLength = 0;
         const uint* chars = ExtendedCharTable::instance.lookupExtendedChar(ch.character, extendedCharLength);
         return chars[0];
     } else {
         return ch.character;
     }
 }
 
 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 QChar::Script currentScript = QChar::script(baseCodePoint(_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 hasSameLineDrawStatus = [&](int column) {
                 return LineBlockCharacters::canDraw(_image[loc(column, y)].character)
                     == lineDraw;
             };
             const auto isSameScript = [&](int column) {
                 const QChar::Script script = QChar::script(baseCodePoint(_image[loc(column, y)]));
                 if (currentScript == QChar::Script_Common || script == QChar::Script_Common
                     || currentScript == QChar::Script_Inherited || script == QChar::Script_Inherited) {
                     return true;
                 }
                 return currentScript == script;
             };
             const auto canBeGrouped = [&](int column) {
                 return _image[loc(column, y)].character <= 0x7e
                        || (_image[loc(column, y)].rendition & RE_EXTENDED_CHAR)
                        || (_bidiEnabled && !doubleWidth);
             };
 
             if (canBeGrouped(x)) {
                 while (isInsideDrawArea(x + len) && hasSameColors(x + len)
                        && hasSameRendition(x + len) && hasSameWidth(x + len)
                        && hasSameLineDrawStatus(x + len) && isSameScript(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))) {
                 auto 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);
             }
         }
     }
 }
 
 QSharedPointer<Filter::HotSpot> TerminalDisplay::filterActions(const QPoint& position)
 {
     int charLine, charColumn;
     getCharacterPosition(position, charLine, charColumn, false);
 
     return _filterChain->hotSpotAt(charLine, charColumn);
 }
 
 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
     auto 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;
     const QMimeData *mimeData = QApplication::clipboard()->mimeData(QClipboard::Clipboard);
 
     // When pasting urls of local files:
     // - remove the scheme part, "file://"
     // - paste the path(s) as a space-separated list of strings, which are quoted if needed
     if (!mimeData->hasUrls()) { // fast path if there are no urls
         text = mimeData->text();
     } else { // handle local file urls
         const QList<QUrl> list = mimeData->urls();
         for (const QUrl &url : list) {
             if (url.isLocalFile()) {
                 text += KShell::quoteArg(url.toLocalFile());
                 text += QLatin1Char(' ');
             } else { // can users copy urls of both local and remote files at the same time?
                 text = mimeData->text();
                 break;
             }
         }
     }
 
     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();
 
     QColor characterColor;
     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, characterColor);
     drawCharacters(painter, rect, _inputMethodData.preeditString, style, characterColor);
 
     _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);
+    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());
     setKeyboardCursorTextColor(profile->useCustomCursorColor() ? profile->customCursorTextColor() : 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/TerminalHeaderBar.cpp b/src/TerminalHeaderBar.cpp
index 2278fda2..7d07fb7e 100644
--- a/src/TerminalHeaderBar.cpp
+++ b/src/TerminalHeaderBar.cpp
@@ -1,180 +1,180 @@
 /*
  *  This file is part of Konsole, a terminal emulator for KDE.
  *
  *  Copyright 2019  Tomaz Canabrava <tcanabrava@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.
  */
 
 #include "TerminalHeaderBar.h"
 
 #include "TerminalDisplay.h"
 #include "SessionController.h"
 #include "ViewProperties.h"
 
 #include <KLocalizedString>
 #include <QBoxLayout>
 #include <QToolButton>
 #include <QLabel>
 #include <QApplication>
 #include <QPaintEvent>
 #include <QTabBar>
 #include <QPainter>
 #include <QSplitter>
 #include <QStyleOptionTabBarBase>
 #include <QStylePainter>
 #include <QDrag>
 #include <QMimeData>
 
 namespace Konsole {
 
 TerminalHeaderBar::TerminalHeaderBar(QWidget *parent)
     : QWidget(parent)
 {
     m_closeBtn = new QToolButton(this);
     m_closeBtn->setIcon(QIcon::fromTheme(QStringLiteral("tab-close")));
     m_closeBtn->setToolTip(i18nc("@info:tooltip", "Close terminal"));
     m_closeBtn->setText(i18nc("@info:tooltip", "Close terminal"));
     m_closeBtn->setObjectName(QStringLiteral("close-terminal-button"));
     m_closeBtn->setAutoRaise(true);
 
     m_toggleExpandedMode = new QToolButton(this);
     m_toggleExpandedMode->setIcon(QIcon::fromTheme(QStringLiteral("view-fullscreen"))); // fake 'expand' icon. VDG input?
     m_toggleExpandedMode->setAutoRaise(true);
     m_toggleExpandedMode->setCheckable(true);
     m_toggleExpandedMode->setToolTip(i18nc("@info:tooltip", "Maximize terminal"));
 
     m_terminalTitle = new QLabel(this);
     m_terminalTitle->setFont(QApplication::font());
 
     m_terminalIcon = new QLabel(this);
     m_terminalActivity = new QLabel(this);
 
     m_boxLayout = new QBoxLayout(QBoxLayout::LeftToRight);
     m_boxLayout->setSpacing(0);
     m_boxLayout->setContentsMargins(0, 0, 0, 0);
 
     // Layout Setup
     m_boxLayout->addStretch();
     m_boxLayout->addWidget(m_terminalIcon);
     m_boxLayout->addWidget(m_terminalTitle);
     m_boxLayout->addWidget(m_terminalActivity);
     m_boxLayout->addStretch();
     m_boxLayout->addWidget(m_toggleExpandedMode);
     m_boxLayout->addWidget(m_closeBtn);
     setLayout(m_boxLayout);
 
     setAutoFillBackground(true);
     terminalFocusOut();
     connect(m_toggleExpandedMode, &QToolButton::clicked,
         this, &TerminalHeaderBar::requestToggleExpansion);
 
 }
 
 // Hack untill I can detangle the creation of the TerminalViews
 void TerminalHeaderBar::finishHeaderSetup(ViewProperties *properties)
 {
     auto controller = dynamic_cast<SessionController*>(properties);
     connect(properties, &Konsole::ViewProperties::titleChanged, this, [this, properties]{
         m_terminalTitle->setText(properties->title());
     });
 
     connect(properties, &Konsole::ViewProperties::iconChanged, this, [this, properties] {
         m_terminalIcon->setPixmap(properties->icon().pixmap(QSize(22,22)));
     });
 
     connect(properties, &Konsole::ViewProperties::activity, this, [this]{
         m_terminalActivity->setPixmap(QPixmap());
     });
 
     connect(m_closeBtn, &QToolButton::clicked, controller, &SessionController::closeSession);
 }
 
 void TerminalHeaderBar::paintEvent(QPaintEvent *paintEvent)
 {
     /* Try to get the widget that's 10px above this one.
      * If the widget is something else than a TerminalWidget, a TabBar or a QSplitter,
      * draw a 1px line to separate it from the others.
      */
 
     const auto globalPos = parentWidget()->mapToGlobal(pos());
     auto *widget = qApp->widgetAt(globalPos.x() + 10, globalPos.y() - 10);
 
     const bool isTabbar = qobject_cast<QTabBar*>(widget) != nullptr;
     const bool isTerminalWidget = qobject_cast<TerminalDisplay*>(widget) != nullptr;
     const bool isSplitter = (qobject_cast<QSplitter*>(widget) != nullptr) || (qobject_cast<QSplitterHandle*>(widget) != nullptr);
     if ((widget != nullptr) && !isTabbar && !isTerminalWidget && !isSplitter) {
         QStyleOptionTabBarBase optTabBase;
         QStylePainter p(this);
         optTabBase.init(this);
         optTabBase.shape = QTabBar::Shape::RoundedSouth;
         optTabBase.documentMode = false;
         p.drawPrimitive(QStyle::PE_FrameTabBarBase, optTabBase);
     }
 
     QWidget::paintEvent(paintEvent);
     if (!m_terminalIsFocused) {
         auto p = qApp->palette();
         auto shadowColor = p.color(QPalette::ColorRole::Shadow);
         shadowColor.setAlphaF( qreal(0.2) * shadowColor.alphaF() ); // same as breeze.
 
         QPainter painter(this);
         painter.setPen(Qt::NoPen);
         painter.setBrush(shadowColor);
         painter.drawRect(rect());
     }
 }
 
 void TerminalHeaderBar::mouseMoveEvent(QMouseEvent* ev)
 {
     if (m_toggleExpandedMode->isChecked()) {
         return;
     }
     auto point = ev->pos() - m_startDrag;
     if (point.manhattanLength() > 10) {
         auto drag = new QDrag(parent());
         auto mimeData = new QMimeData();
         QByteArray payload;
         payload.setNum(qApp->applicationPid());
         mimeData->setData(QStringLiteral("konsole/terminal_display"), payload);
         drag->setMimeData(mimeData);
         drag->exec();
     }
 }
 
 void TerminalHeaderBar::mousePressEvent(QMouseEvent* ev)
 {
     m_startDrag = ev->pos();
 }
 
 void TerminalHeaderBar::mouseReleaseEvent(QMouseEvent* ev)
 {
-    Q_UNUSED(ev);
+    Q_UNUSED(ev)
 }
 
 void TerminalHeaderBar::terminalFocusIn()
 {
     m_terminalIsFocused = true;
     update();
 }
 
 void TerminalHeaderBar::terminalFocusOut()
 {
     m_terminalIsFocused = false;
     update();
 }
 
 }
diff --git a/src/ViewContainer.cpp b/src/ViewContainer.cpp
index e2197ca4..e3cb30fe 100644
--- a/src/ViewContainer.cpp
+++ b/src/ViewContainer.cpp
@@ -1,640 +1,640 @@
 /*
     This file is part of the Konsole Terminal.
 
     Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "ViewContainer.h"
 #include "config-konsole.h"
 
 // Qt
 #include <QTabBar>
 #include <QMenu>
 #include <QFile>
 #include <QKeyEvent>
 
 // KDE
 #include <KColorScheme>
 #include <KColorUtils>
 #include <KLocalizedString>
 #include <KActionCollection>
 
 // Konsole
 #include "IncrementalSearchBar.h"
 #include "ViewProperties.h"
 #include "ProfileList.h"
 #include "ViewManager.h"
 #include "KonsoleSettings.h"
 #include "SessionController.h"
 #include "DetachableTabBar.h"
 #include "TerminalDisplay.h"
 #include "ViewSplitter.h"
 #include "MainWindow.h"
 #include "Session.h"
 
 // TODO Perhaps move everything which is Konsole-specific into different files
 
 using namespace Konsole;
 
 
 TabbedViewContainer::TabbedViewContainer(ViewManager *connectedViewManager, QWidget *parent) :
     QTabWidget(parent),
     _connectedViewManager(connectedViewManager),
     _newTabButton(new QToolButton(this)),
     _closeTabButton(new QToolButton(this)),
     _contextMenuTabIndex(-1),
     _navigationVisibility(ViewManager::NavigationVisibility::NavigationNotSet),
     _newTabBehavior(PutNewTabAtTheEnd)
 {
     setAcceptDrops(true);
 
     auto tabBarWidget = new DetachableTabBar();
     setTabBar(tabBarWidget);
     setDocumentMode(true);
     setMovable(true);
     connect(tabBarWidget, &DetachableTabBar::moveTabToWindow, this, &TabbedViewContainer::moveTabToWindow);
     tabBar()->setContextMenuPolicy(Qt::CustomContextMenu);
     _newTabButton->setIcon(QIcon::fromTheme(QStringLiteral("tab-new")));
     _newTabButton->setAutoRaise(true);
     connect(_newTabButton, &QToolButton::clicked, this, &TabbedViewContainer::newViewRequest);
 
     _closeTabButton->setIcon(QIcon::fromTheme(QStringLiteral("tab-close")));
     _closeTabButton->setAutoRaise(true);
     connect(_closeTabButton, &QToolButton::clicked, this, [this]{
        closeCurrentTab();
     });
 
     connect(tabBar(), &QTabBar::tabBarDoubleClicked, this,
         &Konsole::TabbedViewContainer::tabDoubleClicked);
     connect(tabBar(), &QTabBar::customContextMenuRequested, this,
         &Konsole::TabbedViewContainer::openTabContextMenu);
     connect(tabBarWidget, &DetachableTabBar::detachTab, this, [this](int idx) {
         emit detachTab(idx);
     });
     connect(tabBarWidget, &DetachableTabBar::closeTab,
         this, &TabbedViewContainer::closeTerminalTab);
     connect(tabBarWidget, &DetachableTabBar::newTabRequest,
         this, [this]{ emit newViewRequest(); });
     connect(this, &TabbedViewContainer::currentChanged, this, &TabbedViewContainer::currentTabChanged);
 
     // The context menu of tab bar
     _contextPopupMenu = new QMenu(tabBar());
     connect(_contextPopupMenu, &QMenu::aboutToHide, this, [this]() {
         // Remove the read-only action when the popup closes
         for (auto &action : _contextPopupMenu->actions()) {
             if (action->objectName() == QStringLiteral("view-readonly")) {
                 _contextPopupMenu->removeAction(action);
                 break;
             }
         }
     });
 
     connect(tabBar(), &QTabBar::tabCloseRequested, this, &TabbedViewContainer::closeTerminalTab);
 
     auto detachAction = _contextPopupMenu->addAction(
         QIcon::fromTheme(QStringLiteral("tab-detach")),
         i18nc("@action:inmenu", "&Detach Tab"), this,
         [this] { emit detachTab(_contextMenuTabIndex); }
     );
     detachAction->setObjectName(QStringLiteral("tab-detach"));
 
     auto editAction = _contextPopupMenu->addAction(
         QIcon::fromTheme(QStringLiteral("edit-rename")),
         i18nc("@action:inmenu", "&Rename Tab..."), this,
         [this]{ renameTab(_contextMenuTabIndex); }
     );
     editAction->setObjectName(QStringLiteral("edit-rename"));
 
     auto closeAction = _contextPopupMenu->addAction(
         QIcon::fromTheme(QStringLiteral("tab-close")),
         i18nc("@action:inmenu", "Close Tab"), this,
         [this] { closeTerminalTab(_contextMenuTabIndex); }
     );
     closeAction->setObjectName(QStringLiteral("tab-close"));
 
     auto profileMenu = new QMenu(this);
     auto profileList = new ProfileList(false, profileMenu);
     profileList->syncWidgetActions(profileMenu, true);
     connect(profileList, &Konsole::ProfileList::profileSelected, this, &TabbedViewContainer::newViewWithProfileRequest);
     _newTabButton->setMenu(profileMenu);
 
     konsoleConfigChanged();
     connect(KonsoleSettings::self(), &KonsoleSettings::configChanged, this, &TabbedViewContainer::konsoleConfigChanged);
 }
 
 TabbedViewContainer::~TabbedViewContainer()
 {
     for(int i = 0, end = count(); i < end; i++) {
         auto view = widget(i);
         disconnect(view, &QWidget::destroyed, this, &Konsole::TabbedViewContainer::viewDestroyed);
     }
 }
 
 ViewSplitter *TabbedViewContainer::activeViewSplitter()
 {
     return viewSplitterAt(currentIndex());
 }
 
 ViewSplitter *TabbedViewContainer::viewSplitterAt(int index)
 {
     return qobject_cast<ViewSplitter*>(widget(index));
 }
 
 void TabbedViewContainer::moveTabToWindow(int index, QWidget *window)
 {
     auto splitter = viewSplitterAt(index);
     auto manager = window->findChild<ViewManager*>();
 
     QHash<TerminalDisplay*, Session*> sessionsMap = _connectedViewManager->forgetAll(splitter);
 
     const QList<TerminalDisplay *> displays = splitter->findChildren<TerminalDisplay*>();
     for (TerminalDisplay *terminal : displays) {
         manager->attachView(terminal, sessionsMap[terminal]);
     }
     auto container = manager->activeContainer();
     container->addSplitter(splitter);
 
     auto controller = splitter->activeTerminalDisplay()->sessionController();
     container->currentSessionControllerChanged(controller);
 
     forgetView(splitter);
 }
 
 void TabbedViewContainer::konsoleConfigChanged()
 {
     // don't show tabs if we are in KParts mode.
     // This is a hack, and this needs to be rewritten.
     // The container should not be part of the KParts, perhaps just the
     // TerminalDisplay should.
 
     // ASAN issue if using sessionController->isKonsolePart(), just
     // duplicate code for now
     if (qApp->applicationName() != QLatin1String("konsole")) {
         tabBar()->setVisible(false);
     } else {
         // if we start with --show-tabbar or --hide-tabbar we ignore the preferences.
         setTabBarAutoHide(KonsoleSettings::tabBarVisibility() == KonsoleSettings::EnumTabBarVisibility::ShowTabBarWhenNeeded);
         if (KonsoleSettings::tabBarVisibility() == KonsoleSettings::EnumTabBarVisibility::AlwaysShowTabBar) {
             tabBar()->setVisible(true);
         } else if (KonsoleSettings::tabBarVisibility() == KonsoleSettings::EnumTabBarVisibility::AlwaysHideTabBar) {
             tabBar()->setVisible(false);
         }
     }
 
     setTabPosition((QTabWidget::TabPosition) KonsoleSettings::tabBarPosition());
 
     setCornerWidget(KonsoleSettings::newTabButton() ? _newTabButton : nullptr, Qt::TopLeftCorner);
     _newTabButton->setVisible(KonsoleSettings::newTabButton());
 
     setCornerWidget(KonsoleSettings::closeTabButton() == 1 ? _closeTabButton : nullptr, Qt::TopRightCorner);
     _closeTabButton->setVisible(KonsoleSettings::closeTabButton() == 1);
 
     tabBar()->setTabsClosable(KonsoleSettings::closeTabButton() == 0);
 
     tabBar()->setExpanding(KonsoleSettings::expandTabWidth());
     tabBar()->update();
 
     if (KonsoleSettings::tabBarUseUserStyleSheet()) {
         setCssFromFile(KonsoleSettings::tabBarUserStyleSheetFile());
     } else {
         setCss();
     }
 }
 
 void TabbedViewContainer::setCss(const QString& styleSheet)
 {
     static const QString defaultCss = QStringLiteral("QTabWidget::tab-bar, QTabWidget::pane { margin: 0; }\n");
     setStyleSheet(defaultCss + styleSheet);
 }
 
 void TabbedViewContainer::setCssFromFile(const QUrl &url)
 {
     // Let's only deal w/ local files for now
     if (!url.isLocalFile()) {
         setStyleSheet(KonsoleSettings::tabBarStyleSheet());
     }
 
     QFile file(url.toLocalFile());
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         setStyleSheet(KonsoleSettings::tabBarStyleSheet());
     }
 
     QTextStream in(&file);
     setCss(in.readAll());
 }
 
 void TabbedViewContainer::moveActiveView(MoveDirection direction)
 {
     if (count() < 2) { // return if only one view
         return;
     }
     const int currentIndex = indexOf(currentWidget());
     int newIndex = direction  == MoveViewLeft ? qMax(currentIndex - 1, 0) : qMin(currentIndex + 1, count() - 1);
 
     auto swappedWidget = viewSplitterAt(newIndex);
     auto swappedTitle = tabBar()->tabText(newIndex);
     auto swappedIcon = tabBar()->tabIcon(newIndex);
 
     auto currentWidget = viewSplitterAt(currentIndex);
     auto currentTitle = tabBar()->tabText(currentIndex);
     auto currentIcon = tabBar()->tabIcon(currentIndex);
 
     if (newIndex < currentIndex) {
         insertTab(newIndex, currentWidget, currentIcon, currentTitle);
         insertTab(currentIndex, swappedWidget, swappedIcon, swappedTitle);
     } else {
         insertTab(currentIndex, swappedWidget, swappedIcon, swappedTitle);
         insertTab(newIndex, currentWidget, currentIcon, currentTitle);
     }
     setCurrentIndex(newIndex);
 }
 
 void TabbedViewContainer::terminalDisplayDropped(TerminalDisplay *terminalDisplay) {
     if (terminalDisplay->sessionController()->parent() != connectedViewManager()) {
         // Terminal from another window - recreate SessionController for current ViewManager
         disconnectTerminalDisplay(terminalDisplay);
         Session* terminalSession = terminalDisplay->sessionController()->session();
         terminalDisplay->sessionController()->deleteLater();
         connectedViewManager()->attachView(terminalDisplay, terminalSession);
         connectTerminalDisplay(terminalDisplay);
     }
 }
 
 QSize TabbedViewContainer::sizeHint() const
 {
     // QTabWidget::sizeHint() contains some margins added by widgets
     // style, which were making the initial window size too big.
     const auto tabsSize = tabBar()->sizeHint();
     const auto *leftWidget = cornerWidget(Qt::TopLeftCorner);
     const auto *rightWidget = cornerWidget(Qt::TopRightCorner);
     const auto leftSize = leftWidget ? leftWidget->sizeHint() : QSize(0, 0);
     const auto rightSize = rightWidget ? rightWidget->sizeHint() : QSize(0, 0);
 
     auto tabBarSize = QSize(0, 0);
     // isVisible() won't work; this is called when the window is not yet visible
     if (tabBar()->isVisibleTo(this)) {
         tabBarSize.setWidth(leftSize.width() + tabsSize.width() + rightSize.width());
         tabBarSize.setHeight(qMax(tabsSize.height(), qMax(leftSize.height(), rightSize.height())));
     }
 
     const auto terminalSize = currentWidget() ? currentWidget()->sizeHint() : QSize(0, 0);
 
     //        width
     // ├──────────────────┤
     //
     // ┌──────────────────┐  ┬
     // │                  │  │
     // │     Terminal     │  │
     // │                  │  │ height
     // ├───┬──────────┬───┤  │  ┬
     // │ L │   Tabs   │ R │  │  │ tab bar height
     // └───┴──────────┴───┘  ┴  ┴
     //
     // L/R = left/right widget
 
     return {qMax(terminalSize.width(), tabBarSize.width()),
                  tabBarSize.height() + terminalSize.height()};
 }
 
 void TabbedViewContainer::addSplitter(ViewSplitter *viewSplitter, int index) {
     if (index == -1) {
        index = addTab(viewSplitter, QString());
     } else {
         insertTab(index, viewSplitter, QString());
     }
     connect(viewSplitter, &ViewSplitter::destroyed, this, &TabbedViewContainer::viewDestroyed);
 
     disconnect(viewSplitter, &ViewSplitter::terminalDisplayDropped, nullptr, nullptr);
     connect(viewSplitter, &ViewSplitter::terminalDisplayDropped, this, &TabbedViewContainer::terminalDisplayDropped);
 
     const auto terminalDisplays = viewSplitter->findChildren<TerminalDisplay*>();
     for (TerminalDisplay *terminal : terminalDisplays) {
         connectTerminalDisplay(terminal);
     }
     if (terminalDisplays.count() > 0) {
         updateTitle(qobject_cast<ViewProperties*>(terminalDisplays.at(0)->sessionController()));
     }
     setCurrentIndex(index);
 }
 
 void TabbedViewContainer::addView(TerminalDisplay *view)
 {
     auto viewSplitter = new ViewSplitter();
     viewSplitter->addTerminalDisplay(view, Qt::Horizontal);
     auto item = view->sessionController();
     int index = _newTabBehavior == PutNewTabAfterCurrentTab ? currentIndex() + 1 : -1;
     if (index == -1) {
        index = addTab(viewSplitter, item->icon(), item->title());
     } else {
         insertTab(index, viewSplitter, item->icon(), item->title());
     }
 
     connectTerminalDisplay(view);
     connect(viewSplitter, &ViewSplitter::destroyed, this, &TabbedViewContainer::viewDestroyed);
     connect(viewSplitter, &ViewSplitter::terminalDisplayDropped, this, &TabbedViewContainer::terminalDisplayDropped);
 
     setCurrentIndex(index);
     emit viewAdded(view);
 }
 
 void TabbedViewContainer::splitView(TerminalDisplay *view, Qt::Orientation orientation)
 {
     auto viewSplitter = qobject_cast<ViewSplitter*>(currentWidget());
     viewSplitter->addTerminalDisplay(view, orientation);
     connectTerminalDisplay(view);
 }
 
 void TabbedViewContainer::connectTerminalDisplay(TerminalDisplay *display)
 {
     auto item = display->sessionController();
     connect(item, &Konsole::SessionController::focused, this,
         &Konsole::TabbedViewContainer::currentSessionControllerChanged);
 
     connect(item, &Konsole::ViewProperties::titleChanged, this,
             &Konsole::TabbedViewContainer::updateTitle);
 
     connect(item, &Konsole::ViewProperties::iconChanged, this,
             &Konsole::TabbedViewContainer::updateIcon);
 
     connect(item, &Konsole::ViewProperties::activity, this,
             &Konsole::TabbedViewContainer::updateActivity);
 }
 
 void TabbedViewContainer::disconnectTerminalDisplay(TerminalDisplay *display)
 {
     auto item = display->sessionController();
     disconnect(item, &Konsole::SessionController::focused, this,
         &Konsole::TabbedViewContainer::currentSessionControllerChanged);
 
     disconnect(item, &Konsole::ViewProperties::titleChanged, this,
             &Konsole::TabbedViewContainer::updateTitle);
 
     disconnect(item, &Konsole::ViewProperties::iconChanged, this,
             &Konsole::TabbedViewContainer::updateIcon);
 
     disconnect(item, &Konsole::ViewProperties::activity, this,
             &Konsole::TabbedViewContainer::updateActivity);
 }
 
 void TabbedViewContainer::viewDestroyed(QObject *view)
 {
     auto widget = static_cast<ViewSplitter*>(view);
     const auto idx = indexOf(widget);
 
     removeTab(idx);
     forgetView(widget);
 }
 
 void TabbedViewContainer::forgetView(ViewSplitter *view)
 {
-    Q_UNUSED(view);
+    Q_UNUSED(view)
     if (count() == 0) {
         emit empty(this);
     }
 }
 
 void TabbedViewContainer::activateNextView()
 {
     QWidget *active = currentWidget();
     int index = indexOf(active);
     setCurrentIndex(index == count() - 1 ? 0 : index + 1);
 }
 
 void TabbedViewContainer::activateLastView()
 {
     setCurrentIndex(count() - 1);
 }
 
 void TabbedViewContainer::activatePreviousView()
 {
     QWidget *active = currentWidget();
     int index = indexOf(active);
     setCurrentIndex(index == 0 ? count() - 1 : index - 1);
 }
 
 void TabbedViewContainer::keyReleaseEvent(QKeyEvent* event)
 {
     if (event->modifiers() == Qt::NoModifier) {
         _connectedViewManager->updateTerminalDisplayHistory();
     }
 }
 
 void TabbedViewContainer::closeCurrentTab()
 {
     if (currentIndex() != -1) {
         closeTerminalTab(currentIndex());
     }
 }
 
 void TabbedViewContainer::tabDoubleClicked(int index)
 {
     if (index >= 0) {
         renameTab(index);
     } else {
         emit newViewRequest();
     }
 }
 
 void TabbedViewContainer::renameTab(int index)
 {
     if (index != -1) {
         setCurrentIndex(index);
         viewSplitterAt(index)
             -> activeTerminalDisplay()
             -> sessionController()
             -> rename();
     }
 }
 
 void TabbedViewContainer::openTabContextMenu(const QPoint &point)
 {
     if (point.isNull()) {
         return;
     }
 
     _contextMenuTabIndex = tabBar()->tabAt(point);
     if (_contextMenuTabIndex < 0) {
         return;
     }
 
     //TODO: add a countChanged signal so we can remove this for.
     // Detaching in mac causes crashes.
     for(auto action : _contextPopupMenu->actions()) {
         if (action->objectName() == QStringLiteral("tab-detach")) {
             action->setEnabled(count() > 1);
         }
     }
 
     /* This needs to nove away fro the tab or to lock every thing inside of it.
      * for now, disable.
      * */
     //
     // Add the read-only action
 #if 0
     auto sessionController = terminalAt(_contextMenuTabIndex)->sessionController();
 
     if (sessionController != nullptr) {
         auto collection = sessionController->actionCollection();
         auto readonlyAction = collection->action(QStringLiteral("view-readonly"));
         if (readonlyAction != nullptr) {
             const auto readonlyActions = _contextPopupMenu->actions();
             _contextPopupMenu->insertAction(readonlyActions.last(), readonlyAction);
         }
 
         // Disable tab rename
         for (auto &action : _contextPopupMenu->actions()) {
             if (action->objectName() == QStringLiteral("edit-rename")) {
                 action->setEnabled(!sessionController->isReadOnly());
                 break;
             }
         }
     }
 #endif
     _contextPopupMenu->exec(tabBar()->mapToGlobal(point));
 }
 
 void TabbedViewContainer::currentTabChanged(int index)
 {
     if (index != -1) {
         auto splitview = qobject_cast<ViewSplitter*>(widget(index));
         auto view = splitview->activeTerminalDisplay();
         emit activeViewChanged(view);
         setTabActivity(index, false);
     } else {
         deleteLater();
     }
 }
 
 void TabbedViewContainer::wheelScrolled(int delta)
 {
     if (delta < 0) {
         activateNextView();
     } else {
         activatePreviousView();
     }
 }
 
 void TabbedViewContainer::setTabActivity(int index, bool activity)
 {
     const QPalette &palette = tabBar()->palette();
     KColorScheme colorScheme(palette.currentColorGroup());
     const QColor colorSchemeActive = colorScheme.foreground(KColorScheme::ActiveText).color();
 
     const QColor normalColor = palette.text().color();
     const QColor activityColor = KColorUtils::mix(normalColor, colorSchemeActive);
 
     QColor color = activity ? activityColor : QColor();
 
     if (color != tabBar()->tabTextColor(index)) {
         tabBar()->setTabTextColor(index, color);
     }
 }
 
 void TabbedViewContainer::updateActivity(ViewProperties *item)
 {
     auto controller = qobject_cast<SessionController*>(item);
     auto topLevelSplitter = qobject_cast<ViewSplitter*>(controller->view()->parentWidget())->getToplevelSplitter();
 
     const int index = indexOf(topLevelSplitter);
     if (index != currentIndex()) {
         setTabActivity(index, true);
     }
 }
 
 void TabbedViewContainer::currentSessionControllerChanged(SessionController *controller)
 {
     updateTitle(qobject_cast<ViewProperties*>(controller));
 }
 
 void TabbedViewContainer::updateTitle(ViewProperties *item)
 {
     auto controller = qobject_cast<SessionController*>(item);
     auto topLevelSplitter = qobject_cast<ViewSplitter*>(controller->view()->parentWidget())->getToplevelSplitter();
 
     const int index = indexOf(topLevelSplitter);
     QString tabText = item->title();
 
     setTabToolTip(index, tabText);
 
     // To avoid having & replaced with _ (shortcut indicator)
     tabText.replace(QLatin1Char('&'), QLatin1String("&&"));
     setTabText(index, tabText);
 }
 
 void TabbedViewContainer::updateIcon(ViewProperties *item)
 {
     auto controller = qobject_cast<SessionController*>(item);
     const int index = indexOf(controller->view());
     setTabIcon(index, item->icon());
 }
 
 void TabbedViewContainer::closeTerminalTab(int idx) {
     //TODO: This for should probably go to the ViewSplitter
     for (auto terminal : viewSplitterAt(idx)->findChildren<TerminalDisplay*>()) {
         terminal->sessionController()->closeSession();
     }
 }
 
 ViewManager *TabbedViewContainer::connectedViewManager()
 {
     return _connectedViewManager;
 }
 
 void TabbedViewContainer::setNavigationVisibility(ViewManager::NavigationVisibility navigationVisibility) {
     if (navigationVisibility == ViewManager::NavigationNotSet) {
         return;
     }
 
     setTabBarAutoHide(navigationVisibility == ViewManager::ShowNavigationAsNeeded);
     if (navigationVisibility == ViewManager::AlwaysShowNavigation) {
         tabBar()->setVisible(true);
     } else if (navigationVisibility == ViewManager::AlwaysHideNavigation) {
         tabBar()->setVisible(false);
     }
 }
 
 void TabbedViewContainer::toggleMaximizeCurrentTerminal()
 {
     if (auto *terminal = qobject_cast<TerminalDisplay*>(sender())) {
         terminal->setFocus(Qt::FocusReason::OtherFocusReason);
     }
 
     activeViewSplitter()->toggleMaximizeCurrentTerminal();
 }
 
 void TabbedViewContainer::moveTabLeft()
 {
     if (currentIndex() == 0) {
         return;
     }
     tabBar()->moveTab(currentIndex(), currentIndex() -1);
 }
 
 void TabbedViewContainer::moveTabRight()
 {
     if (currentIndex() == count() -1) {
         return;
     }
     tabBar()->moveTab(currentIndex(), currentIndex() + 1);
 }
 
 void TabbedViewContainer::setNavigationBehavior(int behavior)
 {
     _newTabBehavior = static_cast<NewTabBehavior>(behavior);
 }
diff --git a/src/ViewManager.cpp b/src/ViewManager.cpp
index e6ec943d..0b4de81d 100644
--- a/src/ViewManager.cpp
+++ b/src/ViewManager.cpp
@@ -1,1150 +1,1150 @@
 /*
     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 "ViewManager.h"
 
 #include "config-konsole.h"
 
 // Qt
 #include <QStringList>
 #include <QTabBar>
 
 // KDE
 #include <KLocalizedString>
 #include <KActionCollection>
 #include <KConfigGroup>
 
 // Konsole
 #include <windowadaptor.h>
 
 #include "ColorScheme.h"
 #include "ColorSchemeManager.h"
 #include "Session.h"
 #include "TerminalDisplay.h"
 #include "SessionController.h"
 #include "SessionManager.h"
 #include "ProfileManager.h"
 #include "ViewSplitter.h"
 #include "ViewContainer.h"
 
 using namespace Konsole;
 
 int ViewManager::lastManagerId = 0;
 
 ViewManager::ViewManager(QObject *parent, KActionCollection *collection) :
     QObject(parent),
     _viewContainer(nullptr),
     _pluggedController(nullptr),
     _sessionMap(QHash<TerminalDisplay *, Session *>()),
     _actionCollection(collection),
     _navigationMethod(NoNavigation),
     _navigationVisibility(NavigationNotSet),
     _managerId(0),
     _terminalDisplayHistoryIndex(-1)
 {
     _viewContainer = createContainer();
     // setup actions which are related to the views
     setupActions();
 
     /* TODO: Reconnect
     // emit a signal when all of the views held by this view manager are destroyed
     */
     connect(_viewContainer.data(), &Konsole::TabbedViewContainer::empty,
             this, &Konsole::ViewManager::empty);
 
     // listen for profile changes
     connect(ProfileManager::instance(), &Konsole::ProfileManager::profileChanged,
             this, &Konsole::ViewManager::profileChanged);
     connect(SessionManager::instance(), &Konsole::SessionManager::sessionUpdated,
             this, &Konsole::ViewManager::updateViewsForSession);
 
     //prepare DBus communication
     new WindowAdaptor(this);
 
     _managerId = ++lastManagerId;
     QDBusConnection::sessionBus().registerObject(QLatin1String("/Windows/")
                                                  + QString::number(_managerId), this);
 }
 
 ViewManager::~ViewManager() = default;
 
 int ViewManager::managerId() const
 {
     return _managerId;
 }
 
 QWidget *ViewManager::activeView() const
 {
     return _viewContainer->currentWidget();
 }
 
 QWidget *ViewManager::widget() const
 {
     return _viewContainer;
 }
 
 void ViewManager::setupActions()
 {
     Q_ASSERT(_actionCollection);
     if (_actionCollection == nullptr) {
         return;
     }
 
     KActionCollection *collection = _actionCollection;
     // Let's reuse the pointer, no need not to.
     auto *action = new QAction(this);
     action->setIcon(QIcon::fromTheme(QStringLiteral("view-split-left-right")));
     action->setText(i18nc("@action:inmenu", "Split View Left/Right"));
     connect(action, &QAction::triggered, this, &ViewManager::splitLeftRight);
     collection->addAction(QStringLiteral("split-view-left-right"), action);
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::Key_ParenLeft);
 
     action = new QAction(this);
     action->setIcon(QIcon::fromTheme(QStringLiteral("view-split-top-bottom")));
     action->setText(i18nc("@action:inmenu", "Split View Top/Bottom"));
     connect(action, &QAction::triggered, this, &ViewManager::splitTopBottom);
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::Key_ParenRight);
     collection->addAction(QStringLiteral("split-view-top-bottom"), action);
 
     action = new QAction(this);
     action->setText(i18nc("@action:inmenu", "Expand View"));
     action->setEnabled(false);
     connect(action, &QAction::triggered, this, &ViewManager::expandActiveContainer);
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_BracketRight);
     collection->addAction(QStringLiteral("expand-active-view"), action);
     _multiSplitterOnlyActions << action;
 
     action = new QAction(this);
     action->setText(i18nc("@action:inmenu", "Shrink View"));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_BracketLeft);
     action->setEnabled(false);
     collection->addAction(QStringLiteral("shrink-active-view"), action);
     connect(action, &QAction::triggered, this, &ViewManager::shrinkActiveContainer);
     _multiSplitterOnlyActions << action;
 
     action = collection->addAction(QStringLiteral("detach-view"));
     action->setEnabled(true);
     action->setIcon(QIcon::fromTheme(QStringLiteral("tab-detach")));
     action->setText(i18nc("@action:inmenu", "Detach Current &View"));
 
     connect(action, &QAction::triggered, this, &ViewManager::detachActiveView);
     _multiSplitterOnlyActions << action;
 
     // Ctrl+Shift+D is not used as a shortcut by default because it is too close
     // to Ctrl+D - which will terminate the session in many cases
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_H);
 
     action = collection->addAction(QStringLiteral("detach-tab"));
     action->setEnabled(true);
     action->setIcon(QIcon::fromTheme(QStringLiteral("tab-detach")));
     action->setText(i18nc("@action:inmenu", "Detach Current &Tab"));
     connect(action, &QAction::triggered, this, &ViewManager::detachActiveTab);
     _multiTabOnlyActions << action;
     // Ctrl+Shift+D is not used as a shortcut by default because it is too close
     // to Ctrl+D - which will terminate the session in many cases
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_L);
 
     // keyboard shortcut only actions
     action = new QAction(i18nc("@action Shortcut entry", "Next Tab"), this);
     const QList<QKeySequence> nextViewActionKeys{Qt::SHIFT + Qt::Key_Right, Qt::CTRL + Qt::Key_PageDown};
     collection->setDefaultShortcuts(action, nextViewActionKeys);
     collection->addAction(QStringLiteral("next-tab"), action);
     connect(action, &QAction::triggered, this, &ViewManager::nextView);
     _multiTabOnlyActions << action;
     // _viewSplitter->addAction(nextViewAction);
 
     action = new QAction(i18nc("@action Shortcut entry", "Previous Tab"), this);
     const QList<QKeySequence> previousViewActionKeys{Qt::SHIFT + Qt::Key_Left, Qt::CTRL + Qt::Key_PageUp};
     collection->setDefaultShortcuts(action, previousViewActionKeys);
     collection->addAction(QStringLiteral("previous-tab"), action);
     connect(action, &QAction::triggered, this, &ViewManager::previousView);
     _multiTabOnlyActions << action;
     // _viewSplitter->addAction(previousViewAction);
 
     action = new QAction(i18nc("@action Shortcut entry", "Focus Above Terminal"), this);
     connect(action, &QAction::triggered, this, &ViewManager::focusUp);
     collection->addAction(QStringLiteral("focus-view-above"), action);
     collection->setDefaultShortcut(action, Qt::SHIFT + Qt::CTRL + Qt::Key_Up);
     _viewContainer->addAction(action);
     _multiSplitterOnlyActions << action;
 
     action = new QAction(i18nc("@action Shortcut entry", "Focus Below Terminal"), this);
     collection->setDefaultShortcut(action, Qt::SHIFT + Qt::CTRL + Qt::Key_Down);
     collection->addAction(QStringLiteral("focus-view-below"), action);
     connect(action, &QAction::triggered, this, &ViewManager::focusDown);
     _multiSplitterOnlyActions << action;
     _viewContainer->addAction(action);
 
     action = new QAction(i18nc("@action Shortcut entry", "Focus Left Terminal"), this);
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Konsole::LEFT);
     connect(action, &QAction::triggered, this, &ViewManager::focusLeft);
     collection->addAction(QStringLiteral("focus-view-left"), action);
     _multiSplitterOnlyActions << action;
 
     action = new QAction(i18nc("@action Shortcut entry", "Focus Right Terminal"), this);
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Konsole::RIGHT);
     connect(action, &QAction::triggered, this, &ViewManager::focusRight);
     collection->addAction(QStringLiteral("focus-view-right"), action);
     _multiSplitterOnlyActions << action;
 
     action = new QAction(i18nc("@action Shortcut entry", "Switch to Last Tab"), this);
     connect(action, &QAction::triggered, this, &ViewManager::lastView);
     collection->addAction(QStringLiteral("last-tab"), action);
     _multiTabOnlyActions << action;
 
     action = new QAction(i18nc("@action Shortcut entry", "Last Used Tabs"), this);
     connect(action, &QAction::triggered, this, &ViewManager::lastUsedView);
     collection->setDefaultShortcut(action, Qt::CTRL + Qt::Key_Tab);
     collection->addAction(QStringLiteral("last-used-tab"), action);
 
     action = new QAction(i18nc("@action Shortcut entry", "Toggle Between Two Tabs"), this);
     connect(action, &QAction::triggered, this, &Konsole::ViewManager::toggleTwoViews);
     collection->addAction(QStringLiteral("toggle-two-tabs"), action);
     _multiTabOnlyActions << action;
 
     action = new QAction(i18nc("@action Shortcut entry", "Last Used Tabs (Reverse)"), this);
     collection->addAction(QStringLiteral("last-used-tab-reverse"), action);
     collection->setDefaultShortcut(action, Qt::CTRL + Qt::SHIFT + Qt::Key_Tab);
     connect(action, &QAction::triggered, this, &ViewManager::lastUsedViewReverse);
 
     action = new QAction(i18nc("@action Shortcut entry", "Maximize current Terminal"), this);
     collection->addAction(QStringLiteral("maximize-current-terminal"), action);
     collection->setDefaultShortcut(action, Qt::CTRL + Qt::SHIFT + Qt::Key_E);
     connect(action, &QAction::triggered, _viewContainer, &TabbedViewContainer::toggleMaximizeCurrentTerminal);
     _multiSplitterOnlyActions << action;
     _viewContainer->addAction(action);
 
     action = new QAction(i18nc("@action Shortcut entry", "Move tab to the right"), this);
     collection->addAction(QStringLiteral("move-tab-to-right"), action);
     collection->setDefaultShortcut(action, Qt::CTRL + Qt::ALT + Qt::Key_Right);
     connect(action, &QAction::triggered, _viewContainer, &TabbedViewContainer::moveTabRight);
     _viewContainer->addAction(action);
 
     action = new QAction(i18nc("@action Shortcut entry", "Move tab to the left"), this);
     collection->addAction(QStringLiteral("move-tab-to-left"), action);
     collection->setDefaultShortcut(action, Qt::CTRL + Qt::ALT + Qt::Key_Left);
     connect(action, &QAction::triggered, _viewContainer, &TabbedViewContainer::moveTabLeft);
     _viewContainer->addAction(action);
 
     // _viewSplitter->addAction(lastUsedViewReverseAction);
     const int SWITCH_TO_TAB_COUNT = 19;
     for (int i = 0; i < SWITCH_TO_TAB_COUNT; ++i) {
         action = new QAction(i18nc("@action Shortcut entry", "Switch to Tab %1", i + 1), this);
         connect(action, &QAction::triggered, this, [this, i]() { switchToView(i); });
         collection->addAction(QStringLiteral("switch-to-tab-%1").arg(i), action);
 
         // only add default shortcut bindings for the first 9 tabs, regardless of SWITCH_TO_TAB_COUNT
         if (i < 9) {
             collection->setDefaultShortcut(action, QStringLiteral("Alt+%1").arg(i + 1));
         }
     }
 
     connect(_viewContainer, &TabbedViewContainer::viewAdded, this, &ViewManager::toggleActionsBasedOnState);
     connect(_viewContainer, &TabbedViewContainer::viewRemoved, this, &ViewManager::toggleActionsBasedOnState);
     connect(_viewContainer, &QTabWidget::currentChanged, this, &ViewManager::toggleActionsBasedOnState);
 
     toggleActionsBasedOnState();
 }
 
 void ViewManager::toggleActionsBasedOnState() {
     const int count = _viewContainer->count();
     for (QAction *tabOnlyAction : qAsConst(_multiTabOnlyActions)) {
         tabOnlyAction->setEnabled(count > 1);
     }
 
     if ((_viewContainer != nullptr) && (_viewContainer->activeViewSplitter() != nullptr)) {
         const int splitCount = _viewContainer
                 ->activeViewSplitter()
                 ->getToplevelSplitter()
                 ->findChildren<TerminalDisplay*>()
                     .count();
 
         for (QAction *action : qAsConst(_multiSplitterOnlyActions)) {
             action->setEnabled(splitCount > 1);
         }
     }
 }
 
 void ViewManager::switchToView(int index)
 {
     _viewContainer->setCurrentIndex(index);
 }
 
 void ViewManager::switchToTerminalDisplay(Konsole::TerminalDisplay* terminalDisplay)
 {
     auto splitter = qobject_cast<ViewSplitter*>(terminalDisplay->parentWidget());
     auto toplevelSplitter = splitter->getToplevelSplitter();
 
     // Focus the TermialDisplay
     terminalDisplay->setFocus();
 
     if (_viewContainer->currentWidget() != toplevelSplitter) {
         // Focus the tab
         switchToView(_viewContainer->indexOf(toplevelSplitter));
     }
 }
 
 void ViewManager::focusUp()
 {
     _viewContainer->activeViewSplitter()->focusUp();
 }
 
 void ViewManager::focusDown()
 {
     _viewContainer->activeViewSplitter()->focusDown();
 }
 
 void ViewManager::focusLeft()
 {
     _viewContainer->activeViewSplitter()->focusLeft();
 }
 
 void ViewManager::focusRight()
 {
     _viewContainer->activeViewSplitter()->focusRight();
 }
 
 void ViewManager::moveActiveViewLeft()
 {
     _viewContainer->moveActiveView(TabbedViewContainer::MoveViewLeft);
 }
 
 void ViewManager::moveActiveViewRight()
 {
     _viewContainer->moveActiveView(TabbedViewContainer::MoveViewRight);
 }
 
 void ViewManager::nextContainer()
 {
 //    _viewSplitter->activateNextContainer();
 }
 
 void ViewManager::nextView()
 {
     _viewContainer->activateNextView();
 }
 
 void ViewManager::previousView()
 {
     _viewContainer->activatePreviousView();
 }
 
 void ViewManager::lastView()
 {
     _viewContainer->activateLastView();
 }
 
 void ViewManager::activateLastUsedView(bool reverse)
 {
     if (_terminalDisplayHistory.count() <= 1) {
         return;
     }
 
     if (_terminalDisplayHistoryIndex == -1) {
         _terminalDisplayHistoryIndex = reverse ? _terminalDisplayHistory.count() - 1 : 1;
     } else if (reverse) {
         if (_terminalDisplayHistoryIndex == 0) {
             _terminalDisplayHistoryIndex = _terminalDisplayHistory.count() - 1;
         } else {
             _terminalDisplayHistoryIndex--;
         }
     } else {
         if (_terminalDisplayHistoryIndex >= _terminalDisplayHistory.count() - 1) {
             _terminalDisplayHistoryIndex = 0;
         } else {
             _terminalDisplayHistoryIndex++;
         }
     }
 
     switchToTerminalDisplay(_terminalDisplayHistory[_terminalDisplayHistoryIndex]);
 }
 
 void ViewManager::lastUsedView()
 {
     activateLastUsedView(false);
 }
 
 void ViewManager::lastUsedViewReverse()
 {
     activateLastUsedView(true);
 }
 
 void ViewManager::toggleTwoViews()
 {
     if (_terminalDisplayHistory.count() <= 1) {
         return;
     }
 
     switchToTerminalDisplay(_terminalDisplayHistory.at(1));
 }
 
 void ViewManager::detachActiveView()
 {
     // find the currently active view and remove it from its container
     if ((_viewContainer->findChildren<TerminalDisplay*>()).count() > 1) {
         auto activeSplitter = _viewContainer->activeViewSplitter();
         auto terminal = activeSplitter->activeTerminalDisplay();
         auto newSplitter = new ViewSplitter();
         newSplitter->addTerminalDisplay(terminal, Qt::Horizontal);
         QHash<TerminalDisplay*, Session*> detachedSessions = forgetAll(newSplitter);
         emit terminalsDetached(newSplitter, detachedSessions);
         focusAnotherTerminal(activeSplitter->getToplevelSplitter());
         toggleActionsBasedOnState();
     }
 }
 
 void ViewManager::detachActiveTab()
 {
     const int currentIdx = _viewContainer->currentIndex();
     detachTab(currentIdx);
 }
 
 void ViewManager::detachTab(int tabIdx)
 {
     ViewSplitter* splitter = _viewContainer->viewSplitterAt(tabIdx);
     QHash<TerminalDisplay*, Session*> detachedSessions = forgetAll(_viewContainer->viewSplitterAt(tabIdx));
     emit terminalsDetached(splitter, detachedSessions);
 }
 
 QHash<TerminalDisplay*, Session*> ViewManager::forgetAll(ViewSplitter* splitter) {
     splitter->setParent(nullptr);
     QHash<TerminalDisplay*, Session*> detachedSessions;
     const QList<TerminalDisplay *> displays = splitter->findChildren<TerminalDisplay*>();
     for (TerminalDisplay *terminal : displays) {
         Session* session = forgetTerminal(terminal);
         detachedSessions[terminal] = session;
     }
     return detachedSessions;
 }
 
 Session* ViewManager::forgetTerminal(TerminalDisplay* terminal)
 {
     disconnect(terminal, &TerminalDisplay::requestToggleExpansion, nullptr, nullptr);
 
     removeController(terminal->sessionController());
     auto session = _sessionMap.take(terminal);
     if (session != nullptr) {
         disconnect(session, &Konsole::Session::finished, this, &Konsole::ViewManager::sessionFinished);
     }
     _viewContainer->disconnectTerminalDisplay(terminal);
     updateTerminalDisplayHistory(terminal, true);
     return session;
 }
 
 Session* ViewManager::createSession(const Profile::Ptr &profile, const QString &directory)
 {
     Session *session = SessionManager::instance()->createSession(profile);
     Q_ASSERT(session);
     if (!directory.isEmpty()) {
         session->setInitialWorkingDirectory(directory);
     }
     session->addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_WINDOW=/Windows/%1").arg(managerId()));
     return session;
 }
 
 void ViewManager::sessionFinished()
 {
     // if this slot is called after the view manager's main widget
     // has been destroyed, do nothing
     if (_viewContainer.isNull()) {
         return;
     }
 
     auto *session = qobject_cast<Session *>(sender());
     Q_ASSERT(session);
 
     auto view = _sessionMap.key(session);
     _sessionMap.remove(view);
 
     if (SessionManager::instance()->isClosingAllSessions()){
         return;
     }
 
     // Before deleting the view, let's unmaximize if it's maximized.
     auto *splitter = qobject_cast<ViewSplitter*>(view->parentWidget());
     if (splitter == nullptr) {
         return;
     }
 
     auto *toplevelSplitter = splitter->getToplevelSplitter();
 
     toplevelSplitter->handleMinimizeMaximize(false);
     view->deleteLater();
 
 
     // Only remove the controller from factory() if it's actually controlling
     // the session from the sender.
     // This fixes BUG: 348478 - messed up menus after a detached tab is closed
     if ((!_pluggedController.isNull()) && (_pluggedController->session() == session)) {
         // This is needed to remove this controller from factory() in
         // order to prevent BUG: 185466 - disappearing menu popup
         emit unplugController(_pluggedController);
     }
 
     if (!_sessionMap.empty()) {
         updateTerminalDisplayHistory(view, true);
         focusAnotherTerminal(toplevelSplitter);
         toggleActionsBasedOnState();
     }
 }
 
 void ViewManager::focusAnotherTerminal(ViewSplitter *toplevelSplitter)
 {
     auto tabTterminalDisplays = toplevelSplitter->findChildren<TerminalDisplay*>();
     if (tabTterminalDisplays.count() == 0) {
         return;
     }
 
     if (tabTterminalDisplays.count() > 1) {
         // Give focus to the last used terminal in this tab
         for (auto *historyItem : _terminalDisplayHistory) {
             for (auto *terminalDisplay : tabTterminalDisplays) {
                 if (terminalDisplay == historyItem) {
                     terminalDisplay->setFocus(Qt::OtherFocusReason);
                     return;
                 }
             }
         }
     } else if (_terminalDisplayHistory.count() >= 1) {
         // Give focus to the last used terminal tab
         switchToTerminalDisplay(_terminalDisplayHistory[0]);
     }
 }
 
 void ViewManager::viewActivated(TerminalDisplay *view)
 {
     Q_ASSERT(view != nullptr);
 
     // focus the activated view, this will cause the SessionController
     // to notify the world that the view has been focused and the appropriate UI
     // actions will be plugged in.
     view->setFocus(Qt::OtherFocusReason);
 }
 
 void ViewManager::splitLeftRight()
 {
     splitView(Qt::Horizontal);
 }
 
 void ViewManager::splitTopBottom()
 {
     splitView(Qt::Vertical);
 }
 
 void ViewManager::splitView(Qt::Orientation orientation)
 {
     int currentSessionId = currentSession();
     // At least one display/session exists if we are splitting
     Q_ASSERT(currentSessionId >= 0);
 
     Session *activeSession = SessionManager::instance()->idToSession(currentSessionId);
     Q_ASSERT(activeSession);
 
     auto profile = SessionManager::instance()->sessionProfile(activeSession);
 
     const QString directory = profile->startInCurrentSessionDir()
                               ? activeSession->currentWorkingDirectory()
                               : QString();
     auto *session = createSession(profile, directory);
 
     auto terminalDisplay = createView(session);
 
     _viewContainer->splitView(terminalDisplay, orientation);
 
     toggleActionsBasedOnState();
 
     // focus the new container
     terminalDisplay->setFocus();
 }
 
 void ViewManager::expandActiveContainer()
 {
     _viewContainer->activeViewSplitter()->adjustActiveTerminalDisplaySize(10);
 }
 
 void ViewManager::shrinkActiveContainer()
 {
     _viewContainer->activeViewSplitter()->adjustActiveTerminalDisplaySize(-10);
 }
 
 SessionController *ViewManager::createController(Session *session, TerminalDisplay *view)
 {
     // create a new controller for the session, and ensure that this view manager
     // is notified when the view gains the focus
     auto controller = new SessionController(session, view, this);
     connect(controller, &Konsole::SessionController::focused, this,
             &Konsole::ViewManager::controllerChanged);
     connect(session, &Konsole::Session::destroyed, controller,
             &Konsole::SessionController::deleteLater);
     connect(session, &Konsole::Session::primaryScreenInUse, controller,
             &Konsole::SessionController::setupPrimaryScreenSpecificActions);
     connect(session, &Konsole::Session::selectionChanged, controller,
             &Konsole::SessionController::selectionChanged);
     connect(view, &Konsole::TerminalDisplay::destroyed, controller,
             &Konsole::SessionController::deleteLater);
 
     // if this is the first controller created then set it as the active controller
     if (_pluggedController.isNull()) {
         controllerChanged(controller);
     }
 
     return controller;
 }
 
 // should this be handed by ViewManager::unplugController signal
 void ViewManager::removeController(SessionController* controller)
 {
     if (_pluggedController == controller) {
         _pluggedController.clear();
     }
     controller->deleteLater();
 }
 
 void ViewManager::controllerChanged(SessionController *controller)
 {
     if (controller == _pluggedController) {
         return;
     }
 
     _viewContainer->setFocusProxy(controller->view());
     updateTerminalDisplayHistory(controller->view());
 
     _pluggedController = controller;
     emit activeViewChanged(controller);
 }
 
 SessionController *ViewManager::activeViewController() const
 {
     return _pluggedController;
 }
 
 void ViewManager::attachView(TerminalDisplay *terminal, Session *session)
 {
     connect(session, &Konsole::Session::finished, this, &Konsole::ViewManager::sessionFinished,
             Qt::UniqueConnection);
 
     // Disconnect from the other viewcontainer.
     disconnect(terminal, &TerminalDisplay::requestToggleExpansion, nullptr, nullptr);
 
     // reconnect on this container.
     connect(terminal, &TerminalDisplay::requestToggleExpansion,
             _viewContainer, &TabbedViewContainer::toggleMaximizeCurrentTerminal, Qt::UniqueConnection);
 
     _sessionMap[terminal] = session;
     createController(session, terminal);
     toggleActionsBasedOnState();
     _terminalDisplayHistory.append(terminal);
 }
 
 TerminalDisplay *ViewManager::createView(Session *session)
 {
     // notify this view manager when the session finishes so that its view
     // can be deleted
     //
     // Use Qt::UniqueConnection to avoid duplicate connection
     connect(session, &Konsole::Session::finished, this, &Konsole::ViewManager::sessionFinished,
             Qt::UniqueConnection);
     TerminalDisplay *display = createTerminalDisplay(session);
 
     const Profile::Ptr profile = SessionManager::instance()->sessionProfile(session);
     applyProfileToView(display, profile);
 
     // set initial size
     const QSize &preferredSize = session->preferredSize();
 
     display->setSize(preferredSize.width(), preferredSize.height());
     createController(session, display);
 
     _sessionMap[display] = session;
     session->addView(display);
     _terminalDisplayHistory.append(display);
 
     // tell the session whether it has a light or dark background
     session->setDarkBackground(colorSchemeForProfile(profile)->hasDarkBackground());
     display->setFocus(Qt::OtherFocusReason);
 //     updateDetachViewState();
 
     return display;
 }
 
 TabbedViewContainer *ViewManager::createContainer()
 {
     auto *container = new TabbedViewContainer(this, nullptr);
     container->setNavigationVisibility(_navigationVisibility);
     connect(container, &TabbedViewContainer::detachTab, this, &ViewManager::detachTab);
 
     // connect signals and slots
     connect(container, &Konsole::TabbedViewContainer::viewAdded, this,
            [this, container]() {
                containerViewsChanged(container);
            });
 
     connect(container, &Konsole::TabbedViewContainer::viewRemoved, this,
            [this, container]() {
                containerViewsChanged(container);
            });
 
     connect(container, &TabbedViewContainer::newViewRequest,
             this, &ViewManager::newViewRequest);
     connect(container, &Konsole::TabbedViewContainer::newViewWithProfileRequest,
             this, &Konsole::ViewManager::newViewWithProfileRequest);
     connect(container, &Konsole::TabbedViewContainer::viewRemoved, this,
             &Konsole::ViewManager::viewDestroyed);
     connect(container, &Konsole::TabbedViewContainer::activeViewChanged, this,
             &Konsole::ViewManager::viewActivated);
 
     return container;
 }
 
 void ViewManager::setNavigationMethod(NavigationMethod method)
 {
     Q_ASSERT(_actionCollection);
     if (_actionCollection == nullptr) {
         return;
     }
     KActionCollection *collection = _actionCollection;
 
     _navigationMethod = method;
 
     // FIXME: The following disables certain actions for the KPart that it
     // doesn't actually have a use for, to avoid polluting the action/shortcut
     // namespace of an application using the KPart (otherwise, a shortcut may
     // be in use twice, and the user gets to see an "ambiguous shortcut over-
     // load" error dialog). However, this approach sucks - it's the inverse of
     // what it should be. Rather than disabling actions not used by the KPart,
     // a method should be devised to only enable those that are used, perhaps
     // by using a separate action collection.
 
     const bool enable = (method != NoNavigation);
 
     auto enableAction = [&enable, &collection](const QString& actionName) {
         auto *action = collection->action(actionName);
         if (action != nullptr) {
             action->setEnabled(enable);
         }
     };
 
     enableAction(QStringLiteral("next-view"));
     enableAction(QStringLiteral("previous-view"));
     enableAction(QStringLiteral("last-tab"));
     enableAction(QStringLiteral("last-used-tab"));
     enableAction(QStringLiteral("last-used-tab-reverse"));
     enableAction(QStringLiteral("split-view-left-right"));
     enableAction(QStringLiteral("split-view-top-bottom"));
     enableAction(QStringLiteral("rename-session"));
     enableAction(QStringLiteral("move-view-left"));
     enableAction(QStringLiteral("move-view-right"));
 }
 
 ViewManager::NavigationMethod ViewManager::navigationMethod() const
 {
     return _navigationMethod;
 }
 
 void ViewManager::containerViewsChanged(TabbedViewContainer *container)
 {
-    Q_UNUSED(container);
+    Q_UNUSED(container)
     // TODO: Verify that this is right.
     emit viewPropertiesChanged(viewProperties());
 }
 
 void ViewManager::viewDestroyed(QWidget *view)
 {
     // Note: the received QWidget has already been destroyed, so
     // using dynamic_cast<> or qobject_cast<> does not work here
     // We only need the pointer address to look it up below
     auto *display = reinterpret_cast<TerminalDisplay *>(view);
 
     // 1. detach view from session
     // 2. if the session has no views left, close it
     Session *session = _sessionMap[ display ];
     _sessionMap.remove(display);
     if (session != nullptr) {
         if (session->views().count() == 0) {
             session->close();
         }
     }
 
     //we only update the focus if the splitter is still alive
     toggleActionsBasedOnState();
 
     // The below causes the menus  to be messed up
     // Only happens when using the tab bar close button
 //    if (_pluggedController)
 //        emit unplugController(_pluggedController);
 }
 
 TerminalDisplay *ViewManager::createTerminalDisplay(Session *session)
 {
     auto display = new TerminalDisplay(nullptr);
     display->setRandomSeed(session->sessionId() | (qApp->applicationPid() << 10));
     connect(display, &TerminalDisplay::requestToggleExpansion,
             _viewContainer, &TabbedViewContainer::toggleMaximizeCurrentTerminal);
 
     return display;
 }
 
 const ColorScheme *ViewManager::colorSchemeForProfile(const Profile::Ptr &profile)
 {
     const ColorScheme *colorScheme = ColorSchemeManager::instance()->
                                      findColorScheme(profile->colorScheme());
     if (colorScheme == nullptr) {
         colorScheme = ColorSchemeManager::instance()->defaultColorScheme();
     }
     Q_ASSERT(colorScheme);
 
     return colorScheme;
 }
 
 bool ViewManager::profileHasBlurEnabled(const Profile::Ptr &profile)
 {
     return colorSchemeForProfile(profile)->blur();
 }
 
 void ViewManager::applyProfileToView(TerminalDisplay *view, const Profile::Ptr &profile)
 {
     Q_ASSERT(profile);
     view->applyProfile(profile);
     emit updateWindowIcon();
     emit blurSettingChanged(view->colorScheme()->blur());
 }
 
 void ViewManager::updateViewsForSession(Session *session)
 {
     const Profile::Ptr profile = SessionManager::instance()->sessionProfile(session);
 
     const QList<TerminalDisplay *> sessionMapKeys = _sessionMap.keys(session);
     for (TerminalDisplay *view : sessionMapKeys) {
         applyProfileToView(view, profile);
     }
 }
 
 void ViewManager::profileChanged(const Profile::Ptr &profile)
 {
     // update all views associated with this profile
     QHashIterator<TerminalDisplay *, Session *> iter(_sessionMap);
     while (iter.hasNext()) {
         iter.next();
 
         // if session uses this profile, update the display
         if (iter.key() != nullptr
             && iter.value() != nullptr
             && SessionManager::instance()->sessionProfile(iter.value()) == profile) {
             applyProfileToView(iter.key(), profile);
         }
     }
 }
 
 QList<ViewProperties *> ViewManager::viewProperties() const
 {
     QList<ViewProperties *> list;
 
     TabbedViewContainer *container = _viewContainer;
     if (container == nullptr) {
         return {};
     }
 
     auto terminalContainers = _viewContainer->findChildren<TerminalDisplay*>();
     list.reserve(terminalContainers.size());
 
     for(auto terminalDisplay : _viewContainer->findChildren<TerminalDisplay*>()) {
         list.append(terminalDisplay->sessionController());
     }
 
     return list;
 }
 
 namespace {
 QJsonObject saveSessionTerminal(TerminalDisplay *terminalDisplay)
 {
     QJsonObject thisTerminal;
     auto terminalSession = terminalDisplay->sessionController()->session();
     const int sessionRestoreId = SessionManager::instance()->getRestoreId(terminalSession);
     thisTerminal.insert(QStringLiteral("SessionRestoreId"), sessionRestoreId);
     return thisTerminal;
 }
 
 QJsonObject saveSessionsRecurse(QSplitter *splitter) {
     QJsonObject thisSplitter;
     thisSplitter.insert(
         QStringLiteral("Orientation"),
         splitter->orientation() == Qt::Horizontal ? QStringLiteral("Horizontal")
                                                   : QStringLiteral("Vertical")
     );
 
     QJsonArray internalWidgets;
     for (int i = 0; i < splitter->count(); i++) {
         auto *widget = splitter->widget(i);
         auto *maybeSplitter = qobject_cast<QSplitter*>(widget);
         auto *maybeTerminalDisplay = qobject_cast<TerminalDisplay*>(widget);
 
         if (maybeSplitter != nullptr) {
             internalWidgets.append(saveSessionsRecurse(maybeSplitter));
         } else if (maybeTerminalDisplay != nullptr) {
             internalWidgets.append(saveSessionTerminal(maybeTerminalDisplay));
         }
     }
     thisSplitter.insert(QStringLiteral("Widgets"), internalWidgets);
     return thisSplitter;
 }
 
 } // namespace
 
 void ViewManager::saveSessions(KConfigGroup &group)
 {
     QJsonArray rootArray;
     for(int i = 0; i < _viewContainer->count(); i++) {
         auto *splitter = qobject_cast<QSplitter*>(_viewContainer->widget(i));
         rootArray.append(saveSessionsRecurse(splitter));
     }
 
     group.writeEntry("Tabs", QJsonDocument(rootArray).toJson(QJsonDocument::Compact));
     group.writeEntry("Active", _viewContainer->currentIndex());
 }
 
 namespace {
 
 ViewSplitter *restoreSessionsSplitterRecurse(const QJsonObject& jsonSplitter, ViewManager *manager)
 {
     const QJsonArray splitterWidgets = jsonSplitter[QStringLiteral("Widgets")].toArray();
     auto orientation = (jsonSplitter[QStringLiteral("Orientation")].toString() == QStringLiteral("Horizontal"))
         ? Qt::Horizontal : Qt::Vertical;
 
     auto *currentSplitter = new ViewSplitter();
     currentSplitter->setOrientation(orientation);
 
     for (const auto widgetJsonValue : splitterWidgets) {
         const auto widgetJsonObject = widgetJsonValue.toObject();
         const auto sessionIterator = widgetJsonObject.constFind(QStringLiteral("SessionRestoreId"));
 
         if (sessionIterator != widgetJsonObject.constEnd()) {
             Session *session = SessionManager::instance()->idToSession(sessionIterator->toInt());
             auto newView = manager->createView(session);
             currentSplitter->addWidget(newView);
         } else {
             auto nextSplitter = restoreSessionsSplitterRecurse(widgetJsonObject, manager);
             currentSplitter->addWidget(nextSplitter);
         }
     }
     return currentSplitter;
 }
 
 } // namespace
 void ViewManager::restoreSessions(const KConfigGroup &group)
 {
     const auto tabList = group.readEntry("Tabs", QByteArray("[]"));
     const auto jsonTabs = QJsonDocument::fromJson(tabList).array();
     for (const auto& jsonSplitter : jsonTabs) {
         auto topLevelSplitter = restoreSessionsSplitterRecurse(jsonSplitter.toObject(), this);
         _viewContainer->addSplitter(topLevelSplitter, _viewContainer->count());
     }
 
     if (!jsonTabs.isEmpty())
         return;
 
     // Session file is unusable, try older format
     QList<int> ids = group.readEntry("Sessions", QList<int>());
     int activeTab = group.readEntry("Active", 0);
     TerminalDisplay *display = nullptr;
 
     int tab = 1;
     for (auto it = ids.cbegin(); it != ids.cend(); ++it) {
         const int &id = *it;
         Session *session = SessionManager::instance()->idToSession(id);
 
         if (session == nullptr) {
             qWarning() << "Unable to load session with id" << id;
             // Force a creation of a default session below
             ids.clear();
             break;
         }
 
         activeContainer()->addView(createView(session));
         if (!session->isRunning()) {
             session->run();
         }
         if (tab++ == activeTab) {
             display = qobject_cast<TerminalDisplay *>(activeView());
         }
     }
 
     if (display != nullptr) {
         activeContainer()->setCurrentWidget(display);
         display->setFocus(Qt::OtherFocusReason);
     }
 
     if (ids.isEmpty()) { // Session file is unusable, start default Profile
         Profile::Ptr profile = ProfileManager::instance()->defaultProfile();
         Session *session = SessionManager::instance()->createSession(profile);
         activeContainer()->addView(createView(session));
         if (!session->isRunning()) {
             session->run();
         }
     }
 }
 
 TabbedViewContainer *ViewManager::activeContainer()
 {
     return _viewContainer;
 }
 
 int ViewManager::sessionCount()
 {
     return _sessionMap.size();
 }
 
 QStringList ViewManager::sessionList()
 {
     QStringList ids;
 
     QHash<TerminalDisplay *, Session *>::const_iterator i;
     for (i = _sessionMap.constBegin(); i != _sessionMap.constEnd(); ++i) {
         ids.append(QString::number(i.value()->sessionId()));
     }
 
     return ids;
 }
 
 int ViewManager::currentSession()
 {
     if (_pluggedController) {
         Q_ASSERT(_pluggedController->session() != nullptr);
         return _pluggedController->session()->sessionId();
     }
     return -1;
 }
 
 void ViewManager::setCurrentSession(int sessionId)
 {
     auto *session = SessionManager::instance()->idToSession(sessionId);
     if (session == nullptr || session->views().count() == 0) {
         return;
     }
 
     auto *display = session->views().at(0);
     if (display != nullptr) {
         display->setFocus(Qt::OtherFocusReason);
     }
 }
 
 int ViewManager::newSession()
 {
     return newSession(QString(), QString());
 }
 
 int ViewManager::newSession(const QString &profile)
 {
     return newSession(profile, QString());
 }
 
 int ViewManager::newSession(const QString &profile, const QString &directory)
 {
     Profile::Ptr profileptr = ProfileManager::instance()->defaultProfile();
     if(!profile.isEmpty()) {
         const QList<Profile::Ptr> profilelist = ProfileManager::instance()->allProfiles();
 
         for (const auto &i : profilelist) {
             if (i->name() == profile) {
                 profileptr = i;
                 break;
             }
         }
     }
 
     Session *session = createSession(profileptr, directory);
 
     auto newView = createView(session);
     activeContainer()->addView(newView);
     session->run();
 
     return session->sessionId();
 }
 
 QString ViewManager::defaultProfile()
 {
     return ProfileManager::instance()->defaultProfile()->name();
 }
 
 QStringList ViewManager::profileList()
 {
     return ProfileManager::instance()->availableProfileNames();
 }
 
 void ViewManager::nextSession()
 {
     nextView();
 }
 
 void ViewManager::prevSession()
 {
     previousView();
 }
 
 void ViewManager::moveSessionLeft()
 {
     moveActiveViewLeft();
 }
 
 void ViewManager::moveSessionRight()
 {
     moveActiveViewRight();
 }
 
 void ViewManager::setTabWidthToText(bool setTabWidthToText)
 {
     _viewContainer->tabBar()->setExpanding(!setTabWidthToText);
     _viewContainer->tabBar()->update();
 }
 
 void ViewManager::setNavigationVisibility(NavigationVisibility navigationVisibility) {
     if (_navigationVisibility != navigationVisibility) {
         _navigationVisibility = navigationVisibility;
         _viewContainer->setNavigationVisibility(navigationVisibility);
     }
 }
 
 void ViewManager::updateTerminalDisplayHistory(TerminalDisplay* terminalDisplay, bool remove)
 {
     if (terminalDisplay == nullptr) {
         if (_terminalDisplayHistoryIndex >= 0) {
             // This is the case when we finished walking through the history
             // (i.e. when Ctrl-Tab has been released)
             terminalDisplay = _terminalDisplayHistory[_terminalDisplayHistoryIndex];
             _terminalDisplayHistoryIndex = -1;
         } else {
             return;
         }
     }
 
     if (_terminalDisplayHistoryIndex >= 0 && !remove) {
         // Do not reorder the tab history while we are walking through it
         return;
     }
 
     for (int i = 0; i < _terminalDisplayHistory.count(); i++) {
         if (_terminalDisplayHistory[i] == terminalDisplay) {
             _terminalDisplayHistory.removeAt(i);
             if (!remove) {
                 _terminalDisplayHistory.prepend(terminalDisplay);
             }
             break;
         }
     }
 }
diff --git a/src/ViewSplitter.cpp b/src/ViewSplitter.cpp
index 7c14ee6f..2a056e12 100644
--- a/src/ViewSplitter.cpp
+++ b/src/ViewSplitter.cpp
@@ -1,356 +1,356 @@
 /*
     This file is part of the Konsole Terminal.
 
     Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "ViewSplitter.h"
 
 // Qt
 #include <QChildEvent>
 #include <QDragEnterEvent>
 #include <QMimeData>
 #include <QApplication>
 #include <memory>
 
 
 // Konsole
 #include "ViewContainer.h"
 #include "TerminalDisplay.h"
 
 using Konsole::ViewSplitter;
 using Konsole::TerminalDisplay;
 
 //TODO: Connect the TerminalDisplay destroyed signal here.
 
 ViewSplitter::ViewSplitter(QWidget *parent) :
     QSplitter(parent)
 {
     setAcceptDrops(true);
 }
 
 /* This function is called on the toplevel splitter, we need to look at the actual ViewSplitter inside it */
 void ViewSplitter::adjustActiveTerminalDisplaySize(int percentage)
 {
     auto focusedTerminalDisplay = activeTerminalDisplay();
     Q_ASSERT(focusedTerminalDisplay);
 
     auto parentSplitter = qobject_cast<ViewSplitter*>(focusedTerminalDisplay->parent());
     const int containerIndex = parentSplitter->indexOf(activeTerminalDisplay());
     Q_ASSERT(containerIndex != -1);
 
     QList<int> containerSizes = parentSplitter->sizes();
 
     const int oldSize = containerSizes[containerIndex];
     const auto newSize = static_cast<int>(oldSize * (1.0 + percentage / 100.0));
     const int perContainerDelta = (count() == 1) ? 0 : ((newSize - oldSize) / (count() - 1)) * (-1);
 
     for (int& size : containerSizes) {
         size += perContainerDelta;
     }
     containerSizes[containerIndex] = newSize;
 
     parentSplitter->setSizes(containerSizes);
 }
 
 // Get the first splitter that's a parent of the current focused widget.
 ViewSplitter *ViewSplitter::activeSplitter()
 {
     QWidget *widget = focusWidget() != nullptr ? focusWidget() : this;
 
     ViewSplitter *splitter = nullptr;
 
     while ((splitter == nullptr) && (widget != nullptr)) {
         splitter = qobject_cast<ViewSplitter *>(widget);
         widget = widget->parentWidget();
     }
 
     Q_ASSERT(splitter);
     return splitter;
 }
 
 void ViewSplitter::updateSizes()
 {
     const int space = (orientation() == Qt::Horizontal ? width() : height()) / count();
     setSizes(QVector<int>(count(), space).toList());
 }
 
 void ViewSplitter::addTerminalDisplay(TerminalDisplay *terminalDisplay, Qt::Orientation containerOrientation, AddBehavior behavior)
 {
     ViewSplitter *splitter = activeSplitter();
     const int currentIndex = splitter->activeTerminalDisplay() == nullptr ? splitter->count()
                             : splitter->indexOf(splitter->activeTerminalDisplay());
 
     if (splitter->count() < 2) {
         splitter->insertWidget(behavior == AddBehavior::AddBefore ? currentIndex : currentIndex + 1, terminalDisplay);
         splitter->setOrientation(containerOrientation);
     } else if (containerOrientation == splitter->orientation()) {
         splitter->insertWidget(currentIndex, terminalDisplay);
     } else {
         auto newSplitter = new ViewSplitter();
         TerminalDisplay *oldTerminalDisplay = splitter->activeTerminalDisplay();
         const int oldContainerIndex = splitter->indexOf(oldTerminalDisplay);
         newSplitter->addWidget(behavior == AddBehavior::AddBefore ? terminalDisplay : oldTerminalDisplay);
         newSplitter->addWidget(behavior == AddBehavior::AddBefore ? oldTerminalDisplay : terminalDisplay);
         newSplitter->setOrientation(containerOrientation);
         newSplitter->updateSizes();
         newSplitter->show();
         splitter->insertWidget(oldContainerIndex, newSplitter);
     }
     splitter->updateSizes();
 }
 
 void ViewSplitter::childEvent(QChildEvent *event)
 {
     QSplitter::childEvent(event);
 
     if (event->removed()) {
         if (count() == 0) {
             deleteLater();
         }
         if (findChild<TerminalDisplay*>() == nullptr) {
             deleteLater();
         }
     }
 
     auto terminals = getToplevelSplitter()->findChildren<TerminalDisplay*>();
     if (terminals.size() == 1) {
         terminals.at(0)->headerBar()->setVisible(false);
     } else {
         for(auto terminal : terminals) {
             terminal->headerBar()->setVisible(true);
         }
     }
 }
 
 void ViewSplitter::handleFocusDirection(Qt::Orientation orientation, int direction)
 {
     auto terminalDisplay = activeTerminalDisplay();
     auto parentSplitter = qobject_cast<ViewSplitter*>(terminalDisplay->parentWidget());
     auto topSplitter = parentSplitter->getToplevelSplitter();
 
     // Find the theme's splitter width + extra space to find valid terminal
     // See https://bugs.kde.org/show_bug.cgi?id=411387 for more info
     const auto handleWidth = parentSplitter->handleWidth() + 3;
 
     const auto start = QPoint(terminalDisplay->x(), terminalDisplay->y());
     const auto startMapped = parentSplitter->mapTo(topSplitter, start);
 
     const int newX = orientation != Qt::Horizontal ? startMapped.x() + handleWidth
              : direction == 1 ? startMapped.x() + terminalDisplay->width() + handleWidth
              : startMapped.x() - handleWidth;
 
     const int newY = orientation != Qt::Vertical ? startMapped.y() + handleWidth
                     : direction == 1 ? startMapped.y() + terminalDisplay->height() + handleWidth
                     : startMapped.y() - handleWidth;
 
     const auto newPoint = QPoint(newX, newY);
     auto child = topSplitter->childAt(newPoint);
 
     TerminalDisplay *focusTerminal = nullptr;
     if (auto* terminal = qobject_cast<TerminalDisplay*>(child)) {
         focusTerminal = terminal;
     } else if (qobject_cast<QSplitterHandle*>(child) != nullptr) {
         auto targetSplitter = qobject_cast<QSplitter*>(child->parent());
         focusTerminal = qobject_cast<TerminalDisplay*>(targetSplitter->widget(0));
     } else if (qobject_cast<QWidget*>(child) != nullptr) {
         while(child != nullptr && focusTerminal == nullptr) {
             focusTerminal = qobject_cast<TerminalDisplay*>(child->parentWidget());
             child = child->parentWidget();
         }
     }
     if (focusTerminal != nullptr) {
         focusTerminal->setFocus(Qt::OtherFocusReason);
     }
 }
 
 void ViewSplitter::focusUp()
 {
     handleFocusDirection(Qt::Vertical, -1);
 }
 
 void ViewSplitter::focusDown()
 {
     handleFocusDirection(Qt::Vertical, +1);
 }
 
 void ViewSplitter::focusLeft()
 {
     handleFocusDirection(Qt::Horizontal, -1);
 }
 
 void ViewSplitter::focusRight()
 {
     handleFocusDirection(Qt::Horizontal, +1);
 }
 
 TerminalDisplay *ViewSplitter::activeTerminalDisplay() const
 {
     auto focusedWidget = qobject_cast<TerminalDisplay*>(focusWidget());
     return focusedWidget != nullptr ? focusedWidget : findChild<TerminalDisplay*>();
 }
 
 void ViewSplitter::toggleMaximizeCurrentTerminal()
 {
     m_terminalMaximized = !m_terminalMaximized;
     handleMinimizeMaximize(m_terminalMaximized);
 }
 
 namespace {
     void restoreAll(QList<TerminalDisplay*>&& terminalDisplays, QList<ViewSplitter*>&& splitters) {
         for (auto splitter : splitters) {
             splitter->setVisible(true);
         }
         for (auto terminalDisplay : terminalDisplays) {
             terminalDisplay->setVisible(true);
         }
     }
 }
 
 bool ViewSplitter::hideRecurse(TerminalDisplay *currentTerminalDisplay) {
     bool allHidden = true;
 
     for(int i = 0, end = count(); i < end; i++) {
         if (auto *maybeSplitter = qobject_cast<ViewSplitter*>(widget(i))) {
             allHidden = maybeSplitter->hideRecurse(currentTerminalDisplay) && allHidden;
             continue;
         }
         if (auto maybeTerminalDisplay = qobject_cast<TerminalDisplay*>(widget(i))) {
             if (maybeTerminalDisplay == currentTerminalDisplay) {
                 allHidden = false;
             } else {
                 maybeTerminalDisplay->setVisible(false);
             }
         }
     }
 
     if (allHidden) {
         setVisible(false);
     }
     return allHidden;
 }
 
 void ViewSplitter::handleMinimizeMaximize(bool maximize)
 {
     auto topLevelSplitter = getToplevelSplitter();
     auto currentTerminalDisplay = topLevelSplitter->activeTerminalDisplay();
     if (maximize) {
         for (int i = 0, end = topLevelSplitter->count(); i < end; i++) {
             auto widgetAt = topLevelSplitter->widget(i);
             if (auto *maybeSplitter = qobject_cast<ViewSplitter*>(widgetAt)) {
                 maybeSplitter->hideRecurse(currentTerminalDisplay);
             }
             if (auto maybeTerminalDisplay = qobject_cast<TerminalDisplay*>(widgetAt)) {
                 if (maybeTerminalDisplay != currentTerminalDisplay) {
                     maybeTerminalDisplay->setVisible(false);
                 }
             }
         }
     } else {
         restoreAll(topLevelSplitter->findChildren<TerminalDisplay*>(),
                    topLevelSplitter->findChildren<ViewSplitter*>());
     }
 }
 
 ViewSplitter *ViewSplitter::getToplevelSplitter()
 {
     ViewSplitter *current = this;
     while(qobject_cast<ViewSplitter*>(current->parentWidget()) != nullptr) {
         current = qobject_cast<ViewSplitter*>(current->parentWidget());
     }
     return current;
 }
 
 namespace {
     TerminalDisplay *currentDragTarget = nullptr;
 }
 
 void Konsole::ViewSplitter::dragEnterEvent(QDragEnterEvent* ev)
 {
     const auto dragId = QStringLiteral("konsole/terminal_display");
     if (ev->mimeData()->hasFormat(dragId)) {
         auto other_pid = ev->mimeData()->data(dragId).toInt();
         // don't accept the drop if it's another instance of konsole
         if (qApp->applicationPid() != other_pid) {
             return;
         }
         if (getToplevelSplitter()->terminalMaximized()) {
             return;
         }
         ev->accept();
     }
 }
 
 void Konsole::ViewSplitter::dragMoveEvent(QDragMoveEvent* ev)
 {
     auto currentWidget = childAt(ev->pos());
     if (auto terminal = qobject_cast<TerminalDisplay*>(currentWidget)) {
         if ((currentDragTarget != nullptr) && currentDragTarget != terminal) {
             currentDragTarget->hideDragTarget();
         }
         if (terminal == ev->source()) {
             return;
         }
         currentDragTarget = terminal;
         auto localPos = currentDragTarget->mapFromParent(ev->pos());
         currentDragTarget->showDragTarget(localPos);
     }
 }
 
 void Konsole::ViewSplitter::dragLeaveEvent(QDragLeaveEvent* event)
 {
-    Q_UNUSED(event);
+    Q_UNUSED(event)
     if (currentDragTarget != nullptr) {
         currentDragTarget->hideDragTarget();
         currentDragTarget = nullptr;
     }
 }
 
 void Konsole::ViewSplitter::dropEvent(QDropEvent* ev)
 {
     if (ev->mimeData()->hasFormat(QStringLiteral("konsole/terminal_display"))) {
         if (getToplevelSplitter()->terminalMaximized()) {
             return;
         }
         if (currentDragTarget != nullptr) {
             currentDragTarget->hideDragTarget();
             auto source = qobject_cast<TerminalDisplay*>(ev->source());
             source->setVisible(false);
             source->setParent(nullptr);
 
             currentDragTarget->setFocus(Qt::OtherFocusReason);
             const auto droppedEdge = currentDragTarget->droppedEdge();
 
             AddBehavior behavior = droppedEdge == Qt::LeftEdge || droppedEdge == Qt::TopEdge
                 ? AddBehavior::AddBefore : AddBehavior::AddAfter;
 
             Qt::Orientation orientation = droppedEdge == Qt::LeftEdge || droppedEdge == Qt::RightEdge
                 ? Qt::Horizontal : Qt::Vertical;
 
             // topLevel is the splitter that's connected with the ViewManager
             // that in turn can call the SessionController.
             emit getToplevelSplitter()->terminalDisplayDropped(source);
             addTerminalDisplay(source, orientation, behavior);
             source->setVisible(true);
             currentDragTarget = nullptr;
         }
     }
 }