diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4a47bd8a..8aa2cf87 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,87 +1,95 @@
 # Konsole project
 
 # KDE Application Version, managed by release script
 set (KDE_APPLICATIONS_VERSION_MAJOR "18")
 set (KDE_APPLICATIONS_VERSION_MINOR "11")
 set (KDE_APPLICATIONS_VERSION_MICRO "70")
 set (KDE_APPLICATIONS_VERSION "${KDE_APPLICATIONS_VERSION_MAJOR}.${KDE_APPLICATIONS_VERSION_MINOR}.${KDE_APPLICATIONS_VERSION_MICRO}")
 
 # minimal requirements
 cmake_minimum_required (VERSION 3.0 FATAL_ERROR)
 set (QT_MIN_VERSION "5.6.0")
 set (KF5_MIN_VERSION "5.6.0")
 
 # Release script will create bugzilla versions
 project(konsole VERSION ${KDE_APPLICATIONS_VERSION})
 
 find_package(ECM 1.6.0 REQUIRED NO_MODULE)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(ECMOptionalAddSubdirectory)
 include(ECMInstallIcons)
 include(ECMSetupVersion)
 include(ECMMarkNonGuiExecutable)
 include(ECMGenerateHeaders)
 include(GenerateExportHeader)
 include(FeatureSummary)
 include(ECMQtDeclareLoggingCategory)
 
 ecm_setup_version(${KDE_APPLICATIONS_VERSION} VARIABLE_PREFIX KONSOLEPRIVATE
     SOVERSION ${KDE_APPLICATIONS_VERSION_MAJOR}
 )
 find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED
     Core
     DBus
     PrintSupport
     Widgets
 )
 
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED
     Bookmarks Completion Config ConfigWidgets
     CoreAddons Crash GuiAddons DBusAddons
-    I18n IconThemes Init KIO NewStuff NewStuffCore Notifications NotifyConfig
+    I18n IconThemes Init KIO NewStuff NewStuffCore
     Parts Pty Service TextWidgets WidgetsAddons
     WindowSystem XmlGui DBusAddons GlobalAccel
 )
 
+option(WITHOUT_KNOTIFY "Build without KNotify support" OFF)
+
+if (NOT WITHOUT_KNOTIFY)
+    find_package(KF5 ${KF5_MIN_VERSION} REQUIRED
+        Notifications NotifyConfig
+    )
+endif()
+
 find_package(KF5DocTools ${KF5_MIN_VERSION})
 set_package_properties(KF5DocTools PROPERTIES DESCRIPTION 
     "Tools to generate documentation"
     TYPE OPTIONAL
 )
 
 if(NOT APPLE)
     find_package(X11)
     set_package_properties(X11 PROPERTIES TYPE OPTIONAL)
 endif()
 set(HAVE_X11 ${X11_FOUND})
 
 # See above includes for defaults
 add_definitions(
   -DQT_STRICT_ITERATORS
   -DQT_NO_URL_CAST_FROM_STRING
   -Wno-deprecated-declarations
 )
 
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} )
 
 add_subdirectory( src )
 add_subdirectory( data )
 add_subdirectory( desktop )
 if (KF5DocTools_FOUND)
     add_subdirectory( doc/manual )
 endif()
 
 add_subdirectory( tools )
 
 install( FILES konsole.categories DESTINATION ${KDE_INSTALL_CONFDIR} )
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 7726d44d..f3e24d43 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,216 +1,227 @@
 # cmake-options : -DCMAKE_DISABLE_FIND_PACKAGE_LibKonq=TRUE or FALSE; default is FALSE
 
 add_definitions(-DTRANSLATION_DOMAIN=\"konsole\")
 
 # When Qt5.9+ is required, consider using QOperatingSystemVersion
 ### Too many crashes/issues with detaching on MacOSX
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   set(ENABLE_DETACHING 0)
 else()
   set(ENABLE_DETACHING 1)
 endif()
 
 ### Handle DragonFlyBSD here instead of using __DragonFly__
 IF(${CMAKE_SYSTEM_NAME} MATCHES "DragonFly")
   set(HAVE_OS_DRAGONFLYBSD 1)
 else()
   set(HAVE_OS_DRAGONFLYBSD 0)
 endif()
 
 include(CheckIncludeFiles)
 include(ECMAddAppIcon)
 
 configure_file(config-konsole.h.cmake
               ${CMAKE_CURRENT_BINARY_DIR}/config-konsole.h)
 
 ### Tests
 if(BUILD_TESTING)
   find_package(Qt5Test ${QT_MIN_VERSION} CONFIG REQUIRED)
   add_subdirectory(autotests)
   add_subdirectory(tests)
 endif()
 
 ### Security concerns about sendText and runCommand dbus methods being public
 option(REMOVE_SENDTEXT_RUNCOMMAND_DBUS_METHODS "Konsole: remove sendText and runCommand dbus methods" OFF)
 
 ### Development tools
 option(KONSOLE_BUILD_FONTEMBEDDER "Konsole: build fontembedder executable" OFF)
 option(KONSOLE_GENERATE_LINEFONT "Konsole: regenerate LineFont file" OFF)
 option(KONSOLE_BUILD_UNI2CHARACTERWIDTH "Konsole: build uni2characterwidth executable" OFF)
 
 ### Konsole source files shared between embedded terminal and main application
 # qdbuscpp2xml -m  Session.h -o org.kde.konsole.Session.xml
 # qdbuscpp2xml -M -s ViewManager.h -o org.kde.konsole.Konsole.xml
 
 # Generate dbus .xml files; do not store .xml in source folder
 qt5_generate_dbus_interface(Session.h org.kde.konsole.Session.xml OPTIONS -m)
 qt5_generate_dbus_interface(ViewManager.h org.kde.konsole.Window.xml OPTIONS -m)
 
 qt5_add_dbus_adaptor(sessionadaptors_SRCS
                     ${CMAKE_CURRENT_BINARY_DIR}/org.kde.konsole.Session.xml
                     Session.h
                     Konsole::Session)
 qt5_add_dbus_adaptor(windowadaptors_SRCS
                     ${CMAKE_CURRENT_BINARY_DIR}/org.kde.konsole.Window.xml
                     ViewManager.h
                     Konsole::ViewManager)
 
 set(konsoleprivate_SRCS ${sessionadaptors_SRCS}
                         ${windowadaptors_SRCS}
                         BookmarkHandler.cpp
                         ColorScheme.cpp
                         ColorSchemeManager.cpp
                         ColorSchemeEditor.cpp
                         CopyInputDialog.cpp
                         EditProfileDialog.cpp
                         Emulation.cpp
                         DetachableTabBar.cpp
                         Filter.cpp
                         History.cpp
                         HistorySizeDialog.cpp
                         HistorySizeWidget.cpp
                         IncrementalSearchBar.cpp
                         KeyBindingEditor.cpp
                         KeyboardTranslator.cpp
                         KeyboardTranslatorManager.cpp
                         ProcessInfo.cpp
                         Profile.cpp
                         ProfileList.cpp
                         ProfileReader.cpp
                         ProfileWriter.cpp
                         ProfileManager.cpp
                         Pty.cpp
                         RenameTabDialog.cpp
                         RenameTabWidget.cpp
                         Screen.cpp
                         ScreenWindow.cpp
                         ScrollState.cpp
                         Session.cpp
                         SessionController.cpp
                         SessionManager.cpp
                         SessionListModel.cpp
                         ShellCommand.cpp
                         TabTitleFormatButton.cpp
                         TerminalCharacterDecoder.cpp
                         ExtendedCharTable.cpp
                         TerminalDisplay.cpp
                         TerminalDisplayAccessible.cpp
                         ViewContainer.cpp
                         ViewManager.cpp
                         ViewProperties.cpp
                         ViewSplitter.cpp
                         Vt102Emulation.cpp
                         ZModemDialog.cpp
                         PrintOptions.cpp
                         WindowSystemInfo.cpp
                         CharacterWidth.cpp
                         ${CMAKE_CURRENT_BINARY_DIR}/org.kde.konsole.Window.xml
                         ${CMAKE_CURRENT_BINARY_DIR}/org.kde.konsole.Session.xml)
 
 ecm_qt_declare_logging_category(konsoleprivate_SRCS HEADER konsoledebug.h IDENTIFIER KonsoleDebug CATEGORY_NAME org.kde.konsole)
 
 kconfig_add_kcfg_files(konsoleprivate_SRCS settings/KonsoleSettings.kcfgc)
 
 set(konsole_LIBS
                  KF5::XmlGui
                  Qt5::PrintSupport
                  Qt5::Xml
-                 KF5::Notifications
                  KF5::WindowSystem
                  KF5::TextWidgets
                  KF5::GuiAddons
                  KF5::IconThemes
                  KF5::Bookmarks
                  KF5::I18n
                  KF5::Pty
                  KF5::KIOWidgets
                  KF5::DBusAddons
                  KF5::GlobalAccel
                  KF5::NewStuff
 )
+if (NOT WITHOUT_KNOTIFY)
+    list(APPEND konsole_LIBS KF5::Notifications)
+endif()
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
     #kinfo_getfile() is in libutil
     list(APPEND konsole_LIBS util)
 endif()
 
 ### Konsole Application
 
 ki18n_wrap_ui(konsoleprivate_SRCS ColorSchemeEditor.ui
                                 CopyInputDialog.ui
                                 EditProfileDialog.ui
                                 KeyBindingEditor.ui
                                 RenameTabDialog.ui
                                 RenameTabWidget.ui
                                 HistorySizeDialog.ui
                                 HistorySizeWidget.ui
                                 PrintOptions.ui
                                 settings/FileLocationSettings.ui
                                 settings/GeneralSettings.ui
                                 settings/PartInfo.ui
                                 settings/ProfileSettings.ui
                                 settings/TabBarSettings.ui)
 
 # add the resource files for the ui files
 qt5_add_resources( konsoleprivate_SRCS ../desktop/konsole.qrc)
 
 add_library(konsoleprivate ${konsoleprivate_SRCS})
 generate_export_header(konsoleprivate BASE_NAME konsoleprivate)
 target_link_libraries(konsoleprivate PUBLIC ${konsole_LIBS})
 
 set_target_properties(konsoleprivate PROPERTIES
     VERSION ${KONSOLEPRIVATE_VERSION_STRING}
     SOVERSION ${KONSOLEPRIVATE_SOVERSION}
 )
 
 install(TARGETS konsoleprivate ${KDE_INSTALL_TARGETS_DEFAULT_ARGS} LIBRARY NAMELINK_SKIP)
 
 set(konsole_KDEINIT_SRCS
    Application.cpp
    MainWindow.cpp
    main.cpp
    settings/FileLocationSettings.cpp
    settings/GeneralSettings.cpp
    settings/ProfileSettings.cpp
    settings/TabBarSettings.cpp)
 
 
 # Sets the icon on Windows and OSX
 file(GLOB ICONS_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/../data/icons/*.png")
 ecm_add_app_icon(kdeinit_konsole ICONS ${ICONS_SRCS})
 
 kf5_add_kdeinit_executable(konsole ${konsole_KDEINIT_SRCS})
-target_link_libraries(kdeinit_konsole konsoleprivate KF5::XmlGui KF5::WindowSystem KF5::Bookmarks
-  KF5::I18n
-  KF5::KIOWidgets
-  KF5::NotifyConfig
-  KF5::Crash
+
+set(konsole_KDEINIT_LIBS
+    KF5::XmlGui KF5::WindowSystem KF5::Bookmarks
+    KF5::I18n
+    KF5::KIOWidgets
+    KF5::Crash
+    )
+
+if (NOT WITHOUT_KNOTIFY)
+    list(APPEND konsole_KDEINIT_LIBS KF5::NotifyConfig)
+endif()
+
+target_link_libraries(kdeinit_konsole konsoleprivate
+    ${konsole_KDEINIT_LIBS}
 )
 
 if(APPLE)
     set_target_properties(konsole PROPERTIES
         MACOSX_BUNDLE_GUI_IDENTIFIER "org.kde.konsole"
         MACOSX_BUNDLE_BUNDLE_NAME "Konsole"
         MACOSX_BUNDLE_DISPLAY_NAME "Konsole"
         MACOSX_BUNDLE_INFO_STRING "Konsole, the KDE terminal emulator"
         MACOSX_BUNDLE_LONG_VERSION_STRING "Konsole ${KDE_APPLICATIONS_VERSION}"
         MACOSX_BUNDLE_SHORT_VERSION_STRING "${KDE_APPLICATIONS_VERSION_MAJOR}.${KDE_APPLICATIONS_VERSION_MINOR}"
         MACOSX_BUNDLE_BUNDLE_VERSION "${KDE_APPLICATIONS_VERSION}"
         MACOSX_BUNDLE_COPYRIGHT "1997-2016 The Konsole Developers")
 endif()
 
 install(TARGETS kdeinit_konsole konsole
        ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
 
 ### Embedded Konsole KPart
 
 set(konsolepart_PART_SRCS Part.cpp
     settings/PartInfo.cpp
     settings/ProfileSettings.cpp)
 add_library(konsolepart MODULE ${konsolepart_PART_SRCS})
 generate_export_header(konsolepart BASE_NAME konsole)
 kcoreaddons_desktop_to_json(konsolepart ../desktop/konsolepart.desktop)
 set_target_properties(konsolepart PROPERTIES DEFINE_SYMBOL KONSOLE_PART)
 target_link_libraries(konsolepart KF5::Parts KF5::XmlGui konsoleprivate)
 install(TARGETS konsolepart  DESTINATION ${KDE_INSTALL_PLUGINDIR})
 
diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
index 30df398d..46745aab 100644
--- a/src/MainWindow.cpp
+++ b/src/MainWindow.cpp
@@ -1,878 +1,889 @@
 /*
     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.
 */
 
+// Config
+#include <config-konsole.h>
+
 // Own
 #include "MainWindow.h"
 
 // Qt
 #include <QVBoxLayout>
 #include <QMouseEvent>
 
 // KDE
 #include <KAcceleratorManager>
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KShortcutsDialog>
 #include <KLocalizedString>
 #include <KToggleAction>
 #include <KToggleFullScreenAction>
 #include <KWindowEffects>
 
 #include <QMenu>
 #include <QMenuBar>
 #include <KMessageBox>
 #include <KStandardAction>
 #include <KStandardGuiItem>
 #include <KWindowSystem>
 #include <KXMLGUIFactory>
-#include <KNotifyConfigWidget>
 #include <KConfigDialog>
 #include <KIconLoader>
 
+#ifndef WITHOUT_KNOTIFY
+#include <KNotifyConfigWidget>
+#endif
+
 // Konsole
 #include "BookmarkHandler.h"
 #include "SessionController.h"
 #include "ProfileList.h"
 #include "Session.h"
 #include "ViewManager.h"
 #include "SessionManager.h"
 #include "ProfileManager.h"
 #include "KonsoleSettings.h"
 #include "WindowSystemInfo.h"
 #include "TerminalDisplay.h"
 #include "settings/FileLocationSettings.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,
             static_cast<void (ViewManager::*)(Profile::Ptr)>(&Konsole::ViewManager::newViewRequest),
             this,
             &Konsole::MainWindow::newFromProfile);
     connect(_viewManager,
             static_cast<void (ViewManager::*)()>(&Konsole::ViewManager::newViewRequest), this,
             &Konsole::MainWindow::newTab);
     connect(_viewManager, &Konsole::ViewManager::viewDetached, this,
             &Konsole::MainWindow::viewDetached);
 
     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()
 {
     foreach (QAction *menuItem, menuBar()->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()
 {
     foreach (QAction *menuItem, menuBar()->actions()) {
         menuItem->setText(menuItem->text().replace(QLatin1Char('&'), QString()));
     }
 }
 
 void MainWindow::restoreMenuAccelerators()
 {
     foreach (QAction *menuItem, menuBar()->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);
     }
 }
 
 void MainWindow::activeViewChanged(SessionController *controller)
 {
     // associate bookmark menu with current session
     bookmarkHandler()->setActiveView(controller);
     disconnect(bookmarkHandler(), &Konsole::BookmarkHandler::openUrl, nullptr, nullptr);
     connect(bookmarkHandler(), &Konsole::BookmarkHandler::openUrl, controller,
             &Konsole::SessionController::openUrl);
 
     if (!_pluggedController.isNull()) {
         disconnectController(_pluggedController);
     }
 
     Q_ASSERT(controller);
     _pluggedController = controller;
     _pluggedController->view()->installEventFilter(this);
 
     setBlur(ViewManager::profileHasBlurEnabled(SessionManager::instance()->sessionProfile(_pluggedController->session())));
 
     // listen for title changes from the current session
     connect(controller, &Konsole::SessionController::titleChanged, this,
             &Konsole::MainWindow::activeViewTitleChanged);
     connect(controller, &Konsole::SessionController::rawTitleChanged, this,
             &Konsole::MainWindow::updateWindowCaption);
     connect(controller, &Konsole::SessionController::iconChanged, this,
             &Konsole::MainWindow::updateWindowIcon);
 
     controller->setShowMenuAction(_toggleMenuBarAction);
     guiFactory()->addClient(controller);
 
     // update session title to match newly activated session
     activeViewTitleChanged(controller);
 
     // Update window icon to newly activated session's icon
     updateWindowIcon();
 }
 
 void MainWindow::activeViewTitleChanged(ViewProperties *properties)
 {
     Q_UNUSED(properties);
     updateWindowCaption();
 }
 
 void MainWindow::updateWindowCaption()
 {
     if (_pluggedController.isNull()) {
         return;
     }
 
     const QString &title = _pluggedController->title();
     const QString &userTitle = _pluggedController->userTitle();
 
     // use tab title as caption by default
     QString caption = title;
 
     // use window title as caption when this setting is enabled
     // if the userTitle is empty, use a blank space (using an empty string
     // removes the dash — before the application name; leaving the dash
     // looks better)
     if (KonsoleSettings::showWindowTitleOnTitleBar()) {
         !userTitle.isEmpty() ? caption = userTitle : caption = QStringLiteral(" ");
     }
 
     if (KonsoleSettings::showAppNameOnTitleBar()) {
         setCaption(caption);
     } else {
         setPlainCaption(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, &Konsole::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);
 
+#ifndef WITHOUT_KNOTIFY
     KStandardAction::configureNotifications(this, SLOT(configureNotifications()), collection);
+#endif
+
     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,
             &Konsole::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());
         }
         foreach (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();
 
     Q_FOREACH (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();
     }
 
     Session *session = SessionManager::instance()->createSession(profile);
 
     if (!directory.isEmpty() && profile->startInCurrentSessionDir()) {
         session->setInitialWorkingDirectory(directory);
     }
 
     session->addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_WINDOW=/Windows/%1").arg(_viewManager->managerId()));
 
     // 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
     _viewManager->createView(session);
 
     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
     _viewManager->createView(session);
 
     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());
 
     foreach (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(), true);
     }
     int result;
 
     if (processesRunning.count() > 0) {
         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(),
                                                      QStringLiteral("CloseAllTabs"));
     } else {
         result = KMessageBox::warningYesNoCancel(this,
                                                  i18nc("@info",
                                                        "There are %1 open tabs 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(),
                                                  QStringLiteral("CloseAllEmptyTabs"));
     }
 
     switch (result) {
     case KMessageBox::Yes:
         return true;
     case KMessageBox::No:
         if ((!_pluggedController.isNull()) && (!_pluggedController->session().isNull())) {
             disconnectController(_pluggedController);
             _pluggedController->session()->closeInNormalWay();
         }
         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)
 {
     foreach (QAction *qAction, source->actions()) {
         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
     foreach (KXMLGUIClient *client, guiFactory()->clients()) {
         dialog.addCollection(client->actionCollection());
     }
 
     if (dialog.configure()) {
         // sync shortcuts for non-session actions (defined in "konsoleui.rc") in other main windows
         foreach (QWidget *mainWindowWidget, QApplication::topLevelWidgets()) {
             MainWindow *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.
         foreach (SessionController *controller, SessionController::allControllers()) {
             controller->reloadXML();
             if ((controller->factory() != nullptr) && controller != _pluggedController) {
                 syncActiveShortcuts(controller->actionCollection(), _pluggedController->actionCollection());
             }
         }
     }
 }
 
 void MainWindow::newFromProfile(Profile::Ptr profile)
 {
     createSession(profile, activeSessionDir());
 }
 
 void MainWindow::showManageProfilesDialog()
 {
     showSettingsDialog(true);
 }
 
 void MainWindow::showSettingsDialog(const bool showProfilePage)
 {
     if (KConfigDialog::showDialog(QStringLiteral("settings"))) {
         return;
     }
 
     KConfigDialog *settingsDialog = new KConfigDialog(this, QStringLiteral("settings"), KonsoleSettings::self());
     settingsDialog->setFaceType(KPageDialog::Tabbed);
 
     auto generalSettings = new GeneralSettings(settingsDialog);
     settingsDialog->addPage(generalSettings,
                             i18nc("@title Preferences page name", "General"),
                             QStringLiteral("utilities-terminal"));
 
     auto profileSettings = new ProfileSettings(settingsDialog);
     KPageWidgetItem *profilePage = settingsDialog->addPage(profileSettings,
                                                            i18nc("@title Preferences page name",
                                                                  "Profiles"),
                                                            QStringLiteral("configure"));
 
     auto tabBarSettings = new TabBarSettings(settingsDialog);
     settingsDialog->addPage(tabBarSettings,
                             i18nc("@title Preferences page name", "TabBar"),
                             QStringLiteral("system-run"));
 
     auto fileLocationSettings = new FileLocationSettings(settingsDialog);
     settingsDialog->addPage(fileLocationSettings,
                             i18nc("@title Preferences page name", "File Location"),
                             QStringLiteral("configure"));
 
     if (showProfilePage) {
         settingsDialog->setCurrentPage(profilePage);
     }
 
     settingsDialog->show();
 }
 
 void MainWindow::applyKonsoleSettings()
 {
     setMenuBarInitialVisibility(KonsoleSettings::showMenuBarByDefault());
 
     if (KonsoleSettings::allowMenuAccelerators()) {
         restoreMenuAccelerators();
     } else {
         removeMenuAccelerators();
     }
 
     _viewManager->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()
 {
+#ifndef WITHOUT_KNOTIFY
     KNotifyConfigWidget::configure(this);
+#endif
 }
 
 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::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 (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/Session.cpp b/src/Session.cpp
index c1161ebe..17d7a322 100644
--- a/src/Session.cpp
+++ b/src/Session.cpp
@@ -1,1774 +1,1792 @@
 /*
     This file is part of Konsole
 
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
     Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
     Copyright 2009 by Thomas Dreibholz <dreibh@iem.uni-due.de>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "Session.h"
 
 // Standard
 #include <stdlib.h>
 #include <signal.h>
 #include <unistd.h>
 
 // Qt
 #include <QApplication>
 #include <QColor>
 #include <QDir>
 #include <QFile>
 #include <QStringList>
 #include <QKeyEvent>
 
 // KDE
 #include <KLocalizedString>
-#include <KNotification>
 #include <KRun>
 #include <KShell>
 #include <KProcess>
 #include <KConfigGroup>
 
+#ifndef WITHOUT_KNOTIFY
+#include <KNotification>
+#endif
+
 // Konsole
 #include <sessionadaptor.h>
 
 #include "ProcessInfo.h"
 #include "Pty.h"
 #include "TerminalDisplay.h"
 #include "ShellCommand.h"
 #include "Vt102Emulation.h"
 #include "ZModemDialog.h"
 #include "History.h"
 #include "konsoledebug.h"
 #include "SessionManager.h"
 #include "ProfileManager.h"
 #include "Profile.h"
 
 using namespace Konsole;
 
 int Session::lastSessionId = 0;
 static bool show_disallow_certain_dbus_methods_message = true;
 
 static const int ZMODEM_BUFFER_SIZE = 1048576; // 1 Mb
 
 Session::Session(QObject* parent) :
     QObject(parent)
     , _uniqueIdentifier(QUuid())
     , _shellProcess(nullptr)
     , _emulation(nullptr)
     , _views(QList<TerminalDisplay *>())
     , _monitorActivity(false)
     , _monitorSilence(false)
     , _notifiedActivity(false)
     , _silenceSeconds(10)
     , _silenceTimer(nullptr)
     , _activityTimer(nullptr)
     , _autoClose(true)
     , _closePerUserRequest(false)
     , _nameTitle(QString())
     , _displayTitle(QString())
     , _userTitle(QString())
     , _localTabTitleFormat(QString())
     , _remoteTabTitleFormat(QString())
     , _tabTitleSetByUser(false)
     , _iconName(QString())
     , _iconText(QString())
     , _addToUtmp(true)
     , _flowControlEnabled(true)
     , _program(QString())
     , _arguments(QStringList())
     , _environment(QStringList())
     , _sessionId(0)
     , _initialWorkingDir(QString())
     , _currentWorkingDir(QString())
     , _reportedWorkingUrl(QUrl())
     , _sessionProcessInfo(nullptr)
     , _foregroundProcessInfo(nullptr)
     , _foregroundPid(0)
     , _zmodemBusy(false)
     , _zmodemProc(nullptr)
     , _zmodemProgress(nullptr)
     , _hasDarkBackground(false)
     , _preferredSize(QSize())
     , _readOnly(false)
     , _isPrimaryScreen(true)
 {
     _uniqueIdentifier = QUuid::createUuid();
 
     //prepare DBus communication
     new SessionAdaptor(this);
     _sessionId = ++lastSessionId;
     QDBusConnection::sessionBus().registerObject(QLatin1String("/Sessions/") + QString::number(_sessionId), this);
 
     //create emulation backend
     _emulation = new Vt102Emulation();
 
     connect(_emulation, &Konsole::Emulation::sessionAttributeChanged, this, &Konsole::Session::setSessionAttribute);
     connect(_emulation, &Konsole::Emulation::stateSet, this, &Konsole::Session::activityStateSet);
     connect(_emulation, &Konsole::Emulation::zmodemDownloadDetected, this, &Konsole::Session::fireZModemDownloadDetected);
     connect(_emulation, &Konsole::Emulation::zmodemUploadDetected, this, &Konsole::Session::fireZModemUploadDetected);
     connect(_emulation, &Konsole::Emulation::changeTabTextColorRequest, this, &Konsole::Session::changeTabTextColorRequest);
     connect(_emulation, &Konsole::Emulation::profileChangeCommandReceived, this, &Konsole::Session::profileChangeCommandReceived);
     connect(_emulation, &Konsole::Emulation::flowControlKeyPressed, this, &Konsole::Session::updateFlowControlState);
     connect(_emulation, &Konsole::Emulation::primaryScreenInUse, this, &Konsole::Session::onPrimaryScreenInUse);
     connect(_emulation, &Konsole::Emulation::selectionChanged, this, &Konsole::Session::selectionChanged);
     connect(_emulation, &Konsole::Emulation::imageResizeRequest, this, &Konsole::Session::resizeRequest);
     connect(_emulation, &Konsole::Emulation::sessionAttributeRequest, this, &Konsole::Session::sessionAttributeRequest);
 
     //create new teletype for I/O with shell process
     openTeletype(-1);
 
     //setup timer for monitoring session activity & silence
     _silenceTimer = new QTimer(this);
     _silenceTimer->setSingleShot(true);
     connect(_silenceTimer, &QTimer::timeout, this, &Konsole::Session::silenceTimerDone);
 
     _activityTimer = new QTimer(this);
     _activityTimer->setSingleShot(true);
     connect(_activityTimer, &QTimer::timeout, this, &Konsole::Session::activityTimerDone);
 }
 
 Session::~Session()
 {
     delete _foregroundProcessInfo;
     delete _sessionProcessInfo;
     delete _emulation;
     delete _shellProcess;
     delete _zmodemProc;
 }
 
 void Session::openTeletype(int fd)
 {
     if (isRunning()) {
         qWarning() << "Attempted to open teletype in a running session.";
         return;
     }
 
     delete _shellProcess;
 
     if (fd < 0) {
         _shellProcess = new Pty();
     } else {
         _shellProcess = new Pty(fd);
     }
 
     _shellProcess->setUtf8Mode(_emulation->utf8());
 
     // connect the I/O between emulator and pty process
     connect(_shellProcess, &Konsole::Pty::receivedData, this, &Konsole::Session::onReceiveBlock);
     connect(_emulation, &Konsole::Emulation::sendData, _shellProcess, &Konsole::Pty::sendData);
 
     // UTF8 mode
     connect(_emulation, &Konsole::Emulation::useUtf8Request, _shellProcess, &Konsole::Pty::setUtf8Mode);
 
     // get notified when the pty process is finished
     connect(_shellProcess, static_cast<void(Pty::*)(int,QProcess::ExitStatus)>(&Konsole::Pty::finished), this, &Konsole::Session::done);
 
     // emulator size
     // Use a direct connection to ensure that the window size is set before it runs
     connect(_emulation, &Konsole::Emulation::imageSizeChanged, this, &Konsole::Session::updateWindowSize, Qt::DirectConnection);
     connect(_emulation, &Konsole::Emulation::imageSizeInitialized, this, &Konsole::Session::run);
 }
 
 WId Session::windowId() const
 {
     // Returns a window ID for this session which is used
     // to set the WINDOWID environment variable in the shell
     // process.
     //
     // Sessions can have multiple views or no views, which means
     // that a single ID is not always going to be accurate.
     //
     // If there are no views, the window ID is just 0.  If
     // there are multiple views, then the window ID for the
     // top-level window which contains the first view is
     // returned
 
     if (_views.count() == 0) {
         return 0;
     } else {
         QWidget* window = _views.first();
 
         Q_ASSERT(window);
 
         while (window->parentWidget() != nullptr) {
             window = window->parentWidget();
         }
 
         return window->winId();
     }
 }
 
 void Session::setDarkBackground(bool darkBackground)
 {
     _hasDarkBackground = darkBackground;
 }
 
 bool Session::isRunning() const
 {
     return (_shellProcess != nullptr) && (_shellProcess->state() == QProcess::Running);
 }
 
 void Session::setCodec(QTextCodec* codec)
 {
     if (isReadOnly()) {
         return;
     }
 
     emulation()->setCodec(codec);
 }
 
 bool Session::setCodec(const QByteArray& name)
 {
     QTextCodec* codec = QTextCodec::codecForName(name);
 
     if (codec != nullptr) {
         setCodec(codec);
         return true;
     } else {
         return false;
     }
 }
 
 QByteArray Session::codec()
 {
     return _emulation->codec()->name();
 }
 
 void Session::setProgram(const QString& program)
 {
     _program = ShellCommand::expand(program);
 }
 
 void Session::setArguments(const QStringList& arguments)
 {
     _arguments = ShellCommand::expand(arguments);
 }
 
 void Session::setInitialWorkingDirectory(const QString& dir)
 {
     _initialWorkingDir = validDirectory(KShell::tildeExpand(ShellCommand::expand(dir)));
 }
 
 QString Session::currentWorkingDirectory()
 {
     if (_reportedWorkingUrl.isValid() && _reportedWorkingUrl.isLocalFile()) {
         return _reportedWorkingUrl.path();
     }
 
     // only returned cached value
     if (_currentWorkingDir.isEmpty()) {
         updateWorkingDirectory();
     }
 
     return _currentWorkingDir;
 }
 void Session::updateWorkingDirectory()
 {
     updateSessionProcessInfo();
 
     const QString currentDir = _sessionProcessInfo->validCurrentDir();
     if (currentDir != _currentWorkingDir) {
         _currentWorkingDir = currentDir;
         emit currentDirectoryChanged(_currentWorkingDir);
     }
 }
 
 QList<TerminalDisplay*> Session::views() const
 {
     return _views;
 }
 
 void Session::addView(TerminalDisplay* widget)
 {
     Q_ASSERT(!_views.contains(widget));
 
     _views.append(widget);
 
     // connect emulation - view signals and slots
     connect(widget, &Konsole::TerminalDisplay::keyPressedSignal, _emulation, &Konsole::Emulation::sendKeyEvent);
     connect(widget, &Konsole::TerminalDisplay::mouseSignal, _emulation, &Konsole::Emulation::sendMouseEvent);
     connect(widget, &Konsole::TerminalDisplay::sendStringToEmu, _emulation, &Konsole::Emulation::sendString);
 
     // allow emulation to notify the view when the foreground process
     // indicates whether or not it is interested in Mouse Tracking events
     connect(_emulation, &Konsole::Emulation::programRequestsMouseTracking, widget, &Konsole::TerminalDisplay::setUsesMouseTracking);
 
     widget->setUsesMouseTracking(_emulation->programUsesMouseTracking());
 
     connect(_emulation, &Konsole::Emulation::enableAlternateScrolling, widget, &Konsole::TerminalDisplay::setAlternateScrolling);
 
     connect(_emulation, &Konsole::Emulation::programBracketedPasteModeChanged, widget, &Konsole::TerminalDisplay::setBracketedPasteMode);
 
     widget->setBracketedPasteMode(_emulation->programBracketedPasteMode());
 
     widget->setScreenWindow(_emulation->createWindow());
 
     //connect view signals and slots
     connect(widget, &Konsole::TerminalDisplay::changedContentSizeSignal, this, &Konsole::Session::onViewSizeChange);
 
     connect(widget, &Konsole::TerminalDisplay::destroyed, this, &Konsole::Session::viewDestroyed);
 
     connect(widget, &Konsole::TerminalDisplay::focusLost, _emulation, &Konsole::Emulation::focusLost);
     connect(widget, &Konsole::TerminalDisplay::focusGained, _emulation, &Konsole::Emulation::focusGained);
 
     connect(_emulation, &Konsole::Emulation::setCursorStyleRequest, widget, &Konsole::TerminalDisplay::setCursorStyle);
     connect(_emulation, &Konsole::Emulation::resetCursorStyleRequest, widget, &Konsole::TerminalDisplay::resetCursorStyle);
 }
 
 void Session::viewDestroyed(QObject* view)
 {
     TerminalDisplay* display = reinterpret_cast<TerminalDisplay*>(view);
 
     Q_ASSERT(_views.contains(display));
 
     removeView(display);
 }
 
 void Session::removeView(TerminalDisplay* widget)
 {
     _views.removeAll(widget);
 
     disconnect(widget, nullptr, this, nullptr);
 
     // disconnect
     //  - key presses signals from widget
     //  - mouse activity signals from widget
     //  - string sending signals from widget
     //
     //  ... and any other signals connected in addView()
     disconnect(widget, nullptr, _emulation, nullptr);
 
     // disconnect state change signals emitted by emulation
     disconnect(_emulation, nullptr, widget, nullptr);
 
     // close the session automatically when the last view is removed
     if (_views.count() == 0) {
         close();
     }
 }
 
 // Upon a KPty error, there is no description on what that error was...
 // Check to see if the given program is executable.
 QString Session::checkProgram(const QString& program)
 {
     QString exec = program;
 
     if (exec.isEmpty()) {
         return QString();
     }
 
     QFileInfo info(exec);
     if (info.isAbsolute() && info.exists() && info.isExecutable()) {
         return exec;
     }
 
     exec = KRun::binaryName(exec, false);
     exec = KShell::tildeExpand(exec);
     const QString pexec = QStandardPaths::findExecutable(exec);
     if (pexec.isEmpty()) {
         qCritical() << i18n("Could not find binary: ") << exec;
         return QString();
     }
 
     return exec;
 }
 
 void Session::terminalWarning(const QString& message)
 {
     static const QByteArray warningText = i18nc("@info:shell Alert the user with red color text", "Warning: ").toLocal8Bit();
     QByteArray messageText = message.toLocal8Bit();
 
     static const char redPenOn[] = "\033[1m\033[31m";
     static const char redPenOff[] = "\033[0m";
 
     _emulation->receiveData(redPenOn, qstrlen(redPenOn));
     _emulation->receiveData("\n\r\n\r", 4);
     _emulation->receiveData(warningText.constData(), qstrlen(warningText.constData()));
     _emulation->receiveData(messageText.constData(), qstrlen(messageText.constData()));
     _emulation->receiveData("\n\r\n\r", 4);
     _emulation->receiveData(redPenOff, qstrlen(redPenOff));
 }
 
 QString Session::shellSessionId() const
 {
     QString friendlyUuid(_uniqueIdentifier.toString());
     friendlyUuid.remove(QLatin1Char('-')).remove(QLatin1Char('{')).remove(QLatin1Char('}'));
 
     return friendlyUuid;
 }
 
 void Session::run()
 {
     // FIXME: run() is called twice in some instances
     if (isRunning()) {
         qCDebug(KonsoleDebug) << "Attempted to re-run an already running session (" << _shellProcess->pid() << ")";
         return;
     }
 
     //check that everything is in place to run the session
     if (_program.isEmpty()) {
         qWarning() << "Program to run not set.";
     }
     if (_arguments.isEmpty()) {
         qWarning() << "No command line arguments specified.";
     }
     if (_uniqueIdentifier.isNull()) {
         _uniqueIdentifier = QUuid::createUuid();
     }
 
     const int CHOICE_COUNT = 3;
     // if '_program' is empty , fall back to default shell. If that is not set
     // then fall back to /bin/sh
     QString programs[CHOICE_COUNT] = {_program, QString::fromUtf8(qgetenv("SHELL")), QStringLiteral("/bin/sh")};
     QString exec;
     int choice = 0;
     while (choice < CHOICE_COUNT) {
         exec = checkProgram(programs[choice]);
         if (exec.isEmpty()) {
             choice++;
         } else {
             break;
         }
     }
 
     // if a program was specified via setProgram(), but it couldn't be found, print a warning
     if (choice != 0 && choice < CHOICE_COUNT && !_program.isEmpty()) {
         terminalWarning(i18n("Could not find '%1', starting '%2' instead.  Please check your profile settings.", _program, exec));
         // if none of the choices are available, print a warning
     } else if (choice == CHOICE_COUNT) {
         terminalWarning(i18n("Could not find an interactive shell to start."));
         return;
     }
 
     // if no arguments are specified, fall back to program name
     QStringList arguments = _arguments.join(QLatin1Char(' ')).isEmpty() ?
                             QStringList() << exec :
                             _arguments;
 
     if (!_initialWorkingDir.isEmpty()) {
         _shellProcess->setInitialWorkingDirectory(_initialWorkingDir);
     } else {
         _shellProcess->setInitialWorkingDirectory(QDir::currentPath());
     }
 
     _shellProcess->setFlowControlEnabled(_flowControlEnabled);
     _shellProcess->setEraseChar(_emulation->eraseChar());
     _shellProcess->setUseUtmp(_addToUtmp);
 
     // this is not strictly accurate use of the COLORFGBG variable.  This does not
     // tell the terminal exactly which colors are being used, but instead approximates
     // the color scheme as "black on white" or "white on black" depending on whether
     // the background color is deemed dark or not
     const QString backgroundColorHint = _hasDarkBackground ? QStringLiteral("COLORFGBG=15;0") : QStringLiteral("COLORFGBG=0;15");
     addEnvironmentEntry(backgroundColorHint);
 
     addEnvironmentEntry(QStringLiteral("SHELL_SESSION_ID=%1").arg(shellSessionId()));
 
     addEnvironmentEntry(QStringLiteral("WINDOWID=%1").arg(QString::number(windowId())));
 
     const QString dbusService = QDBusConnection::sessionBus().baseService();
     addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_SERVICE=%1").arg(dbusService));
 
     const QString dbusObject = QStringLiteral("/Sessions/%1").arg(QString::number(_sessionId));
     addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_SESSION=%1").arg(dbusObject));
 
     int result = _shellProcess->start(exec, arguments, _environment);
     if (result < 0) {
         terminalWarning(i18n("Could not start program '%1' with arguments '%2'.", exec, arguments.join(QLatin1String(" "))));
         terminalWarning(_shellProcess->errorString());
         return;
     }
 
     _shellProcess->setWriteable(false);  // We are reachable via kwrited.
 
     emit started();
 }
 
 void Session::setSessionAttribute(int what, const QString& caption)
 {
     // set to true if anything has actually changed
     // eg. old _nameTitle != new _nameTitle
     bool modified = false;
 
     if ((what == IconNameAndWindowTitle) || (what == WindowTitle)) {
         if (_userTitle != caption) {
             _userTitle = caption;
             modified = true;
         }
     }
 
     if ((what == IconNameAndWindowTitle) || (what == IconName)) {
         if (_iconText != caption) {
             _iconText = caption;
             modified = true;
         }
     }
 
     if (what == TextColor || what == BackgroundColor) {
         QString colorString = caption.section(QLatin1Char(';'), 0, 0);
         QColor color = QColor(colorString);
         if (color.isValid()) {
             if (what == TextColor) {
                 emit changeForegroundColorRequest(color);
             } else {
                 emit changeBackgroundColorRequest(color);
             }
         }
     }
 
     if (what == SessionName) {
         if (_localTabTitleFormat != caption) {
             _localTabTitleFormat = caption;
             setTitle(Session::DisplayedTitleRole, caption);
             modified = true;
         }
     }
 
     /* I don't believe this has ever worked in KDE 4.x
     if (what == 31) {
         QString cwd = caption;
         cwd = cwd.replace(QRegExp("^~"), QDir::homePath());
         emit openUrlRequest(cwd);
     }*/
 
     /* The below use of 32 works but appears to non-standard.
        It is from a commit from 2004 c20973eca8776f9b4f15bee5fdcb5a3205aa69de
      */
     // change icon via \033]32;Icon\007
     if (what == SessionIcon) {
         if (_iconName != caption) {
             _iconName = caption;
 
             modified = true;
         }
     }
 
     if (what == CurrentDirectory) {
         _reportedWorkingUrl = QUrl::fromUserInput(caption);
         emit currentDirectoryChanged(currentWorkingDirectory());
         modified = true;
     }
 
     if (what == ProfileChange) {
         emit profileChangeCommandReceived(caption);
         return;
     }
 
     if (modified) {
         emit sessionAttributeChanged();
     }
 }
 
 QString Session::userTitle() const
 {
     return _userTitle;
 }
 void Session::setTabTitleFormat(TabTitleContext context , const QString& format)
 {
     if (context == LocalTabTitle) {
         _localTabTitleFormat = format;
         ProcessInfo* process = getProcessInfo();
         process->setUserNameRequired(format.contains(QLatin1String("%u")));
     } else if (context == RemoteTabTitle) {
         _remoteTabTitleFormat = format;
     }
 }
 QString Session::tabTitleFormat(TabTitleContext context) const
 {
     if (context == LocalTabTitle) {
         return _localTabTitleFormat;
     } else if (context == RemoteTabTitle) {
         return _remoteTabTitleFormat;
     }
 
     return QString();
 }
 
 void Session::tabTitleSetByUser(bool set)
 {
     _tabTitleSetByUser = set;
 }
 
 bool Session::isTabTitleSetByUser() const
 {
     return _tabTitleSetByUser;
 }
 
 void Session::silenceTimerDone()
 {
     //FIXME: The idea here is that the notification popup will appear to tell the user than output from
     //the terminal has stopped and the popup will disappear when the user activates the session.
     //
     //This breaks with the addition of multiple views of a session.  The popup should disappear
     //when any of the views of the session becomes active
 
     //FIXME: Make message text for this notification and the activity notification more descriptive.
     if (!_monitorSilence) {
         emit stateChanged(NOTIFYNORMAL);
         return;
     }
 
     bool hasFocus = false;
     foreach(TerminalDisplay *display, _views) {
         if (display->hasFocus()) {
             hasFocus = true;
             break;
         }
     }
 
+#ifndef WITHOUT_KNOTIFY
     KNotification::event(hasFocus ? QStringLiteral("Silence") : QStringLiteral("SilenceHidden"),
             i18n("Silence in session '%1'", _nameTitle), QPixmap(),
             QApplication::activeWindow(),
             KNotification::CloseWhenWidgetActivated);
+#else
+    emit bellRequest(i18n("Silence in session '%1'", _nameTitle));
+#endif
+
     emit stateChanged(NOTIFYSILENCE);
 }
 
 void Session::activityTimerDone()
 {
     _notifiedActivity = false;
 }
 
 void Session::updateFlowControlState(bool suspended)
 {
     if (suspended) {
         if (flowControlEnabled()) {
             foreach(TerminalDisplay * display, _views) {
                 if (display->flowControlWarningEnabled()) {
                     display->outputSuspended(true);
                 }
             }
         }
     } else {
         foreach(TerminalDisplay * display, _views) {
             display->outputSuspended(false);
         }
     }
 }
 
 void Session::onPrimaryScreenInUse(bool use)
 {
 
     _isPrimaryScreen = use;
     emit primaryScreenInUse(use);
 }
 bool Session::isPrimaryScreen()
 {
     return _isPrimaryScreen;
 }
 
 void Session::sessionAttributeRequest(int id)
 {
     switch (id) {
         case BackgroundColor:
             // Get 'TerminalDisplay' (_view) background color
             emit getBackgroundColor();
             break;
     }
 }
 
 void Session::activityStateSet(int state)
 {
     // TODO: should this hardcoded interval be user configurable?
     const int activityMaskInSeconds = 15;
 
     if (state == NOTIFYBELL) {
         emit bellRequest(i18n("Bell in session '%1'", _nameTitle));
     } else if (state == NOTIFYACTIVITY) {
         // Don't notify if the terminal is active
         bool hasFocus = false;
         foreach(TerminalDisplay *display, _views) {
             if (display->hasFocus()) {
                 hasFocus = true;
                 break;
             }
         }
 
         if (_monitorActivity  && !_notifiedActivity) {
+#ifndef WITHOUT_KNOTIFY
             KNotification::event(hasFocus ? QStringLiteral("Activity") : QStringLiteral("ActivityHidden"),
                                  i18n("Activity in session '%1'", _nameTitle), QPixmap(),
                                  QApplication::activeWindow(),
                                  KNotification::CloseWhenWidgetActivated);
+#else
+            emit bellRequest(i18n("Activity in session '%1'", _nameTitle));
+#endif
 
             // mask activity notification for a while to avoid flooding
             _notifiedActivity = true;
             _activityTimer->start(activityMaskInSeconds * 1000);
         }
 
         // reset the counter for monitoring continuous silence since there is activity
         if (_monitorSilence) {
             _silenceTimer->start(_silenceSeconds * 1000);
         }
     }
 
     if (state == NOTIFYACTIVITY && !_monitorActivity) {
         state = NOTIFYNORMAL;
     }
     if (state == NOTIFYSILENCE && !_monitorSilence) {
         state = NOTIFYNORMAL;
     }
 
     emit stateChanged(state);
 }
 
 void Session::onViewSizeChange(int /*height*/, int /*width*/)
 {
     updateTerminalSize();
 }
 
 void Session::updateTerminalSize()
 {
     int minLines = -1;
     int minColumns = -1;
 
     // minimum number of lines and columns that views require for
     // their size to be taken into consideration ( to avoid problems
     // with new view widgets which haven't yet been set to their correct size )
     const int VIEW_LINES_THRESHOLD = 2;
     const int VIEW_COLUMNS_THRESHOLD = 2;
 
     //select largest number of lines and columns that will fit in all visible views
     foreach(TerminalDisplay* view, _views) {
         if (!view->isHidden() &&
                 view->lines() >= VIEW_LINES_THRESHOLD &&
                 view->columns() >= VIEW_COLUMNS_THRESHOLD) {
             minLines = (minLines == -1) ? view->lines() : qMin(minLines , view->lines());
             minColumns = (minColumns == -1) ? view->columns() : qMin(minColumns , view->columns());
             view->processFilters();
         }
     }
 
     // backend emulation must have a _terminal of at least 1 column x 1 line in size
     if (minLines > 0 && minColumns > 0) {
         _emulation->setImageSize(minLines , minColumns);
     }
 }
 void Session::updateWindowSize(int lines, int columns)
 {
     Q_ASSERT(lines > 0 && columns > 0);
     _shellProcess->setWindowSize(columns, lines);
 }
 void Session::refresh()
 {
     // attempt to get the shell process to redraw the display
     //
     // this requires the program running in the shell
     // to cooperate by sending an update in response to
     // a window size change
     //
     // the window size is changed twice, first made slightly larger and then
     // resized back to its normal size so that there is actually a change
     // in the window size (some shells do nothing if the
     // new and old sizes are the same)
     //
     // if there is a more 'correct' way to do this, please
     // send an email with method or patches to konsole-devel@kde.org
 
     const QSize existingSize = _shellProcess->windowSize();
     _shellProcess->setWindowSize(existingSize.width() + 1, existingSize.height());
     // introduce small delay to avoid changing size too quickly
     QThread::usleep(500);
     _shellProcess->setWindowSize(existingSize.width(), existingSize.height());
 }
 
 void Session::sendSignal(int signal)
 {
     const ProcessInfo* process = getProcessInfo();
     bool ok = false;
     int pid;
     pid = process->foregroundPid(&ok);
 
     if (ok) {
         ::kill(pid, signal);
     }
 }
 
 void Session::reportBackgroundColor(const QColor& c)
 {
     #define to65k(a) (QStringLiteral("%1").arg(int(((a)*0xFFFF)), 4, 16, QLatin1Char('0')))
     QString msg = QStringLiteral("\033]11;rgb:")
                 + to65k(c.redF())   + QLatin1Char('/')
                 + to65k(c.greenF()) + QLatin1Char('/')
                 + to65k(c.blueF())  + QLatin1Char('\a');
     _emulation->sendString(msg.toUtf8());
     #undef to65k
 }
 
 bool Session::kill(int signal)
 {
     if (_shellProcess->pid() <= 0) {
         return false;
     }
 
     int result = ::kill(_shellProcess->pid(), signal);
 
     if (result == 0) {
         return _shellProcess->waitForFinished(1000);
     } else {
         return false;
     }
 }
 
 void Session::close()
 {
     if (isRunning()) {
         if (!closeInNormalWay()) {
             closeInForceWay();
         }
     } else {
         // terminal process has finished, just close the session
         QTimer::singleShot(1, this, &Konsole::Session::finished);
     }
 }
 
 bool Session::closeInNormalWay()
 {
     _autoClose    = true;
     _closePerUserRequest = true;
 
     // for the possible case where following events happen in sequence:
     //
     // 1). the terminal process crashes
     // 2). the tab stays open and displays warning message
     // 3). the user closes the tab explicitly
     //
     if (!isRunning()) {
         emit finished();
         return true;
     }
 
     static QSet<QString> knownShells({QStringLiteral("ash"), QStringLiteral("bash"), QStringLiteral("csh"), QStringLiteral("dash"), QStringLiteral("fish"), QStringLiteral("hush"), QStringLiteral("ksh"), QStringLiteral("mksh"), QStringLiteral("pdksh"), QStringLiteral("tcsh"), QStringLiteral("zsh")});
 
     // If only the session's shell is running, try sending an EOF for a clean exit
     if (!isForegroundProcessActive() && knownShells.contains(QFileInfo(_program).fileName())) {
         _shellProcess->sendEof();
 
         if (_shellProcess->waitForFinished(1000)) {
             return true;
         }
         qWarning() << "shell did not close, sending SIGHUP";
     }
 
 
     // We tried asking nicely, ask a bit less nicely
     if (kill(SIGHUP)) {
         return true;
     } else {
         qWarning() << "Process " << _shellProcess->pid() << " did not die with SIGHUP";
         _shellProcess->closePty();
         return (_shellProcess->waitForFinished(1000));
     }
 }
 
 bool Session::closeInForceWay()
 {
     _autoClose    = true;
     _closePerUserRequest = true;
 
     if (kill(SIGKILL)) {
         return true;
     } else {
         qWarning() << "Process " << _shellProcess->pid() << " did not die with SIGKILL";
         return false;
     }
 }
 
 void Session::sendTextToTerminal(const QString& text, const QChar& eol) const
 {
     if (isReadOnly()) {
         return;
     }
 
     if (eol.isNull()) {
         _emulation->sendText(text);
     } else {
         _emulation->sendText(text + eol);
     }
 }
 
 // Only D-Bus calls this function (via SendText or runCommand)
 void Session::sendText(const QString& text) const
 {
     if (isReadOnly()) {
         return;
     }
 
 #if !defined(REMOVE_SENDTEXT_RUNCOMMAND_DBUS_METHODS)
     if (show_disallow_certain_dbus_methods_message) {
 
+#ifndef WITHOUT_KNOTIFY
         KNotification::event(KNotification::Warning, QStringLiteral("Konsole D-Bus Warning"),
             i18n("The D-Bus methods sendText/runCommand were just used.  There are security concerns about allowing these methods to be public.  If desired, these methods can be changed to internal use only by re-compiling Konsole. <p>This warning will only show once for this Konsole instance.</p>"));
+#else
+        emit bellRequest(i18n("The D-Bus methods sendText/runCommand were just used.  There are security concerns about allowing these methods to be public.  If desired, these methods can be changed to internal use only by re-compiling Konsole. <p>This warning will only show once for this Konsole instance.</p>"));
+#endif
 
         show_disallow_certain_dbus_methods_message = false;
     }
 #endif
 
     _emulation->sendText(text);
 }
 
 // Only D-Bus calls this function
 void Session::runCommand(const QString& command) const
 {
     sendText(command + QLatin1Char('\n'));
 }
 
 void Session::sendMouseEvent(int buttons, int column, int line, int eventType)
 {
     _emulation->sendMouseEvent(buttons, column, line, eventType);
 }
 
 void Session::done(int exitCode, QProcess::ExitStatus exitStatus)
 {
     // This slot should be triggered only one time
     disconnect(_shellProcess, static_cast<void(Pty::*)(int,QProcess::ExitStatus)>(&Konsole::Pty::finished),
                this, &Konsole::Session::done);
 
     if (!_autoClose) {
         _userTitle = i18nc("@info:shell This session is done", "Finished");
         emit sessionAttributeChanged();
         return;
     }
 
     if (_closePerUserRequest) {
         emit finished();
         return;
     }
 
     QString message;
 
     if (exitCode != 0) {
         if (exitStatus != QProcess::NormalExit) {
             message = i18n("Program '%1' crashed.", _program);
         } else {
             message = i18n("Program '%1' exited with status %2.", _program, exitCode);
         }
 
+#ifndef WITHOUT_KNOTIFY
         //FIXME: See comments in Session::silenceTimerDone()
         KNotification::event(QStringLiteral("Finished"), message , QPixmap(),
                              QApplication::activeWindow(),
                              KNotification::CloseWhenWidgetActivated);
+#endif
     }
 
     if (exitStatus != QProcess::NormalExit) {
         // this seeming duplicated line is for the case when exitCode is 0
         message = i18n("Program '%1' crashed.", _program);
         terminalWarning(message);
     } else {
         emit finished();
     }
 }
 
 Emulation* Session::emulation() const
 {
     return _emulation;
 }
 
 QString Session::keyBindings() const
 {
     return _emulation->keyBindings();
 }
 
 QStringList Session::environment() const
 {
     return _environment;
 }
 
 void Session::setEnvironment(const QStringList& environment)
 {
     if (isReadOnly()) {
         return;
     }
 
     _environment = environment;
 }
 
 void Session::addEnvironmentEntry(const QString& entry)
 {
     _environment << entry;
 }
 
 int Session::sessionId() const
 {
     return _sessionId;
 }
 
 void Session::setKeyBindings(const QString& name)
 {
     _emulation->setKeyBindings(name);
 }
 
 void Session::setTitle(TitleRole role , const QString& newTitle)
 {
     if (title(role) != newTitle) {
         if (role == NameRole) {
             _nameTitle = newTitle;
         } else if (role == DisplayedTitleRole) {
             _displayTitle = newTitle;
         }
 
         emit sessionAttributeChanged();
     }
 }
 
 QString Session::title(TitleRole role) const
 {
     if (role == NameRole) {
         return _nameTitle;
     } else if (role == DisplayedTitleRole) {
         return _displayTitle;
     } else {
         return QString();
     }
 }
 
 ProcessInfo* Session::getProcessInfo()
 {
     ProcessInfo* process = nullptr;
 
     if (isForegroundProcessActive() && updateForegroundProcessInfo()) {
         process = _foregroundProcessInfo;
     } else {
         updateSessionProcessInfo();
         process = _sessionProcessInfo;
     }
 
     return process;
 }
 
 void Session::updateSessionProcessInfo()
 {
     Q_ASSERT(_shellProcess);
 
     bool ok;
     // The checking for pid changing looks stupid, but it is needed
     // at the moment to workaround the problem that processId() might
     // return 0
     if ((_sessionProcessInfo == nullptr) ||
             (processId() != 0 && processId() != _sessionProcessInfo->pid(&ok))) {
         delete _sessionProcessInfo;
         _sessionProcessInfo = ProcessInfo::newInstance(processId(),
                     tabTitleFormat(Session::LocalTabTitle));
         _sessionProcessInfo->setUserHomeDir();
     }
     _sessionProcessInfo->update();
 }
 
 bool Session::updateForegroundProcessInfo()
 {
     Q_ASSERT(_shellProcess);
 
     const int foregroundPid = _shellProcess->foregroundProcessGroup();
     if (foregroundPid != _foregroundPid) {
         delete _foregroundProcessInfo;
         _foregroundProcessInfo = ProcessInfo::newInstance(foregroundPid,
                     tabTitleFormat(Session::LocalTabTitle));
         _foregroundPid = foregroundPid;
     }
 
     if (_foregroundProcessInfo != nullptr) {
         _foregroundProcessInfo->update();
         return _foregroundProcessInfo->isValid();
     } else {
         return false;
     }
 }
 
 bool Session::isRemote()
 {
     ProcessInfo* process = getProcessInfo();
 
     bool ok = false;
     return (process->name(&ok) == QLatin1String("ssh") && ok);
 }
 
 QString Session::getDynamicTitle()
 {
 
     ProcessInfo* process = getProcessInfo();
 
     // format tab titles using process info
     bool ok = false;
     if (process->name(&ok) == QLatin1String("ssh") && ok) {
         SSHProcessInfo sshInfo(*process);
         return sshInfo.format(tabTitleFormat(Session::RemoteTabTitle));
     }
 
     /*
      * Parses an input string, looking for markers beginning with a '%'
      * character and returns a string with the markers replaced
      * with information from this process description.
      * <br>
      * The markers recognized are:
      * <ul>
      * <li> %u - Name of the user which owns the process. </li>
      * <li> %n - Replaced with the name of the process.   </li>
      * <li> %d - Replaced with the last part of the path name of the
      *      process' current working directory.
      *
      *      (eg. if the current directory is '/home/bob' then
      *      'bob' would be returned)
      * </li>
      * <li> %D - Replaced with the current working directory of the process. </li>
      * </ul>
      */
     QString title = tabTitleFormat(Session::LocalTabTitle);
     // search for and replace known marker
     title.replace(QLatin1String("%u"), process->userName());
     title.replace(QLatin1String("%h"), Konsole::ProcessInfo::localHost());
     title.replace(QLatin1String("%n"), process->name(&ok));
 
     QString dir = _reportedWorkingUrl.toLocalFile();
     if (dir.isEmpty()) {
         // update current directory from process
         updateWorkingDirectory();
         dir = process->validCurrentDir();
     }
 
     if (title.contains(QLatin1String("%D"))) {
         const QString homeDir = process->userHomeDir();
         if (!homeDir.isEmpty()) {
             QString tempDir = dir;
             // Change User's Home Dir w/ ~ only at the beginning
             if (tempDir.startsWith(homeDir)) {
                 tempDir.remove(0, homeDir.length());
                 tempDir.prepend(QLatin1Char('~'));
             }
             title.replace(QLatin1String("%D"), tempDir);
         } else {
             // Example: 'sudo top'  We have to replace %D with something
             title.replace(QLatin1String("%D"), QStringLiteral("-"));
         }
     }
     title.replace(QLatin1String("%d"), process->formatShortDir(dir));
 
     return title;
 }
 
 QUrl Session::getUrl()
 {
     if (_reportedWorkingUrl.isValid()) {
         return _reportedWorkingUrl;
     }
 
     QString path;
 
     updateSessionProcessInfo();
     if (_sessionProcessInfo->isValid()) {
         bool ok = false;
 
         // check if foreground process is bookmark-able
         if (isForegroundProcessActive() && _foregroundProcessInfo->isValid()) {
             // for remote connections, save the user and host
             // bright ideas to get the directory at the other end are welcome :)
             if (_foregroundProcessInfo->name(&ok) == QLatin1String("ssh") && ok) {
                 SSHProcessInfo sshInfo(*_foregroundProcessInfo);
 
                 QUrl url;
                 url.setScheme(QStringLiteral("ssh"));
                 url.setUserName(sshInfo.userName());
                 url.setHost(sshInfo.host());
 
                 const QString port = sshInfo.port();
                 if (!port.isEmpty() && port != QLatin1String("22")) {
                     url.setPort(port.toInt());
                 }
                 return url;
             } else {
                 path = _foregroundProcessInfo->currentDir(&ok);
                 if (!ok) {
                     path.clear();
                 }
             }
         } else { // otherwise use the current working directory of the shell process
             path = _sessionProcessInfo->currentDir(&ok);
             if (!ok) {
                 path.clear();
             }
         }
     }
 
     return QUrl::fromLocalFile(path);
 }
 
 void Session::setIconName(const QString& iconName)
 {
     if (iconName != _iconName) {
         _iconName = iconName;
         emit sessionAttributeChanged();
     }
 }
 
 void Session::setIconText(const QString& iconText)
 {
     _iconText = iconText;
 }
 
 QString Session::iconName() const
 {
     return isReadOnly() ? QStringLiteral("object-locked") : _iconName;
 }
 
 QString Session::iconText() const
 {
     return _iconText;
 }
 
 void Session::setHistoryType(const HistoryType& hType)
 {
     _emulation->setHistory(hType);
 }
 
 const HistoryType& Session::historyType() const
 {
     return _emulation->history();
 }
 
 void Session::clearHistory()
 {
     _emulation->clearHistory();
 }
 
 QStringList Session::arguments() const
 {
     return _arguments;
 }
 
 QString Session::program() const
 {
     return _program;
 }
 
 bool Session::isMonitorActivity() const
 {
     return _monitorActivity;
 }
 bool Session::isMonitorSilence()  const
 {
     return _monitorSilence;
 }
 
 void Session::setMonitorActivity(bool monitor)
 {
     if (_monitorActivity == monitor) {
         return;
     }
 
     _monitorActivity  = monitor;
     _notifiedActivity = false;
 
     // This timer is meaningful only after activity has been notified
     _activityTimer->stop();
 
     activityStateSet(NOTIFYNORMAL);
 }
 
 void Session::setMonitorSilence(bool monitor)
 {
     if (_monitorSilence == monitor) {
         return;
     }
 
     _monitorSilence = monitor;
     if (_monitorSilence) {
         _silenceTimer->start(_silenceSeconds * 1000);
     } else {
         _silenceTimer->stop();
     }
 
     activityStateSet(NOTIFYNORMAL);
 }
 
 void Session::setMonitorSilenceSeconds(int seconds)
 {
     _silenceSeconds = seconds;
     if (_monitorSilence) {
         _silenceTimer->start(_silenceSeconds * 1000);
     }
 }
 
 void Session::setAddToUtmp(bool add)
 {
     _addToUtmp = add;
 }
 
 void Session::setAutoClose(bool close)
 {
     _autoClose = close;
 }
 
 bool Session::autoClose() const
 {
     return _autoClose;
 }
 
 void Session::setFlowControlEnabled(bool enabled)
 {
     if (isReadOnly()) {
         return;
     }
 
     _flowControlEnabled = enabled;
 
     if (_shellProcess != nullptr) {
         _shellProcess->setFlowControlEnabled(_flowControlEnabled);
     }
 
     emit flowControlEnabledChanged(enabled);
 }
 bool Session::flowControlEnabled() const
 {
     if (_shellProcess != nullptr) {
         return _shellProcess->flowControlEnabled();
     } else {
         return _flowControlEnabled;
     }
 }
 void Session::fireZModemDownloadDetected()
 {
     if (!_zmodemBusy) {
         QTimer::singleShot(10, this, &Konsole::Session::zmodemDownloadDetected);
         _zmodemBusy = true;
     }
 }
 
 void Session::fireZModemUploadDetected()
 {
     if (!_zmodemBusy) {
         QTimer::singleShot(10, this, &Konsole::Session::zmodemUploadDetected);
     }
 }
 
 void Session::cancelZModem()
 {
     _shellProcess->sendData(QByteArrayLiteral("\030\030\030\030")); // Abort
     _zmodemBusy = false;
 }
 
 void Session::startZModem(const QString& zmodem, const QString& dir, const QStringList& list)
 {
     _zmodemBusy = true;
     _zmodemProc = new KProcess();
     _zmodemProc->setOutputChannelMode(KProcess::SeparateChannels);
 
     *_zmodemProc << zmodem << QStringLiteral("-v") << QStringLiteral("-e") << list;
 
     if (!dir.isEmpty()) {
         _zmodemProc->setWorkingDirectory(dir);
     }
 
     connect(_zmodemProc, &KProcess::readyReadStandardOutput, this, &Konsole::Session::zmodemReadAndSendBlock);
     connect(_zmodemProc, &KProcess::readyReadStandardError, this, &Konsole::Session::zmodemReadStatus);
     connect(_zmodemProc, static_cast<void(KProcess::*)(int,QProcess::ExitStatus)>(&KProcess::finished), this, &Konsole::Session::zmodemFinished);
 
     _zmodemProc->start();
 
     disconnect(_shellProcess, &Konsole::Pty::receivedData,
                this, &Konsole::Session::onReceiveBlock);
     connect(_shellProcess, &Konsole::Pty::receivedData, this, &Konsole::Session::zmodemReceiveBlock);
 
     _zmodemProgress = new ZModemDialog(QApplication::activeWindow(), false,
                                        i18n("ZModem Progress"));
 
     connect(_zmodemProgress, &Konsole::ZModemDialog::zmodemCancel, this, &Konsole::Session::zmodemFinished);
 
     _zmodemProgress->show();
 }
 
 void Session::zmodemReadAndSendBlock()
 {
     _zmodemProc->setReadChannel(QProcess::StandardOutput);
     QByteArray data = _zmodemProc->read(ZMODEM_BUFFER_SIZE);
 
     while (data.count() != 0) {
         _shellProcess->sendData(data);
         data = _zmodemProc->read(ZMODEM_BUFFER_SIZE);
     }
 }
 
 void Session::zmodemReadStatus()
 {
     _zmodemProc->setReadChannel(QProcess::StandardError);
     QByteArray msg = _zmodemProc->readAll();
     while (!msg.isEmpty()) {
         int i = msg.indexOf('\015');
         int j = msg.indexOf('\012');
         QByteArray txt;
         if ((i != -1) && ((j == -1) || (i < j))) {
             msg = msg.mid(i + 1);
         } else if (j != -1) {
             txt = msg.left(j);
             msg = msg.mid(j + 1);
         } else {
             txt = msg;
             msg.truncate(0);
         }
         if (!txt.isEmpty()) {
             _zmodemProgress->addText(QString::fromLocal8Bit(txt));
         }
     }
 }
 
 void Session::zmodemReceiveBlock(const char* data, int len)
 {
     static int steps = 0;
     QByteArray bytes(data, len);
 
     _zmodemProc->write(bytes);
 
     // Provide some feedback to dialog
     if (steps > 100) {
         _zmodemProgress->addProgressText(QStringLiteral("."));
         steps = 0;
     }
     steps++;
 }
 
 void Session::zmodemFinished()
 {
     /* zmodemFinished() is called by QProcess's finished() and
        ZModemDialog's user1Clicked(). Therefore, an invocation by
        user1Clicked() will recursively invoke this function again
        when the KProcess is deleted! */
     if (_zmodemProc != nullptr) {
         KProcess* process = _zmodemProc;
         _zmodemProc = nullptr;   // Set _zmodemProc to 0 avoid recursive invocations!
         _zmodemBusy = false;
         delete process;    // Now, the KProcess may be disposed safely.
 
         disconnect(_shellProcess, &Konsole::Pty::receivedData,
                    this , &Konsole::Session::zmodemReceiveBlock);
         connect(_shellProcess, &Konsole::Pty::receivedData, this, &Konsole::Session::onReceiveBlock);
 
         _shellProcess->sendData(QByteArrayLiteral("\030\030\030\030")); // Abort
         _shellProcess->sendData(QByteArrayLiteral("\001\013\n")); // Try to get prompt back
         _zmodemProgress->transferDone();
     }
 }
 
 void Session::onReceiveBlock(const char* buf, int len)
 {
     _emulation->receiveData(buf, len);
 }
 
 QSize Session::size()
 {
     return _emulation->imageSize();
 }
 
 void Session::setSize(const QSize& size)
 {
     if ((size.width() <= 1) || (size.height() <= 1)) {
         return;
     }
 
     emit resizeRequest(size);
 }
 
 QSize Session::preferredSize() const
 {
     return _preferredSize;
 }
 
 void Session::setPreferredSize(const QSize& size)
 {
     _preferredSize = size;
 }
 
 int Session::processId() const
 {
     return _shellProcess->pid();
 }
 
 void Session::setTitle(int role , const QString& title)
 {
     switch (role) {
     case 0:
         setTitle(Session::NameRole, title);
         break;
     case 1:
         setTitle(Session::DisplayedTitleRole, title);
 
         // without these, that title will be overridden by the expansion of
         // title format shortly after, which will confuses users.
         _localTabTitleFormat = title;
         _remoteTabTitleFormat = title;
 
         break;
     }
 }
 
 QString Session::title(int role) const
 {
     switch (role) {
     case 0:
         return title(Session::NameRole);
     case 1:
         return title(Session::DisplayedTitleRole);
     default:
         return QString();
     }
 }
 
 void Session::setTabTitleFormat(int context , const QString& format)
 {
     switch (context) {
     case 0:
         setTabTitleFormat(Session::LocalTabTitle, format);
         break;
     case 1:
         setTabTitleFormat(Session::RemoteTabTitle, format);
         break;
     }
 }
 
 QString Session::tabTitleFormat(int context) const
 {
     switch (context) {
     case 0:
         return tabTitleFormat(Session::LocalTabTitle);
     case 1:
         return tabTitleFormat(Session::RemoteTabTitle);
     default:
         return QString();
     }
 }
 
 void Session::setHistorySize(int lines)
 {
     if (isReadOnly()) {
         return;
     }
 
     if (lines < 0) {
         setHistoryType(HistoryTypeFile());
     } else if (lines == 0) {
         setHistoryType(HistoryTypeNone());
     } else {
         setHistoryType(CompactHistoryType(lines));
     }
 }
 
 int Session::historySize() const
 {
     const HistoryType& currentHistory = historyType();
 
     if (currentHistory.isEnabled()) {
         if (currentHistory.isUnlimited()) {
             return -1;
         } else {
             return currentHistory.maximumLineCount();
         }
     } else {
         return 0;
     }
 }
 
 
 void Session::setProfile(const QString &profileName)
 {
   const QList<Profile::Ptr> profiles = ProfileManager::instance()->allProfiles();
   foreach (const Profile::Ptr &profile, profiles) {
     if (profile->name() == profileName) {
       SessionManager::instance()->setSessionProfile(this, profile);
     }
   }
 }
 
 int Session::foregroundProcessId()
 {
     int pid;
 
     bool ok = false;
     pid = getProcessInfo()->pid(&ok);
     if (!ok) {
         pid = -1;
     }
 
     return pid;
 }
 
 bool Session::isForegroundProcessActive()
 {
     // foreground process info is always updated after this
     return (_shellProcess->pid() != _shellProcess->foregroundProcessGroup());
 }
 
 QString Session::foregroundProcessName()
 {
     QString name;
 
     if (updateForegroundProcessInfo()) {
         bool ok = false;
         name = _foregroundProcessInfo->name(&ok);
         if (!ok) {
             name.clear();
         }
     }
 
     return name;
 }
 
 void Session::saveSession(KConfigGroup& group)
 {
     group.writePathEntry("WorkingDir", currentWorkingDirectory());
     group.writeEntry("LocalTab",       tabTitleFormat(LocalTabTitle));
     group.writeEntry("RemoteTab",      tabTitleFormat(RemoteTabTitle));
     group.writeEntry("SessionGuid",    _uniqueIdentifier.toString());
     group.writeEntry("Encoding",       QString::fromUtf8(codec()));
 }
 
 void Session::restoreSession(KConfigGroup& group)
 {
     QString value;
 
     value = group.readPathEntry("WorkingDir", QString());
     if (!value.isEmpty()) {
         setInitialWorkingDirectory(value);
     }
     value = group.readEntry("LocalTab");
     if (!value.isEmpty()) {
         setTabTitleFormat(LocalTabTitle, value);
     }
     value = group.readEntry("RemoteTab");
     if (!value.isEmpty()) {
         setTabTitleFormat(RemoteTabTitle, value);
     }
     value = group.readEntry("SessionGuid");
     if (!value.isEmpty()) {
         _uniqueIdentifier = QUuid(value);
     }
     value = group.readEntry("Encoding");
     if (!value.isEmpty()) {
         setCodec(value.toUtf8());
     }
 }
 
 QString Session::validDirectory(const QString& dir) const
 {
     QString validDir = dir;
     if (validDir.isEmpty()) {
         validDir = QDir::currentPath();
     }
 
     const QFileInfo fi(validDir);
     if (!fi.exists() || !fi.isDir()) {
         validDir = QDir::homePath();
     }
 
     return validDir;
 }
 
 bool Session::isReadOnly() const
 {
     return _readOnly;
 }
 
 void Session::setReadOnly(bool readOnly)
 {
     if (_readOnly != readOnly) {
         _readOnly = readOnly;
 
         // Needed to update the tab icons and all
         // attached views.
         emit readOnlyChanged();
     }
 }
 
 SessionGroup::SessionGroup(QObject* parent)
     : QObject(parent), _masterMode(0)
 {
 }
 SessionGroup::~SessionGroup() = default;
 
 int SessionGroup::masterMode() const
 {
     return _masterMode;
 }
 QList<Session*> SessionGroup::sessions() const
 {
     return _sessions.keys();
 }
 bool SessionGroup::masterStatus(Session* session) const
 {
     return _sessions[session];
 }
 
 void SessionGroup::addSession(Session* session)
 {
     connect(session, &Konsole::Session::finished, this, &Konsole::SessionGroup::sessionFinished);
     _sessions.insert(session, false);
 }
 void SessionGroup::removeSession(Session* session)
 {
     disconnect(session, &Konsole::Session::finished, this, &Konsole::SessionGroup::sessionFinished);
     setMasterStatus(session, false);
     _sessions.remove(session);
 }
 void SessionGroup::sessionFinished()
 {
     Session* session = qobject_cast<Session*>(sender());
     Q_ASSERT(session);
     removeSession(session);
 }
 void SessionGroup::setMasterMode(int mode)
 {
     _masterMode = mode;
 }
 QList<Session*> SessionGroup::masters() const
 {
     return _sessions.keys(true);
 }
 void SessionGroup::setMasterStatus(Session* session , bool master)
 {
     const bool wasMaster = _sessions[session];
 
     if (wasMaster == master) {
         // No status change -> nothing to do.
         return;
     }
     _sessions[session] = master;
 
     if (master) {
         connect(session->emulation(), &Konsole::Emulation::sendData, this, &Konsole::SessionGroup::forwardData);
     } else {
         disconnect(session->emulation(), &Konsole::Emulation::sendData,
                    this, &Konsole::SessionGroup::forwardData);
     }
 }
 void SessionGroup::forwardData(const QByteArray& data)
 {
     static bool _inForwardData = false;
     if (_inForwardData) {  // Avoid recursive calls among session groups!
         // A recursive call happens when a master in group A calls forwardData()
         // in group B. If one of the destination sessions in group B is also a
         // master of a group including the master session of group A, this would
         // again call forwardData() in group A, and so on.
         return;
     }
 
     _inForwardData = true;
     const QList<Session*> sessionsKeys = _sessions.keys();
     foreach(Session* other, sessionsKeys) {
         if (!_sessions[other]) {
             other->emulation()->sendString(data);
         }
     }
     _inForwardData = false;
 }
 
diff --git a/src/Session.h b/src/Session.h
index 07f97f3d..d825aebf 100644
--- a/src/Session.h
+++ b/src/Session.h
@@ -1,898 +1,898 @@
 /*
     This file is part of Konsole, an X terminal.
 
     Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
     Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
     Copyright 2009 by Thomas Dreibholz <dreibh@iem.uni-due.de>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 #ifndef SESSION_H
 #define SESSION_H
 
 // Qt
 #include <QStringList>
 #include <QHash>
 #include <QUuid>
 #include <QSize>
 #include <QProcess>
 #include <QWidget>
 #include <QUrl>
 
 // Konsole
 #include "konsoleprivate_export.h"
 #include "config-konsole.h" //krazy:exclude=includes
 #include "Shortcut_p.h"
 
 class QColor;
 
 class KConfigGroup;
 class KProcess;
 
 namespace Konsole {
 class Emulation;
 class Pty;
 class ProcessInfo;
 class TerminalDisplay;
 class ZModemDialog;
 class HistoryType;
 
 /**
  * Represents a terminal session consisting of a pseudo-teletype and a terminal emulation.
  * The pseudo-teletype (or PTY) handles I/O between the terminal process and Konsole.
  * The terminal emulation ( Emulation and subclasses ) processes the output stream from the
  * PTY and produces a character image which is then shown on views connected to the session.
  *
  * Each Session can be connected to one or more views by using the addView() method.
  * The attached views can then display output from the program running in the terminal
  * or send input to the program in the terminal in the form of keypresses and mouse
  * activity.
  */
 class KONSOLEPRIVATE_EXPORT Session : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.konsole.Session")
 
 public:
     Q_PROPERTY(QString name READ nameTitle)
     Q_PROPERTY(int processId READ processId)
     Q_PROPERTY(QString keyBindings READ keyBindings WRITE setKeyBindings)
     Q_PROPERTY(QSize size READ size WRITE setSize)
 
     /**
      * Constructs a new session.
      *
      * To start the terminal process, call the run() method,
      * after specifying the program and arguments
      * using setProgram() and setArguments()
      *
      * If no program or arguments are specified explicitly, the Session
      * falls back to using the program specified in the SHELL environment
      * variable.
      */
     explicit Session(QObject *parent = nullptr);
     ~Session() Q_DECL_OVERRIDE;
 
     /**
      * Connect to an existing terminal.  When a new Session() is constructed it
      * automatically searches for and opens a new teletype.  If you want to
      * use an existing teletype (given its file descriptor) call this after
      * constructing the session.
      *
      * Calling openTeletype() while a session is running has no effect.
      *
      * @param fd The file descriptor of the pseudo-teletype master (See KPtyProcess::KPtyProcess())
      */
     void openTeletype(int fd);
 
     /**
      * Returns true if the session is currently running.  This will be true
      * after run() has been called successfully.
      */
     bool isRunning() const;
 
     /**
      * Adds a new view for this session.
      *
      * The viewing widget will display the output from the terminal and
      * input from the viewing widget (key presses, mouse activity etc.)
      * will be sent to the terminal.
      *
      * Views can be removed using removeView().  The session is automatically
      * closed when the last view is removed.
      */
     void addView(TerminalDisplay *widget);
     /**
      * Removes a view from this session.  When the last view is removed,
      * the session will be closed automatically.
      *
      * @p widget will no longer display output from or send input
      * to the terminal
      */
     void removeView(TerminalDisplay *widget);
 
     /**
      * Returns the views connected to this session
      */
     QList<TerminalDisplay *> views() const;
 
     /**
      * Returns the terminal emulation instance being used to encode / decode
      * characters to / from the process.
      */
     Emulation *emulation() const;
 
     /** Returns the unique ID for this session. */
     int sessionId() const;
 
     /**
      * This enum describes the contexts for which separate
      * tab title formats may be specified.
      */
     enum TabTitleContext {
         /** Default tab title format */
         LocalTabTitle,
         /**
          * Tab title format used session currently contains
          * a connection to a remote computer (via SSH)
          */
         RemoteTabTitle
     };
 
     /**
      * Returns true if the session currently contains a connection to a
      * remote computer.  It currently supports ssh.
      */
     bool isRemote();
 
     /**
      * Sets the format used by this session for tab titles.
      *
      * @param context The context whose format should be set.
      * @param format The tab title format.  This may be a mixture
      * of plain text and dynamic elements denoted by a '%' character
      * followed by a letter.  (eg. %d for directory).  The dynamic
      * elements available depend on the @p context
      */
     void setTabTitleFormat(TabTitleContext context, const QString &format);
     /** Returns the format used by this session for tab titles. */
     QString tabTitleFormat(TabTitleContext context) const;
 
     /**
      * Returns true if the tab title has been changed by the user via the
      * rename-tab dialog.
      */
     bool isTabTitleSetByUser() const;
 
     /** Returns the arguments passed to the shell process when run() is called. */
     QStringList arguments() const;
     /** Returns the program name of the shell process started when run() is called. */
     QString program() const;
 
     /**
      * Sets the command line arguments which the session's program will be passed when
      * run() is called.
      */
     void setArguments(const QStringList &arguments);
     /** Sets the program to be executed when run() is called. */
     void setProgram(const QString &program);
 
     /** Returns the session's current working directory. */
     QString initialWorkingDirectory()
     {
         return _initialWorkingDir;
     }
 
     /**
      * Sets the initial working directory for the session when it is run
      * This has no effect once the session has been started.
      */
     void setInitialWorkingDirectory(const QString &dir);
 
     /**
      * Returns the current directory of the foreground process in the session
      */
     QString currentWorkingDirectory();
 
     /**
      * Sets the type of history store used by this session.
      * Lines of output produced by the terminal are added
      * to the history store.  The type of history store
      * used affects the number of lines which can be
      * remembered before they are lost and the storage
      * (in memory, on-disk etc.) used.
      */
     void setHistoryType(const HistoryType &hType);
     /**
      * Returns the type of history store used by this session.
      */
     const HistoryType &historyType() const;
     /**
      * Clears the history store used by this session.
      */
     void clearHistory();
 
     /**
      * Sets the key bindings used by this session.  The bindings
      * specify how input key sequences are translated into
      * the character stream which is sent to the terminal.
      *
      * @param name The name of the key bindings to use.  The
      * names of available key bindings can be determined using the
      * KeyboardTranslatorManager class.
      */
     void setKeyBindings(const QString &name);
     /** Returns the name of the key bindings used by this session. */
     QString keyBindings() const;
 
     /**
      * This enum describes the available title roles.
      */
     enum TitleRole {
         /** The name of the session. */
         NameRole,
         /** The title of the session which is displayed in tabs etc. */
         DisplayedTitleRole
     };
 
     /**
      * Return the session title set by the user (ie. the program running
      * in the terminal), or an empty string if the user has not set a custom title
      */
     QString userTitle() const;
 
     /** Convenience method used to read the name property.  Returns title(Session::NameRole). */
     QString nameTitle() const
     {
         return title(Session::NameRole);
     }
 
     /** Returns a title generated from tab format and process information. */
     QString getDynamicTitle();
 
     /** Sets the name of the icon associated with this session. */
     void setIconName(const QString &iconName);
     /** Returns the name of the icon associated with this session. */
     QString iconName() const;
 
     /** Return URL for the session. */
     QUrl getUrl();
 
     /** Sets the text of the icon associated with this session. */
     void setIconText(const QString &iconText);
     /** Returns the text of the icon associated with this session. */
     QString iconText() const;
 
     /** Sets the session's title for the specified @p role to @p title. */
     void setTitle(TitleRole role, const QString &newTitle);
 
     /** Returns the session's title for the specified @p role. */
     QString title(TitleRole role) const;
 
     /**
      * Specifies whether a utmp entry should be created for the pty used by this session.
      * If true, KPty::login() is called when the session is started.
      */
     void setAddToUtmp(bool);
 
     /**
      * Specifies whether to close the session automatically when the terminal
      * process terminates.
      */
     void setAutoClose(bool close);
 
     /** See setAutoClose() */
     bool autoClose() const;
 
     /** Returns true if the user has started a program in the session. */
     bool isForegroundProcessActive();
 
     /** Returns the name of the current foreground process. */
     QString foregroundProcessName();
 
     /** Returns the terminal session's window size in lines and columns. */
     QSize size();
     /**
      * Emits a request to resize the session to accommodate
      * the specified window size.
      *
      * @param size The size in lines and columns to request.
      */
     void setSize(const QSize &size);
 
     QSize preferredSize() const;
 
     void setPreferredSize(const QSize &size);
 
     /**
      * Sets whether the session has a dark background or not.  The session
      * uses this information to set the COLORFGBG variable in the process's
      * environment, which allows the programs running in the terminal to determine
      * whether the background is light or dark and use appropriate colors by default.
      *
      * This has no effect once the session is running.
      */
     void setDarkBackground(bool darkBackground);
 
     /**
      * Attempts to get the shell program to redraw the current display area.
      * This can be used after clearing the screen, for example, to get the
      * shell to redraw the prompt line.
      */
     void refresh();
 
     void startZModem(const QString &zmodem, const QString &dir, const QStringList &list);
     void cancelZModem();
     bool isZModemBusy()
     {
         return _zmodemBusy;
     }
     void setZModemBusy(bool busy)
     {
         _zmodemBusy = busy;
     }
 
     /**
       * Possible values of the @p what parameter for setSessionAttribute().
       * See the "Operating System Commands" section at:
       * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Operating-System-Commands
       */
     enum SessionAttributes {
         IconNameAndWindowTitle = 0,
         IconName = 1,
         WindowTitle = 2,
         CurrentDirectory = 7,         // From VTE (supposedly 6 was for dir, 7 for file, but whatever)
         TextColor = 10,
         BackgroundColor = 11,
         SessionName = 30,             // Non-standard
         SessionIcon = 32,             // Non-standard
         ProfileChange = 50            // this clashes with Xterm's font change command
     };
 
     // Sets the text codec used by this sessions terminal emulation.
     void setCodec(QTextCodec *codec);
 
     // session management
     void saveSession(KConfigGroup &group);
     void restoreSession(KConfigGroup &group);
 
     void sendSignal(int signal);
 
     void reportBackgroundColor(const QColor &c);
 
     bool isReadOnly() const;
     void setReadOnly(bool readOnly);
 
     // Returns true if the current screen is the secondary/alternate one
     // or false if it's the primary/normal buffer
     bool isPrimaryScreen();
     void tabTitleSetByUser(bool set);
 
 public Q_SLOTS:
 
     /**
      * Starts the terminal session.
      *
      * This creates the terminal process and connects the teletype to it.
      */
     void run();
 
     /**
      * Returns the environment of this session as a list of strings like
      * VARIABLE=VALUE
      */
     Q_SCRIPTABLE QStringList environment() const;
 
     /**
      * Sets the environment for this session.
      * @p environment should be a list of strings like
      * VARIABLE=VALUE
      */
     Q_SCRIPTABLE void setEnvironment(const QStringList &environment);
 
     /**
      * Adds one entry for the environment of this session
      * @p entry should be like VARIABLE=VALUE
      */
     void addEnvironmentEntry(const QString &entry);
 
     /**
      * Closes the terminal session. It kills the terminal process by calling
      * closeInNormalWay() and, optionally, closeInForceWay().
      */
     //Q_SCRIPTABLE void close(); // This cause the menu issues bko 185466
     void close();
 
     /**
      * Kill the terminal process in normal way. This sends a hangup signal
      * (SIGHUP) to the terminal process and causes the finished() signal to
      * be emitted. If the process does not respond to the SIGHUP signal then
      * the terminal connection (the pty) is closed and Konsole waits for the
      * process to exit. This method works most of the time, but fails with some
      * programs which respond to SIGHUP signal in special way, such as autossh
      * and irssi.
      */
     bool closeInNormalWay();
 
     /**
      * kill terminal process in force way. This send a SIGKILL signal to the
      * terminal process. It should be called only after closeInNormalWay() has
      * failed. Take it as last resort.
      */
     bool closeInForceWay();
 
     /**
      * Changes one of certain session attributes in the terminal emulation
      * display. For a list of what may be changed see the
      * Emulation::sessionAttributeChanged() signal.
      *
      * @param what The session attribute being changed, it is one of the
      * SessionAttributes enum
      * @param caption The text part of the terminal command
      */
     void setSessionAttribute(int what, const QString &caption);
 
     /**
      * Enables monitoring for activity in the session.
      * This will cause notifySessionState() to be emitted
      * with the NOTIFYACTIVITY state flag when output is
      * received from the terminal.
      */
     Q_SCRIPTABLE void setMonitorActivity(bool);
 
     /** Returns true if monitoring for activity is enabled. */
     Q_SCRIPTABLE bool isMonitorActivity() const;
 
     /**
      * Enables monitoring for silence in the session.
      * This will cause notifySessionState() to be emitted
      * with the NOTIFYSILENCE state flag when output is not
      * received from the terminal for a certain period of
      * time, specified with setMonitorSilenceSeconds()
      */
     Q_SCRIPTABLE void setMonitorSilence(bool);
 
     /**
      * Returns true if monitoring for inactivity (silence)
      * in the session is enabled.
      */
     Q_SCRIPTABLE bool isMonitorSilence() const;
 
     /** See setMonitorSilence() */
     Q_SCRIPTABLE void setMonitorSilenceSeconds(int seconds);
 
     /**
      * Sets whether flow control is enabled for this terminal
      * session.
      */
     Q_SCRIPTABLE void setFlowControlEnabled(bool enabled);
 
     /** Returns whether flow control is enabled for this terminal session. */
     Q_SCRIPTABLE bool flowControlEnabled() const;
 
     /**
      * @param text to send to the current foreground terminal program.
      * @param eol send this after @p text
      */
     void sendTextToTerminal(const QString &text, const QChar &eol = QChar()) const;
 
 #if defined(REMOVE_SENDTEXT_RUNCOMMAND_DBUS_METHODS)
     void sendText(const QString &text) const;
 #else
     Q_SCRIPTABLE void sendText(const QString &text) const;
 #endif
 
     /**
      * Sends @p command to the current foreground terminal program.
      */
 #if defined(REMOVE_SENDTEXT_RUNCOMMAND_DBUS_METHODS)
     void runCommand(const QString &command) const;
 #else
     Q_SCRIPTABLE void runCommand(const QString &command) const;
 #endif
 
     /**
      * Sends a mouse event of type @p eventType emitted by button
      * @p buttons on @p column/@p line to the current foreground
      * terminal program
      */
     Q_SCRIPTABLE void sendMouseEvent(int buttons, int column, int line, int eventType);
 
     /**
     * Returns the process id of the terminal process.
     * This is the id used by the system API to refer to the process.
     */
     Q_SCRIPTABLE int processId() const;
 
     /**
      * Returns the process id of the terminal's foreground process.
      * This is initially the same as processId() but can change
      * as the user starts other programs inside the terminal.
      */
     Q_SCRIPTABLE int foregroundProcessId();
 
     /** Sets the text codec used by this sessions terminal emulation.
       * Overloaded to accept a QByteArray for convenience since DBus
       * does not accept QTextCodec directly.
       */
     Q_SCRIPTABLE bool setCodec(const QByteArray &name);
 
     /** Returns the codec used to decode incoming characters in this
      * terminal emulation
      */
     Q_SCRIPTABLE QByteArray codec();
 
     /** Sets the session's title for the specified @p role to @p title.
      *  This is an overloaded member function for setTitle(TitleRole, QString)
      *  provided for convenience since enum data types may not be
      *  exported directly through DBus
      */
     Q_SCRIPTABLE void setTitle(int role, const QString &title);
 
     /** Returns the session's title for the specified @p role.
      * This is an overloaded member function for  setTitle(TitleRole)
      * provided for convenience since enum data types may not be
      * exported directly through DBus
      */
     Q_SCRIPTABLE QString title(int role) const;
 
     /** Returns the "friendly" version of the QUuid of this session.
     * This is a QUuid with the braces and dashes removed, so it cannot be
     * used to construct a new QUuid. The same text appears in the
     * SHELL_SESSION_ID environment variable.
     */
     Q_SCRIPTABLE QString shellSessionId() const;
 
     /** Sets the session's tab title format for the specified @p context to @p format.
      *  This is an overloaded member function for setTabTitleFormat(TabTitleContext, QString)
      *  provided for convenience since enum data types may not be
      *  exported directly through DBus
      */
     Q_SCRIPTABLE void setTabTitleFormat(int context, const QString &format);
 
     /** Returns the session's tab title format for the specified @p context.
      * This is an overloaded member function for tabTitleFormat(TitleRole)
      * provided for convenience since enum data types may not be
      * exported directly through DBus
      */
     Q_SCRIPTABLE QString tabTitleFormat(int context) const;
 
     /**
      * Sets the history capacity of this session.
      *
      * @param lines The history capacity in unit of lines. Its value can be:
      * <ul>
      * <li> positive integer  -  fixed size history</li>
      * <li> 0 -  no history</li>
      * <li> negative integer -  unlimited history</li>
      * </ul>
      */
     Q_SCRIPTABLE void setHistorySize(int lines);
 
     /**
      * Returns the history capacity of this session.
      */
     Q_SCRIPTABLE int historySize() const;
 
     /**
      * Sets the current session's profile
      */
     Q_SCRIPTABLE void setProfile(const QString &profile);
 
 Q_SIGNALS:
 
     /** Emitted when the terminal process starts. */
     void started();
 
     /**
      * Emitted when the terminal process exits.
      */
     void finished();
 
     /**
      * Emitted when one of certain session attributes has been changed.
      * See setSessionAttribute().
      */
     void sessionAttributeChanged();
 
     /** Emitted when the session gets locked / unlocked. */
     void readOnlyChanged();
 
     /**
      * Emitted when the activity state of this session changes.
      *
      * @param state The new state of the session.  This may be one
      * of NOTIFYNORMAL, NOTIFYSILENCE or NOTIFYACTIVITY
      */
     void stateChanged(int state);
 
     /**
      * Emitted when the current working directory of this session changes.
      *
      * @param dir The new current working directory of the session.
      */
     void currentDirectoryChanged(const QString &dir);
 
     /** Emitted when a bell event occurs in the session. */
-    void bellRequest(const QString &message);
+    void bellRequest(const QString &message) const;
 
     /**
      * Requests that the color the text for any tabs associated with
      * this session should be changed;
      *
      * TODO: Document what the parameter does
      */
     void changeTabTextColorRequest(int);
 
     /**
      * Requests that the background color of views on this session
      * should be changed.
      */
     void changeBackgroundColorRequest(const QColor &);
     /**
      * Requests that the text color of views on this session should
      * be changed to @p color.
      */
     void changeForegroundColorRequest(const QColor &);
 
     /** TODO: Document me. */
     void openUrlRequest(const QString &url);
 
     /**
      * Emitted when the request for data transmission through ZModem
      * protocol is detected.
      */
     void zmodemDownloadDetected();
     void zmodemUploadDetected();
 
     /**
      * Emitted when the terminal process requests a change
      * in the size of the terminal window.
      *
      * @param size The requested window size in terms of lines and columns.
      */
     void resizeRequest(const QSize &size);
 
     /**
      * Emitted when a profile change command is received from the terminal.
      *
      * @param text The text of the command.  This is a string of the form
      * "PropertyName=Value;PropertyName=Value ..."
      */
     void profileChangeCommandReceived(const QString &text);
 
     /**
      * Emitted when the flow control state changes.
      *
      * @param enabled True if flow control is enabled or false otherwise.
      */
     void flowControlEnabledChanged(bool enabled);
 
     /**
      * Emitted when the active screen is switched, to indicate whether the primary
      * screen is in use.
      *
      * This signal serves as a relayer of Emulation::priamyScreenInUse(bool),
      * making it usable for higher level component.
      */
     void primaryScreenInUse(bool use);
 
     /**
      * Emitted when the text selection is changed.
      *
      * This signal serves as a relayer of Emulation::selectedText(QString),
      * making it usable for higher level component.
      */
     void selectionChanged(const QString &text);
 
     /**
      * Emitted when background request ("\033]11;?\a") terminal code received.
      * Terminal is expected send "\033]11;rgb:RRRR/GGGG/BBBB\a" response.
      *
      * Originally implemented to support vim's background detection feature
      * (without explictly setting 'bg=dark' within local/remote vimrc)
      */
     void getBackgroundColor();
 
 private Q_SLOTS:
     void done(int, QProcess::ExitStatus);
 
     void fireZModemDownloadDetected();
     void fireZModemUploadDetected();
 
     void onReceiveBlock(const char *buf, int len);
     void silenceTimerDone();
     void activityTimerDone();
 
     void onViewSizeChange(int height, int width);
 
     void activityStateSet(int);
 
     //automatically detach views from sessions when view is destroyed
     void viewDestroyed(QObject *view);
 
     void zmodemReadStatus();
     void zmodemReadAndSendBlock();
     void zmodemReceiveBlock(const char *data, int len);
     void zmodemFinished();
 
     void updateFlowControlState(bool suspended);
     void updateWindowSize(int lines, int columns);
 
     // Relays the signal from Emulation and sets _isPrimaryScreen
     void onPrimaryScreenInUse(bool use);
 
     void sessionAttributeRequest(int id);
 
 private:
     Q_DISABLE_COPY(Session)
 
     // checks that the binary 'program' is available and can be executed
     // returns the binary name if available or an empty string otherwise
     static QString checkProgram(const QString &program);
 
     void updateTerminalSize();
     WId windowId() const;
     bool kill(int signal);
     // print a warning message in the terminal.  This is used
     // if the program fails to start, or if the shell exits in
     // an unsuccessful manner
     void terminalWarning(const QString &message);
     ProcessInfo *getProcessInfo();
     void updateSessionProcessInfo();
     bool updateForegroundProcessInfo();
     void updateWorkingDirectory();
 
     QString validDirectory(const QString &dir) const;
 
     QUuid _uniqueIdentifier;            // SHELL_SESSION_ID
 
     Pty *_shellProcess;
     Emulation *_emulation;
 
     QList<TerminalDisplay *> _views;
 
     // monitor activity & silence
     bool _monitorActivity;
     bool _monitorSilence;
     bool _notifiedActivity;
     int _silenceSeconds;
     QTimer *_silenceTimer;
     QTimer *_activityTimer;
 
     bool _autoClose;
     bool _closePerUserRequest;
 
     QString _nameTitle;
     QString _displayTitle;
     QString _userTitle;
 
     QString _localTabTitleFormat;
     QString _remoteTabTitleFormat;
 
     bool _tabTitleSetByUser;
 
     QString _iconName;
     QString _iconText;        // not actually used
     bool _addToUtmp;
     bool _flowControlEnabled;
 
     QString _program;
     QStringList _arguments;
 
     QStringList _environment;
     int _sessionId;
 
     QString _initialWorkingDir;
     QString _currentWorkingDir;
     QUrl _reportedWorkingUrl;
 
     ProcessInfo *_sessionProcessInfo;
     ProcessInfo *_foregroundProcessInfo;
     int _foregroundPid;
 
     // ZModem
     bool _zmodemBusy;
     KProcess *_zmodemProc;
     ZModemDialog *_zmodemProgress;
 
     bool _hasDarkBackground;
 
     QSize _preferredSize;
 
     bool _readOnly;
     static int lastSessionId;
 
     bool _isPrimaryScreen;
 };
 
 /**
  * Provides a group of sessions which is divided into master and slave sessions.
  * Activity in master sessions can be propagated to all sessions within the group.
  * The type of activity which is propagated and method of propagation is controlled
  * by the masterMode() flags.
  */
 class SessionGroup : public QObject
 {
     Q_OBJECT
 
 public:
     /** Constructs an empty session group. */
     explicit SessionGroup(QObject *parent);
     /** Destroys the session group and removes all connections between master and slave sessions. */
     ~SessionGroup() Q_DECL_OVERRIDE;
 
     /** Adds a session to the group. */
     void addSession(Session *session);
     /** Removes a session from the group. */
     void removeSession(Session *session);
 
     /** Returns the list of sessions currently in the group. */
     QList<Session *> sessions() const;
 
     /**
      * Sets whether a particular session is a master within the group.
      * Changes or activity in the group's master sessions may be propagated
      * to all the sessions in the group, depending on the current masterMode()
      *
      * @param session The session whose master status should be changed.
      * @param master True to make this session a master or false otherwise
      */
     void setMasterStatus(Session *session, bool master);
     /** Returns the master status of a session.  See setMasterStatus() */
     bool masterStatus(Session *session) const;
 
     /**
      * This enum describes the options for propagating certain activity or
      * changes in the group's master sessions to all sessions in the group.
      */
     enum MasterMode {
         /**
          * Any input key presses in the master sessions are sent to all
          * sessions in the group.
          */
         CopyInputToAll = 1
     };
 
     /**
      * Specifies which activity in the group's master sessions is propagated
      * to all sessions in the group.
      *
      * @param mode A bitwise OR of MasterMode flags.
      */
     void setMasterMode(int mode);
     /**
      * Returns a bitwise OR of the active MasterMode flags for this group.
      * See setMasterMode()
      */
     int masterMode() const;
 
 private Q_SLOTS:
     void sessionFinished();
     void forwardData(const QByteArray &data);
 
 private:
     QList<Session *> masters() const;
 
     // maps sessions to their master status
     QHash<Session *, bool> _sessions;
 
     int _masterMode;
 };
 }
 
 #endif
diff --git a/src/TerminalDisplay.cpp b/src/TerminalDisplay.cpp
index 19316d09..f036a52d 100644
--- a/src/TerminalDisplay.cpp
+++ b/src/TerminalDisplay.cpp
@@ -1,3999 +1,4006 @@
 /*
     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 <QFontDatabase>
 #include <QLabel>
 #include <QMimeData>
 #include <QPainter>
 #include <QPixmap>
 #include <QScrollBar>
 #include <QStyle>
 #include <QTimer>
 #include <QDrag>
 #include <QDesktopServices>
 #include <QAccessible>
 
 // KDE
 #include <KShell>
 #include <KColorScheme>
 #include <KCursor>
 #include <KLocalizedString>
-#include <KNotification>
 #include <KIO/DropJob>
 #include <KJobWidgets>
 #include <KMessageBox>
 #include <KMessageWidget>
 #include <KIO/StatJob>
 
+#ifndef WITHOUT_KNOTIFY
+#include <KNotification>
+#endif
+
 // Konsole
 #include "Filter.h"
 #include "konsoledebug.h"
 #include "TerminalCharacterDecoder.h"
 #include "Screen.h"
 #include "LineFont.h"
 #include "SessionController.h"
 #include "ExtendedCharTable.h"
 #include "TerminalDisplayAccessible.h"
 #include "SessionManager.h"
 #include "Session.h"
 #include "WindowSystemInfo.h"
 #include "IncrementalSearchBar.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: http://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::updateScrollBarPalette()
 {
     QColor backgroundColor = _colorTable[DEFAULT_BACK_COLOR];
     backgroundColor.setAlphaF(_opacity);
     QPalette p = palette();
     p.setColor(QPalette::Window, backgroundColor);
 
     //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
     QColor buttonColor;
     buttonColor.setHsvF(backgroundColor.hueF(), backgroundColor.saturationF(), backgroundColor.valueF() + (backgroundColor.valueF() < 0.5 ? 0.2 : -0.2));
     p.setColor(QPalette::Button, buttonColor);
 
     p.setColor(QPalette::WindowText, _colorTable[DEFAULT_FORE_COLOR]);
     p.setColor(QPalette::ButtonText, _colorTable[DEFAULT_FORE_COLOR]);
     _scrollBar->setPalette(p);
 
 }
 
 void TerminalDisplay::setBackgroundColor(const QColor& color)
 {
     _colorTable[DEFAULT_BACK_COLOR] = color;
 
     QPalette p = palette();
     p.setColor(backgroundRole(), color);
     setPalette(p);
 
     updateScrollBarPalette();
     update();
 }
 QColor TerminalDisplay::getBackgroundColor() const
 {
     QPalette p = palette();
     return p.color(backgroundRole());
 }
 void TerminalDisplay::setForegroundColor(const QColor& color)
 {
     _colorTable[DEFAULT_FORE_COLOR] = color;
 
     updateScrollBarPalette();
     update();
 }
 void TerminalDisplay::setColorTable(const ColorEntry table[])
 {
     for (int i = 0; i < TABLE_COLORS; i++) {
         _colorTable[i] = table[i];
     }
 
     setBackgroundColor(_colorTable[DEFAULT_BACK_COLOR]);
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                   Font                                    */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 static inline bool isLineCharString(const QString& string)
 {
     if (string.length() == 0) {
         return false;
     }
 
     return isSupportedLineChar(string.at(0).unicode());
 }
 
 void TerminalDisplay::fontChange(const QFont&)
 {
     QFontMetrics fm(font());
     _fontHeight = fm.height() + _lineSpacing;
 
     Q_ASSERT(_fontHeight > 0);
 
     // 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);
 
     // In case the provided font doesn't have some specific characters it should
     // fall back to a Monospace fonts.
     newFont.setStyleHint(QFont::TypeWriter);
 
     QFontMetrics fontMetrics(newFont);
 
     // This check seems extreme and semi-random
     // TODO: research if these checks are still needed to prevent
     // enormous fonts from being used; consider usage on big TV
     // screens.
     if ((fontMetrics.height() > height()) || (fontMetrics.maxWidth() > width())) {
         // return here will cause the "general" non-fixed width font
         // to be selected
         return;
     }
 
     // hint that text should be drawn without anti-aliasing.
     // depending on the user's font configuration, this may not be respected
     if (!_antialiasText) {
         newFont.setStyleStrategy(QFont::StyleStrategy(newFont.styleStrategy() | QFont::NoAntialias));
     }
 
     // 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);
 
     // Konsole cannot handle non-integer font metrics
     newFont.setStyleStrategy(QFont::StyleStrategy(newFont.styleStrategy() | QFont::ForceIntegerMetrics));
 
     // 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"));
         newFont.setStyleHint(QFont::TypeWriter);
         qCDebug(KonsoleDebug)<<"Font changed to "<<newFont.toString();
     }
 
     QFontInfo fontInfo(newFont);
 
 //    if (!fontInfo.fixedPitch()) {
 //        qWarning() << "Using a variable-width font - this might cause display problems";
 //    }
 
     // QFontInfo::fixedPitch() appears to not match QFont::fixedPitch()
     // related?  https://bugreports.qt.io/browse/QTBUG-34082
     if (!fontInfo.exactMatch()) {
         const QChar comma(QLatin1Char(','));
         QString nonMatching = fontInfo.family() % comma %
             QString::number(fontInfo.pointSizeF()) % comma %
             QString::number(fontInfo.pixelSize()) % comma %
             QString::number(static_cast<int>(fontInfo.styleHint())) % comma %
             QString::number(fontInfo.weight()) % comma %
             QString::number(static_cast<int>(fontInfo.style())) % comma %
             QString::number(static_cast<int>(fontInfo.underline())) % comma %
             QString::number(static_cast<int>(fontInfo.strikeOut())) % comma %
             QString::number(static_cast<int>(fontInfo.fixedPitch())) % comma %
             QString::number(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::setFont(const QFont &)
 {
     // ignore font change request if not coming from konsole itself
 }
 
 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;
     setVTFont(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 (TerminalDisplay *display = qobject_cast<TerminalDisplay*>(object)) {
         return new TerminalDisplayAccessible(display);
     }
     return nullptr;
 }
 
 #endif
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                         Constructor / Destructor                          */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 TerminalDisplay::TerminalDisplay(QWidget* parent)
     : QWidget(parent)
     , _screenWindow(nullptr)
     , _bellMasked(false)
     , _verticalLayout(new QVBoxLayout(this))
     , _fixedFont(true)
     , _fontHeight(1)
     , _fontWidth(1)
     , _fontAscent(1)
     , _boldIntense(true)
     , _lines(1)
     , _columns(1)
     , _usedLines(1)
     , _usedColumns(1)
     , _contentRect(QRect())
     , _image(nullptr)
     , _imageSize(0)
     , _lineProperties(QVector<LineProperty>())
     , _randomSeed(0)
     , _resizing(false)
     , _showTerminalSizeHint(true)
     , _bidiEnabled(false)
     , _usesMouseTracking(false)
     , _alternateScrolling(true)
     , _bracketedPasteMode(false)
     , _iPntSel(QPoint())
     , _pntSel(QPoint())
     , _tripleSelBegin(QPoint())
     , _actSel(0)
     , _wordSelectionMode(false)
     , _lineSelectionMode(false)
     , _preserveLineBreaks(true)
     , _columnSelectionMode(false)
     , _autoCopySelectedText(false)
     , _copyTextAsHTML(true)
     , _middleClickPasteMode(Enum::PasteFromX11Selection)
     , _scrollBar(nullptr)
     , _scrollbarLocation(Enum::ScrollBarRight)
     , _scrollFullPage(false)
     , _wordCharacters(QStringLiteral(":@-./_~"))
     , _bellMode(Enum::NotifyBell)
     , _allowBlinkingText(true)
     , _allowBlinkingCursor(false)
     , _textBlinking(false)
     , _cursorBlinking(false)
     , _hasTextBlinker(false)
     , _urlHintsModifiers(Qt::NoModifier)
     , _showUrlHint(false)
     , _reverseUrlHints(false)
     , _openLinksByDirectClick(false)
     , _ctrlRequiredForDrag(true)
     , _dropUrlsAsText(false)
     , _tripleClickMode(Enum::SelectWholeLine)
     , _possibleTripleClick(false)
     , _resizeWidget(nullptr)
     , _resizeTimer(nullptr)
     , _flowControlWarningEnabled(false)
     , _outputSuspendedMessageWidget(nullptr)
     , _lineSpacing(0)
     , _size(QSize())
     , _blendColor(qRgba(0, 0, 0, 0xff))
     , _wallpaper(nullptr)
     , _filterChain(new TerminalImageFilterChain())
     , _mouseOverHotspotArea(QRegion())
     , _filterUpdateRequired(true)
     , _cursorShape(Enum::BlockCursor)
     , _cursorColor(QColor())
     , _antialiasText(true)
     , _useFontLineCharacters(false)
     , _printerFriendly(false)
     , _sessionController(nullptr)
     , _trimLeadingSpaces(false)
     , _trimTrailingSpaces(false)
     , _mouseWheelZoom(false)
     , _margin(1)
     , _centerContents(false)
     , _readOnlyMessageWidget(nullptr)
     , _readOnly(false)
     , _opacity(1.0)
     , _scrollWheelState(ScrollState())
     , _searchBar(new IncrementalSearchBar(this))
 {
     // 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);
     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->addStretch();
     _verticalLayout->setSpacing(0);
 
     setLayout(_verticalLayout);
 
     // Take the scrollbar into account and add a margin to the layout. Without the timer the scrollbar width
     // is garbage.
     QTimer::singleShot(0, this, [this]() {
         const int scrollBarWidth = _scrollBar->isVisible() ? geometry().intersected(_scrollBar->geometry()).width() : 0;
         _verticalLayout->setContentsMargins(0, 0, scrollBarWidth, 0);
     });
 
     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;
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                             Display Operations                            */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 /**
  A table for emulating the simple (single width) unicode drawing chars.
  It represents the 250x - 257x glyphs. If it's zero, we can't use it.
  if it's not, it's encoded as follows: imagine a 5x5 grid where the points are numbered
  0 to 24 left to top, top to bottom. Each point is represented by the corresponding bit.
 
  Then, the pixels basically have the following interpretation:
  _|||_
  -...-
  -...-
  -...-
  _|||_
 
 where _ = none
       | = vertical line.
       - = horizontal line.
  */
 
 enum LineEncode {
     TopL  = (1 << 1),
     TopC  = (1 << 2),
     TopR  = (1 << 3),
 
     LeftT = (1 << 5),
     Int11 = (1 << 6),
     Int12 = (1 << 7),
     Int13 = (1 << 8),
     RightT = (1 << 9),
 
     LeftC = (1 << 10),
     Int21 = (1 << 11),
     Int22 = (1 << 12),
     Int23 = (1 << 13),
     RightC = (1 << 14),
 
     LeftB = (1 << 15),
     Int31 = (1 << 16),
     Int32 = (1 << 17),
     Int33 = (1 << 18),
     RightB = (1 << 19),
 
     BotL  = (1 << 21),
     BotC  = (1 << 22),
     BotR  = (1 << 23)
 };
 
 static void drawLineChar(QPainter& paint, int x, int y, int w, int h, uchar code)
 {
     //Calculate cell midpoints, end points.
     const int cx = x + w / 2;
     const int cy = y + h / 2;
     const int ex = x + w - 1;
     const int ey = y + h - 1;
 
     const quint32 toDraw = LineChars[code];
 
     //Top _lines:
     if ((toDraw & TopL) != 0u) {
         paint.drawLine(cx - 1, y, cx - 1, cy - 2);
     }
     if ((toDraw & TopC) != 0u) {
         paint.drawLine(cx, y, cx, cy - 2);
     }
     if ((toDraw & TopR) != 0u) {
         paint.drawLine(cx + 1, y, cx + 1, cy - 2);
     }
 
     //Bot _lines:
     if ((toDraw & BotL) != 0u) {
         paint.drawLine(cx - 1, cy + 2, cx - 1, ey);
     }
     if ((toDraw & BotC) != 0u) {
         paint.drawLine(cx, cy + 2, cx, ey);
     }
     if ((toDraw & BotR) != 0u) {
         paint.drawLine(cx + 1, cy + 2, cx + 1, ey);
     }
 
     //Left _lines:
     if ((toDraw & LeftT) != 0u) {
         paint.drawLine(x, cy - 1, cx - 2, cy - 1);
     }
     if ((toDraw & LeftC) != 0u) {
         paint.drawLine(x, cy, cx - 2, cy);
     }
     if ((toDraw & LeftB) != 0u) {
         paint.drawLine(x, cy + 1, cx - 2, cy + 1);
     }
 
     //Right _lines:
     if ((toDraw & RightT) != 0u) {
         paint.drawLine(cx + 2, cy - 1, ex, cy - 1);
     }
     if ((toDraw & RightC) != 0u) {
         paint.drawLine(cx + 2, cy, ex, cy);
     }
     if ((toDraw & RightB) != 0u) {
         paint.drawLine(cx + 2, cy + 1, ex, cy + 1);
     }
 
     //Intersection points.
     if ((toDraw & Int11) != 0u) {
         paint.drawPoint(cx - 1, cy - 1);
     }
     if ((toDraw & Int12) != 0u) {
         paint.drawPoint(cx, cy - 1);
     }
     if ((toDraw & Int13) != 0u) {
         paint.drawPoint(cx + 1, cy - 1);
     }
 
     if ((toDraw & Int21) != 0u) {
         paint.drawPoint(cx - 1, cy);
     }
     if ((toDraw & Int22) != 0u) {
         paint.drawPoint(cx, cy);
     }
     if ((toDraw & Int23) != 0u) {
         paint.drawPoint(cx + 1, cy);
     }
 
     if ((toDraw & Int31) != 0u) {
         paint.drawPoint(cx - 1, cy + 1);
     }
     if ((toDraw & Int32) != 0u) {
         paint.drawPoint(cx, cy + 1);
     }
     if ((toDraw & Int33) != 0u) {
         paint.drawPoint(cx + 1, cy + 1);
     }
 }
 
 static void drawOtherChar(QPainter& paint, int x, int y, int w, int h, uchar code)
 {
     //Calculate cell midpoints, end points.
     const int cx = x + w / 2;
     const int cy = y + h / 2;
     const int ex = x + w - 1;
     const int ey = y + h - 1;
 
     // Double dashes
     if (0x4C <= code && code <= 0x4F) {
         const int xHalfGap = qMax(w / 15, 1);
         const int yHalfGap = qMax(h / 15, 1);
         switch (code) {
         case 0x4D: // BOX DRAWINGS HEAVY DOUBLE DASH HORIZONTAL
             paint.drawLine(x, cy - 1, cx - xHalfGap - 1, cy - 1);
             paint.drawLine(x, cy + 1, cx - xHalfGap - 1, cy + 1);
             paint.drawLine(cx + xHalfGap, cy - 1, ex, cy - 1);
             paint.drawLine(cx + xHalfGap, cy + 1, ex, cy + 1);
             // No break!
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 8, 0))
             Q_FALLTHROUGH();
 #endif
         case 0x4C: // BOX DRAWINGS LIGHT DOUBLE DASH HORIZONTAL
             paint.drawLine(x, cy, cx - xHalfGap - 1, cy);
             paint.drawLine(cx + xHalfGap, cy, ex, cy);
             break;
         case 0x4F: // BOX DRAWINGS HEAVY DOUBLE DASH VERTICAL
             paint.drawLine(cx - 1, y, cx - 1, cy - yHalfGap - 1);
             paint.drawLine(cx + 1, y, cx + 1, cy - yHalfGap - 1);
             paint.drawLine(cx - 1, cy + yHalfGap, cx - 1, ey);
             paint.drawLine(cx + 1, cy + yHalfGap, cx + 1, ey);
             // No break!
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 8, 0))
             Q_FALLTHROUGH();
 #endif
         case 0x4E: // BOX DRAWINGS LIGHT DOUBLE DASH VERTICAL
             paint.drawLine(cx, y, cx, cy - yHalfGap - 1);
             paint.drawLine(cx, cy + yHalfGap, cx, ey);
             break;
         }
     }
 
     // Rounded corner characters
     else if (0x6D <= code && code <= 0x70) {
         const int r = w * 3 / 8;
         const int d = 2 * r;
         switch (code) {
         case 0x6D: // BOX DRAWINGS LIGHT ARC DOWN AND RIGHT
             paint.drawLine(cx, cy + r, cx, ey);
             paint.drawLine(cx + r, cy, ex, cy);
             paint.drawArc(cx, cy, d, d, 90 * 16, 90 * 16);
             break;
         case 0x6E: // BOX DRAWINGS LIGHT ARC DOWN AND LEFT
             paint.drawLine(cx, cy + r, cx, ey);
             paint.drawLine(x, cy, cx - r, cy);
             paint.drawArc(cx - d, cy, d, d, 0 * 16, 90 * 16);
             break;
         case 0x6F: // BOX DRAWINGS LIGHT ARC UP AND LEFT
             paint.drawLine(cx, y, cx, cy - r);
             paint.drawLine(x, cy, cx - r, cy);
             paint.drawArc(cx - d, cy - d, d, d, 270 * 16, 90 * 16);
             break;
         case 0x70: // BOX DRAWINGS LIGHT ARC UP AND RIGHT
             paint.drawLine(cx, y, cx, cy - r);
             paint.drawLine(cx + r, cy, ex, cy);
             paint.drawArc(cx, cy - d, d, d, 180 * 16, 90 * 16);
             break;
         }
     }
 
     // Diagonals
     else if (0x71 <= code && code <= 0x73) {
         switch (code) {
         case 0x71: // BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT
             paint.drawLine(ex, y, x, ey);
             break;
         case 0x72: // BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT
             paint.drawLine(x, y, ex, ey);
             break;
         case 0x73: // BOX DRAWINGS LIGHT DIAGONAL CROSS
             paint.drawLine(ex, y, x, ey);
             paint.drawLine(x, y, ex, ey);
             break;
         }
     }
 }
 
 void TerminalDisplay::drawLineCharString(QPainter& painter, int x, int y, const QString& str,
         const Character* attributes)
 {
     painter.save();
     painter.setRenderHint(QPainter::Antialiasing);
 
     const QPen& originalPen = painter.pen();
 
     if (((attributes->rendition & RE_BOLD) != 0) && _boldIntense) {
         QPen boldPen(originalPen);
         boldPen.setWidth(3);
         painter.setPen(boldPen);
     }
 
     for (int i = 0 ; i < str.length(); i++) {
         const uchar code = str[i].cell();
         if (LineChars[code] != 0u) {
             drawLineChar(painter, x + (_fontWidth * i), y, _fontWidth, _fontHeight, code);
         } else {
             drawOtherChar(painter, x + (_fontWidth * i), y, _fontWidth, _fontHeight, code);
         }
     }
 
     painter.restore();
 }
 
 void TerminalDisplay::setKeyboardCursorShape(Enum::CursorShapeEnum shape)
 {
     _cursorShape = shape;
 }
 Enum::CursorShapeEnum TerminalDisplay::keyboardCursorShape() const
 {
     return _cursorShape;
 }
 
 void TerminalDisplay::setCursorStyle(Enum::CursorShapeEnum shape, bool isBlinking)
 {
     setKeyboardCursorShape(shape);
 
     setBlinkingCursorEnabled(isBlinking);
 
     // when the cursor shape and blinking state are changed via the
     // Set Cursor Style (DECSCUSR) escape sequences in vim, and if the
     // cursor isn't set to blink, the cursor shape doesn't actually
     // change until the cursor is moved by the user; calling update()
     // makes the cursor shape get updated sooner.
     if (!isBlinking) {
         update();
     }
 }
 void TerminalDisplay::resetCursorStyle()
 {
     Q_ASSERT(_sessionController != nullptr);
     Q_ASSERT(!_sessionController->session().isNull());
 
     Profile::Ptr currentProfile = SessionManager::instance()->sessionProfile(_sessionController->session());
 
     if (currentProfile != nullptr) {
         Enum::CursorShapeEnum shape = static_cast<Enum::CursorShapeEnum>(currentProfile->property<int>(Profile::CursorShape));
 
         setKeyboardCursorShape(shape);
         setBlinkingCursorEnabled(currentProfile->blinkingCursorEnabled());
     }
 }
 
 void TerminalDisplay::setKeyboardCursorColor(const QColor& color)
 {
     _cursorColor = color;
 }
 QColor TerminalDisplay::keyboardCursorColor() const
 {
     return _cursorColor;
 }
 
 void TerminalDisplay::setOpacity(qreal opacity)
 {
     QColor color(_blendColor);
     color.setAlphaF(opacity);
     _opacity = opacity;
 
     // enable automatic background filling to prevent the display
     // flickering if there is no transparency
     /*if ( color.alpha() == 255 )
     {
         setAutoFillBackground(true);
     }
     else
     {
         setAutoFillBackground(false);
     }*/
 
     _blendColor = color.rgba();
     updateScrollBarPalette();
 }
 
 void TerminalDisplay::setWallpaper(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));
 
         painter.save();
         painter.setCompositionMode(QPainter::CompositionMode_Source);
         painter.fillRect(rect, color);
         painter.restore();
 #endif
     } else {
         painter.fillRect(rect, backgroundColor);
     }
 }
 
 void TerminalDisplay::drawCursor(QPainter& painter,
                                  const QRect& rect,
                                  const QColor& foregroundColor,
                                  const QColor& /*backgroundColor*/,
                                  bool& invertCharacterColor)
 {
     // don't draw cursor which is currently blinking
     if (_cursorBlinking) {
         return;
     }
 
     // shift rectangle top down one pixel to leave some space
     // between top and bottom
     QRect 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(penWidth / 2,
                                              penWidth / 2,
                                              - penWidth / 2 - penWidth % 2,
                                              - penWidth / 2 - penWidth % 2));
 
         // draw the cursor body only when the widget has focus
         if (hasFocus()) {
             painter.fillRect(cursorRect, cursorColor);
 
             if (!_cursorColor.isValid()) {
                 // invert the color used to draw the text to ensure that the character at
                 // the cursor position is readable
                 invertCharacterColor = true;
             }
         }
     } else if (_cursorShape == Enum::UnderlineCursor) {
         painter.drawLine(cursorRect.left(),
                          cursorRect.bottom(),
                          cursorRect.right(),
                          cursorRect.bottom());
 
     } else if (_cursorShape == Enum::IBeamCursor) {
         painter.drawLine(cursorRect.left(),
                          cursorRect.top(),
                          cursorRect.left(),
                          cursorRect.bottom());
     }
 }
 
 void TerminalDisplay::drawCharacters(QPainter& painter,
                                      const QRect& rect,
                                      const QString& text,
                                      const Character* style,
                                      bool invertCharacterColor)
 {
     // don't draw text which is currently blinking
     if (_textBlinking && ((style->rendition & RE_BLINK) != 0)) {
         return;
     }
 
     // don't draw concealed characters
     if ((style->rendition & RE_CONCEAL) != 0) {
         return;
     }
 
     // setup bold and underline
     bool useBold = (((style->rendition & RE_BOLD) != 0) && _boldIntense) || font().bold();
     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 font = painter.font();
     if (font.bold() != useBold
             || font.underline() != useUnderline
             || font.italic() != useItalic
             || font.strikeOut() != useStrikeOut
             || font.overline() != useOverline) {
         font.setBold(useBold);
         font.setUnderline(useUnderline);
         font.setItalic(useItalic);
         font.setStrikeOut(useStrikeOut);
         font.setOverline(useOverline);
         painter.setFont(font);
     }
 
     // setup pen
     const CharacterColor& textColor = (invertCharacterColor ? style->backgroundColor : style->foregroundColor);
     const QColor color = textColor.color(_colorTable);
     QPen pen = painter.pen();
     if (pen.color() != color) {
         pen.setColor(color);
         painter.setPen(color);
     }
 
     // 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);
 
         painter.setClipRect(rect);
         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.setClipping(false);
     }
 }
 
 void TerminalDisplay::drawTextFragment(QPainter& painter ,
                                        const QRect& rect,
                                        const QString& text,
                                        const Character* style)
 {
     painter.save();
 
     // 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 != palette().background().color()) {
         drawBackground(painter, rect, backgroundColor,
                        false /* do not use transparency */);
     }
 
     // draw cursor shape if the current character is the cursor
     // this may alter the foreground and background colors
     bool invertCharacterColor = false;
     if ((style->rendition & RE_CURSOR) != 0) {
         drawCursor(painter, rect, foregroundColor, backgroundColor, invertCharacterColor);
     }
 
     // draw text
     drawCharacters(painter, rect, text, style, invertCharacterColor);
 
     painter.restore();
 }
 
 void TerminalDisplay::drawPrinterFriendlyTextFragment(QPainter& painter,
         const QRect& rect,
         const QString& text,
         const Character* style)
 {
     painter.save();
 
     // Set the colors used to draw to black foreground and white
     // background for printer friendly output when printing
     Character print_style = *style;
     print_style.foregroundColor = CharacterColor(COLOR_SPACE_RGB, 0x00000000);
     print_style.backgroundColor = CharacterColor(COLOR_SPACE_RGB, 0xFFFFFFFF);
 
     // draw text
     drawCharacters(painter, rect, text, &print_style, false);
 
     painter.restore();
 }
 
 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);
 
     //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);
 
         //set region of display to scroll
         scrollRect.setTop(top);
     } 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);
 
         //set region of the display to scroll
         scrollRect.setTop(top + abs(lines) * _fontHeight);
     }
     scrollRect.setHeight(linesToMove * _fontHeight);
 
     Q_ASSERT(scrollRect.isValid() && !scrollRect.isEmpty());
 
     //scroll the display vertically to match internal _image
     scroll(0 , _fontHeight * (-lines) , scrollRect);
 }
 
 QRegion TerminalDisplay::hotSpotRegion() const
 {
     QRegion region;
     foreach(Filter::HotSpot * hotSpot , _filterChain->hotSpots()) {
         QRect r;
         if (hotSpot->startLine() == hotSpot->endLine()) {
             r.setLeft(hotSpot->startColumn());
             r.setTop(hotSpot->startLine());
             r.setRight(hotSpot->endColumn());
             r.setBottom(hotSpot->endLine());
             region |= imageToWidget(r);
         } else {
             r.setLeft(hotSpot->startColumn());
             r.setTop(hotSpot->startLine());
             r.setRight(_columns);
             r.setBottom(hotSpot->startLine());
             region |= imageToWidget(r);
             for (int line = hotSpot->startLine() + 1 ; line < hotSpot->endLine() ; line++) {
                 r.setLeft(0);
                 r.setTop(line);
                 r.setRight(_columns);
                 r.setBottom(line);
                 region |= imageToWidget(r);
             }
             r.setLeft(0);
             r.setTop(hotSpot->endLine());
             r.setRight(hotSpot->endColumn());
             r.setBottom(hotSpot->endLine());
             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());
         _screenWindow->resetScrollCount();
     }
 
     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 = newLine[x + 0].isLineChar();
                     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) ||
                                 ch.isLineChar() != 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;
 
     // 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().width(i18n("Size: XXX x XXX")));
             _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);
 
     foreach(const QRect & rect, (pe->region() & contentsRect()).rects()) {
         drawBackground(paint, rect, palette().background().color(),
                        true /* use opacity setting */);
         drawContents(paint, rect);
     }
     drawCurrentResultRect(paint);
     drawInputMethodPreeditString(paint, preeditRect());
     paintFilters(paint);
 }
 
 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, size().width(), size().height());
 
     _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 QPoint(0, 0);
     }
 }
 
 inline bool TerminalDisplay::isCursorOnDisplay() const
 {
     return cursorPosition().x() < _columns &&
            cursorPosition().y() < _lines;
 }
 
 FilterChain* TerminalDisplay::filterChain() const
 {
     return _filterChain;
 }
 
 void TerminalDisplay::paintFilters(QPainter& painter)
 {
     if (_filterUpdateRequired) {
         return;
     }
 
     // get color of character under mouse and use it to draw
     // lines for filters
     QPoint cursorPos = mapFromGlobal(QCursor::pos());
     int cursorLine;
     int cursorColumn;
 
     getCharacterPosition(cursorPos, cursorLine, cursorColumn, false);
     Character cursorCharacter = _image[loc(qMin(cursorColumn, _columns - 1), cursorLine)];
 
     painter.setPen(QPen(cursorCharacter.foregroundColor.color(colorTable())));
 
     // iterate over hotspots identified by the display's currently active filters
     // and draw appropriate visuals to indicate the presence of the hotspot
 
     QList<Filter::HotSpot*> spots = _filterChain->hotSpots();
     int urlNumber, urlNumInc;
     if (_reverseUrlHints) {
         urlNumber = spots.size() + 1;
         urlNumInc = -1;
     } else {
         urlNumber = 0;
         urlNumInc = 1;
     }
     foreach(Filter::HotSpot* spot, spots) {
         urlNumber += urlNumInc;
 
         QRegion region;
         if (spot->type() == Filter::HotSpot::Link) {
             QRect r;
             if (spot->startLine() == spot->endLine()) {
                 r.setCoords(spot->startColumn()*_fontWidth + _contentRect.left(),
                             spot->startLine()*_fontHeight + _contentRect.top(),
                             (spot->endColumn())*_fontWidth + _contentRect.left() - 1,
                             (spot->endLine() + 1)*_fontHeight + _contentRect.top() - 1);
                 region |= r;
             } else {
                 r.setCoords(spot->startColumn()*_fontWidth + _contentRect.left(),
                             spot->startLine()*_fontHeight + _contentRect.top(),
                             (_columns)*_fontWidth + _contentRect.left() - 1,
                             (spot->startLine() + 1)*_fontHeight + _contentRect.top() - 1);
                 region |= r;
                 for (int line = spot->startLine() + 1 ; line < spot->endLine() ; line++) {
                     r.setCoords(0 * _fontWidth + _contentRect.left(),
                                 line * _fontHeight + _contentRect.top(),
                                 (_columns)*_fontWidth + _contentRect.left() - 1,
                                 (line + 1)*_fontHeight + _contentRect.top() - 1);
                     region |= r;
                 }
                 r.setCoords(0 * _fontWidth + _contentRect.left(),
                             spot->endLine()*_fontHeight + _contentRect.top(),
                             (spot->endColumn())*_fontWidth + _contentRect.left() - 1,
                             (spot->endLine() + 1)*_fontHeight + _contentRect.top() - 1);
                 region |= r;
             }
 
             if (_showUrlHint && urlNumber < 10) {
                 // Position at the beginning of the URL
                 const QVector<QRect> regionRects = region.rects();
                 QRect hintRect(regionRects.first());
                 hintRect.setWidth(r.height());
                 painter.fillRect(hintRect, QColor(0, 0, 0, 128));
                 painter.setPen(Qt::white);
                 painter.drawRect(hintRect.adjusted(0, 0, -1, -1));
                 painter.drawText(hintRect, Qt::AlignCenter, QString::number(urlNumber));
             }
         }
 
         for (int line = spot->startLine() ; line <= spot->endLine() ; line++) {
             int startColumn = 0;
             int endColumn = _columns - 1; // TODO use number of _columns which are actually
             // occupied on this line rather than the width of the
             // display in _columns
 
             // Check image size so _image[] is valid (see makeImage)
             if (endColumn >= _columns || line >= _lines) {
                 break;
             }
 
             // ignore whitespace at the end of the lines
             while (_image[loc(endColumn, line)].isSpace() && endColumn > 0) {
                 endColumn--;
             }
 
             // increment here because the column which we want to set 'endColumn' to
             // is the first whitespace character at the end of the line
             endColumn++;
 
             if (line == spot->startLine()) {
                 startColumn = spot->startColumn();
             }
             if (line == spot->endLine()) {
                 endColumn = spot->endColumn();
             }
 
             // TODO: resolve this comment with the new margin/center code
             // subtract one pixel from
             // the right and bottom so that
             // we do not overdraw adjacent
             // hotspots
             //
             // subtracting one pixel from all sides also prevents an edge case where
             // moving the mouse outside a link could still leave it underlined
             // because the check below for the position of the cursor
             // finds it on the border of the target area
             QRect r;
             r.setCoords(startColumn * _fontWidth + _contentRect.left(),
                         line * _fontHeight + _contentRect.top(),
                         endColumn * _fontWidth + _contentRect.left() - 1,
                         (line + 1)*_fontHeight + _contentRect.top() - 1);
             // Underline link hotspots
             if (spot->type() == Filter::HotSpot::Link) {
                 QFontMetrics metrics(font());
 
                 // find the baseline (which is the invisible line that the characters in the font sit on,
                 // with some having tails dangling below)
                 const int baseline = r.bottom() - metrics.descent();
                 // find the position of the underline below that
                 const int underlinePos = baseline + metrics.underlinePos();
                 if (_showUrlHint || region.contains(mapFromGlobal(QCursor::pos()))) {
                     painter.drawLine(r.left() , underlinePos ,
                                      r.right() , underlinePos);
                 }
 
                 // Marker hotspots simply have a transparent rectangular shape
                 // drawn on top of them
             } else if (spot->type() == Filter::HotSpot::Marker) {
                 //TODO - Do not use a hardcoded color for this
                 const bool isCurrentResultLine = (_screenWindow->currentResultLine() == (spot->startLine() + _screenWindow->currentLine()));
                 QColor color = isCurrentResultLine ? QColor(255, 255, 0, 120) : QColor(255, 0, 0, 120);
                 painter.fillRect(r, color);
             }
         }
     }
 }
 
 inline static bool isRtl(const Character &chr) {
     uint c = 0;
     if ((chr.rendition & RE_EXTENDED_CHAR) == 0) {
         c = chr.character;
     } else {
         ushort extendedCharLength = 0;
         const uint* chars = ExtendedCharTable::instance.lookupExtendedChar(chr.character, extendedCharLength);
         if (chars != nullptr) {
             c = chars[0];
         }
     }
 
     switch(QChar::direction(c)) {
     case QChar::DirR:
     case QChar::DirAL:
     case QChar::DirRLE:
     case QChar::DirRLI:
     case QChar::DirRLO:
         return true;
     default:
         return false;
     }
 }
 
 void TerminalDisplay::drawContents(QPainter& paint, const QRect& rect)
 {
     const QPoint tL  = contentsRect().topLeft();
     const int    tLx = tL.x();
     const int    tLy = tL.y();
 
     const int lux = qMin(_usedColumns - 1, qMax(0, (rect.left()   - tLx - _contentRect.left()) / _fontWidth));
     const int luy = qMin(_usedLines - 1,  qMax(0, (rect.top()    - tLy - _contentRect.top()) / _fontHeight));
     const int rlx = qMin(_usedColumns - 1, qMax(0, (rect.right()  - tLx - _contentRect.left()) / _fontWidth));
     const int rly = qMin(_usedLines - 1,  qMax(0, (rect.bottom() - tLy - _contentRect.top()) / _fontHeight));
 
     const int numberOfColumns = _usedColumns;
     QVector<uint> univec;
     univec.reserve(numberOfColumns);
     for (int y = luy; y <= rly; y++) {
         int x = lux;
         if ((_image[loc(lux, y)].character == 0u) && (x != 0)) {
             x--; // Search for start of multi-column character
         }
         for (; x <= rlx; 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 = _image[loc(x, y)].isLineChar();
             const bool doubleWidth = (_image[qMin(loc(x, y) + 1, _imageSize - 1)].character == 0);
             const CharacterColor currentForeground = _image[loc(x, y)].foregroundColor;
             const CharacterColor currentBackground = _image[loc(x, y)].backgroundColor;
             const RenditionFlags currentRendition = _image[loc(x, y)].rendition;
             const bool rtl = isRtl(_image[loc(x, y)]);
 
             if(_image[loc(x, y)].character <= 0x7e || rtl) {
                 while (x + len <= rlx &&
                         _image[loc(x + len, y)].foregroundColor == currentForeground &&
                         _image[loc(x + len, y)].backgroundColor == currentBackground &&
                         (_image[loc(x + len, y)].rendition & ~RE_EXTENDED_CHAR) == (currentRendition & ~RE_EXTENDED_CHAR) &&
                         (_image[qMin(loc(x + len, y) + 1, _imageSize - 1)].character == 0) == doubleWidth &&
                         _image[loc(x + len, y)].isLineChar() == lineDraw &&
                         (_image[loc(x + len, y)].character <= 0x7e || rtl)) {
                     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++;
                 }
             }
             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.
             paint.setWorldMatrix(textScale, true);
 
             //calculate the area in which the text will be drawn
             QRect textArea = QRect(_contentRect.left() + tLx + _fontWidth * x , _contentRect.top() + tLy + _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
             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;
     }
 
     QRect r(0, _contentRect.top() + (_screenWindow->currentResultLine() - _screenWindow->currentLine()) * _fontHeight,
             contentsRect().width(), _fontHeight);
     painter.fillRect(r, 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;
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                          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
             blinkCursorEvent();
         }
         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;
 
     emit focusLost();
 }
 
 void TerminalDisplay::focusInEvent(QFocusEvent*)
 {
     if (_allowBlinkingCursor) {
         _blinkCursorTimer->start();
     }
 
     updateCursor();
 
     if (_allowBlinkingText && _hasTextBlinker) {
         _blinkTextTimer->start();
     }
 
     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.
     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)
 {
     const auto width = event->size().width() - _scrollBar->geometry().width();
     _searchBar->correctPosition(QSize(width, event->size().height()));
     if (contentsRect().isValid()) {
         updateImageSize();
     }
 }
 
 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()
 {
     _scrollBar->resize(_scrollBar->sizeHint().width(), contentsRect().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().topLeft());
         break;
     case Enum::ScrollBarRight:
         _contentRect.setRight(_contentRect.right() - _scrollBar->width());
         _scrollBar->move(contentsRect().topRight() - QPoint(_scrollBar->width() - 1, 0));
         break;
     }
 
     // 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;
     }
 
     if (position == Enum::ScrollBarHidden) {
         _scrollBar->hide();
     } else {
         _scrollBar->show();
     }
 
     _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()) {
             QStyle::RequestSoftwareInputPanel behavior = QStyle::RequestSoftwareInputPanel(
                         style()->styleHint(QStyle::SH_RequestSoftwareInputPanel));
             if (hasFocus() || behavior == QStyle::RSIP_OnMouseClick) {
                 QEvent event(QEvent::RequestSoftwareInputPanel);
                 QApplication::sendEvent(this, &event);
             }
         }
 
         _lineSelectionMode = false;
         _wordSelectionMode = false;
 
         // The user clicked inside selected text
         bool selected =  _screenWindow->isSelected(pos.x(), pos.y());
 
         // Drag only when the Control key is held
         if ((!_ctrlRequiredForDrag || ((ev->modifiers() & Qt::ControlModifier) != 0u)) && selected) {
             _dragInfo.state = diPending;
             _dragInfo.start = ev->pos();
         } else {
             // No reason to ever start a drag event
             _dragInfo.state = diNone;
 
             _preserveLineBreaks = !(((ev->modifiers() & Qt::ControlModifier) != 0u) && !(ev->modifiers() & Qt::AltModifier));
             _columnSelectionMode = ((ev->modifiers() & Qt::AltModifier) != 0u) && ((ev->modifiers() & Qt::ControlModifier) != 0u);
 
     // There are a couple of use cases when selecting text :
     // Normal buffer or Alternate buffer when not using Mouse Tracking:
     //  select text or extendSelection or columnSelection or columnSelection + extendSelection
     //
     // Alternate buffer when using Mouse Tracking and with Shift pressed:
     //  select text or columnSelection
             if (!_usesMouseTracking &&
                 ((ev->modifiers() == Qt::ShiftModifier) ||
                 (((ev->modifiers() & Qt::ShiftModifier) != 0u) && _columnSelectionMode))) {
                     extendSelection(ev->pos());
             } else if ((!_usesMouseTracking && !((ev->modifiers() & Qt::ShiftModifier))) ||
                        (_usesMouseTracking && ((ev->modifiers() & Qt::ShiftModifier) != 0u))) {
                 _screenWindow->clearSelection();
 
                 pos.ry() += _scrollBar->value();
                 _iPntSel = _pntSel = pos;
                 _actSel = 1; // left mouse button pressed but nothing selected yet.
             } else if (_usesMouseTracking && !_readOnly) {
                     emit mouseSignal(0, charColumn + 1, charLine + 1 + _scrollBar->value() - _scrollBar->maximum() , 0);
             }
 
             if ((_openLinksByDirectClick || ((ev->modifiers() & Qt::ControlModifier) != 0u))) {
                 Filter::HotSpot* spot = _filterChain->hotSpotAt(charLine, charColumn);
                 if ((spot != nullptr) && spot->type() == Filter::HotSpot::Link) {
                     QObject action;
                     action.setObjectName(QStringLiteral("open-action"));
                     spot->activate(&action);
                 }
             }
         }
     } else if (ev->button() == Qt::MidButton) {
         processMidButtonClick(ev);
     } else if (ev->button() == Qt::RightButton) {
         if (!_usesMouseTracking || ((ev->modifiers() & Qt::ShiftModifier) != 0u)) {
             emit configureRequest(ev->pos());
         } else {
             if(!_readOnly) {
                 emit mouseSignal(2, charColumn + 1, charLine + 1 + _scrollBar->value() - _scrollBar->maximum() , 0);
             }
         }
     }
 }
 
 QList<QAction*> TerminalDisplay::filterActions(const QPoint& position)
 {
     int charLine, charColumn;
     getCharacterPosition(position, charLine, charColumn, false);
 
     Filter::HotSpot* spot = _filterChain->hotSpotAt(charLine, charColumn);
 
     return spot != nullptr ? spot->actions() : QList<QAction*>();
 }
 
 void TerminalDisplay::mouseMoveEvent(QMouseEvent* ev)
 {
     int charLine = 0;
     int charColumn = 0;
     getCharacterPosition(ev->pos(), charLine, charColumn, !_usesMouseTracking);
 
     processFilters();
     // handle filters
     // change link hot-spot appearance on mouse-over
     Filter::HotSpot* spot = _filterChain->hotSpotAt(charLine, charColumn);
     if ((spot != nullptr) && spot->type() == Filter::HotSpot::Link) {
         QRegion previousHotspotArea = _mouseOverHotspotArea;
         _mouseOverHotspotArea = QRegion();
         QRect r;
         if (spot->startLine() == spot->endLine()) {
             r.setCoords(spot->startColumn()*_fontWidth + _contentRect.left(),
                         spot->startLine()*_fontHeight + _contentRect.top(),
                         (spot->endColumn())*_fontWidth + _contentRect.left() - 1,
                         (spot->endLine() + 1)*_fontHeight + _contentRect.top() - 1);
             _mouseOverHotspotArea |= r;
         } else {
             r.setCoords(spot->startColumn()*_fontWidth + _contentRect.left(),
                         spot->startLine()*_fontHeight + _contentRect.top(),
                         (_columns)*_fontWidth + _contentRect.left() - 1,
                         (spot->startLine() + 1)*_fontHeight + _contentRect.top() - 1);
             _mouseOverHotspotArea |= r;
             for (int line = spot->startLine() + 1 ; line < spot->endLine() ; line++) {
                 r.setCoords(0 * _fontWidth + _contentRect.left(),
                             line * _fontHeight + _contentRect.top(),
                             (_columns)*_fontWidth + _contentRect.left() - 1,
                             (line + 1)*_fontHeight + _contentRect.top() - 1);
                 _mouseOverHotspotArea |= r;
             }
             r.setCoords(0 * _fontWidth + _contentRect.left(),
                         spot->endLine()*_fontHeight + _contentRect.top(),
                         (spot->endColumn())*_fontWidth + _contentRect.left() - 1,
                         (spot->endLine() + 1)*_fontHeight + _contentRect.top() - 1);
             _mouseOverHotspotArea |= r;
         }
 
         if ((_openLinksByDirectClick || ((ev->modifiers() & Qt::ControlModifier) != 0u)) && (cursor().shape() != Qt::PointingHandCursor)) {
             setCursor(Qt::PointingHandCursor);
         }
 
         update(_mouseOverHotspotArea | previousHotspotArea);
     } else if (!_mouseOverHotspotArea.isEmpty()) {
         if ((_openLinksByDirectClick || ((ev->modifiers() & Qt::ControlModifier) != 0u)) || (cursor().shape() == Qt::PointingHandCursor)) {
             setCursor(_usesMouseTracking ? Qt::ArrowCursor : Qt::IBeamCursor);
         }
 
         update(_mouseOverHotspotArea);
         // set hotspot area to an invalid rectangle
         _mouseOverHotspotArea = QRegion();
     }
 
     // for auto-hiding the cursor, we need mouseTracking
     if (ev->buttons() == Qt::NoButton) {
         return;
     }
 
     // if the program running in the terminal is interested in Mouse Tracking
     // evnets then emit a mouse movement signal, unless the shift key is
     // being held down, which overrides this.
     if (_usesMouseTracking && !(ev->modifiers() & Qt::ShiftModifier)) {
         int button = 3;
         if ((ev->buttons() & Qt::LeftButton) != 0u) {
             button = 0;
         }
         if ((ev->buttons() & Qt::MidButton) != 0u) {
             button = 1;
         }
         if ((ev->buttons() & Qt::RightButton) != 0u) {
             button = 2;
         }
 
         emit mouseSignal(button,
                          charColumn + 1,
                          charLine + 1 + _scrollBar->value() - _scrollBar->maximum(),
                          1);
 
         return;
     }
 
     if (_dragInfo.state == diPending) {
         // we had a mouse down, but haven't confirmed a drag yet
         // if the mouse has moved sufficiently, we will confirm
 
         const int distance = QApplication::startDragDistance();
         if (ev->x() > _dragInfo.start.x() + distance || ev->x() < _dragInfo.start.x() - distance ||
                 ev->y() > _dragInfo.start.y() + distance || ev->y() < _dragInfo.start.y() - distance) {
             // we've left the drag square, we can start a real drag operation now
 
             _screenWindow->clearSelection();
             doDrag();
         }
         return;
     } else if (_dragInfo.state == diDragging) {
         // this isn't technically needed because mouseMoveEvent is suppressed during
         // Qt drag operations, replaced by dragMoveEvent
         return;
     }
 
     if (_actSel == 0) {
         return;
     }
 
 // don't extend selection while pasting
     if ((ev->buttons() & Qt::MidButton) != 0u) {
         return;
     }
 
     extendSelection(ev->pos());
 }
 
 void TerminalDisplay::leaveEvent(QEvent *)
 {
     // remove underline from an active link when cursor leaves the widget area
     if(!_mouseOverHotspotArea.isEmpty()) {
         update(_mouseOverHotspotArea);
         _mouseOverHotspotArea = QRegion();
     }
 }
 
 void TerminalDisplay::extendSelection(const QPoint& position)
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     //if ( !contentsRect().contains(ev->pos()) ) return;
     const QPoint tL  = contentsRect().topLeft();
     const int    tLx = tL.x();
     const int    tLy = tL.y();
     const int    scroll = _scrollBar->value();
 
     // we're in the process of moving the mouse with the left button pressed
     // the mouse cursor will kept caught within the bounds of the text in
     // this widget.
 
     int linesBeyondWidget = 0;
 
     QRect textBounds(tLx + _contentRect.left(),
                      tLy + _contentRect.top(),
                      _usedColumns * _fontWidth - 1,
                      _usedLines * _fontHeight - 1);
 
     QPoint pos = position;
 
     // Adjust position within text area bounds.
     const QPoint oldpos = pos;
 
     pos.setX(qBound(textBounds.left(), pos.x(), textBounds.right()));
     pos.setY(qBound(textBounds.top(), pos.y(), textBounds.bottom()));
 
     if (oldpos.y() > textBounds.bottom()) {
         linesBeyondWidget = (oldpos.y() - textBounds.bottom()) / _fontHeight;
         _scrollBar->setValue(_scrollBar->value() + linesBeyondWidget + 1); // scrollforward
     }
     if (oldpos.y() < textBounds.top()) {
         linesBeyondWidget = (textBounds.top() - oldpos.y()) / _fontHeight;
         _scrollBar->setValue(_scrollBar->value() - linesBeyondWidget - 1); // history
     }
 
     int charColumn = 0;
     int charLine = 0;
     getCharacterPosition(pos, charLine, charColumn, true);
 
     QPoint here = QPoint(charColumn, charLine);
     QPoint ohere;
     QPoint _iPntSelCorr = _iPntSel;
     _iPntSelCorr.ry() -= _scrollBar->value();
     QPoint _pntSelCorr = _pntSel;
     _pntSelCorr.ry() -= _scrollBar->value();
     bool swapping = false;
 
     if (_wordSelectionMode) {
         // Extend to word boundaries
         int i;
         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)
         QPoint left = left_not_right ? here : _iPntSelCorr;
         i = loc(qBound(0, left.x(), _columns - 1), qBound(0, left.y(), _lines - 1));
         if (i >= 0 && i < _imageSize) {
             selClass = charClass(_image[qMin(i, _imageSize - 1)]);
             while (((left.x() > 0) || (left.y() > 0 && ((_lineProperties[left.y() - 1] & LINE_WRAPPED) != 0)))
                     && charClass(_image[i - 1]) == selClass) {
                 i--;
                 if (left.x() > 0) {
                     left.rx()--;
                 } else {
                     left.rx() = _usedColumns - 1;
                     left.ry()--;
                 }
             }
         }
 
         // Find left (left_not_right ? from start : from here)
         QPoint right = left_not_right ? _iPntSelCorr : here;
         i = loc(qBound(0, right.x(), _columns - 1), qBound(0, right.y(), _lines - 1));
         if (i >= 0 && i < _imageSize) {
             selClass = charClass(_image[qMin(i, _imageSize - 1)]);
             while (((right.x() < _usedColumns - 1) || (right.y() < _usedLines - 1 && ((_lineProperties[right.y()] & LINE_WRAPPED) != 0)))
                     && charClass(_image[i + 1]) == selClass) {
                 i++;
                 if (right.x() < _usedColumns - 1) {
                     right.rx()++;
                 } else {
                     right.rx() = 0;
                     right.ry()++;
                 }
             }
         }
 
         // 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();
     QPoint bgnSel = pos;
     QPoint endSel = pos;
     int i = loc(bgnSel.x(), bgnSel.y());
     _iPntSel = bgnSel;
     _iPntSel.ry() += _scrollBar->value();
 
     _wordSelectionMode = true;
     _actSel = 2; // within selection
 
     // find word boundaries...
     const QChar selClass = charClass(_image[i]);
     {
         // find the start of the word
         int x = bgnSel.x();
         while (((x > 0) || (bgnSel.y() > 0 && ((_lineProperties[bgnSel.y() - 1] & LINE_WRAPPED) != 0)))
                 && charClass(_image[i - 1]) == selClass) {
             i--;
             if (x > 0) {
                 x--;
             } else {
                 x = _usedColumns - 1;
                 bgnSel.ry()--;
             }
         }
 
         bgnSel.setX(x);
         _screenWindow->setSelectionStart(bgnSel.x() , bgnSel.y() , false);
 
         // find the end of the word
         i = loc(endSel.x(), endSel.y());
         x = endSel.x();
         while (((x < _usedColumns - 1) || (endSel.y() < _usedLines - 1 && ((_lineProperties[endSel.y()] & LINE_WRAPPED) != 0)))
                 && charClass(_image[i + 1]) == selClass) {
             i++;
             if (x < _usedColumns - 1) {
                 x++;
             } else {
                 x = 0;
                 endSel.ry()++;
             }
         }
 
         endSel.setX(x);
 
         // In word selection mode don't select @ (64) if at end of word.
         if (((_image[i].rendition & RE_EXTENDED_CHAR) == 0) &&
                 (QChar(_image[i].character) == QLatin1Char('@')) &&
                 ((endSel.x() - bgnSel.x()) > 0)) {
             endSel.setX(x - 1);
         }
 
         _actSel = 2; // within selection
 
         _screenWindow->setSelectionEnd(endSel.x() , endSel.y());
 
         copyToX11Selection();
     }
 
     _possibleTripleClick = true;
 
     QTimer::singleShot(QApplication::doubleClickInterval(), [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 QPoint(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 QPoint(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 QPoint(_columns - 1, lineInHistory - topVisibleLine);
             }
         }
 
         line = 0;
         lineProperties = screen->getLineProperties(lineInHistory, qMin(lineInHistory + visibleScreenLines, maxY));
     }
     return QPoint(_columns - 1, lineInHistory - topVisibleLine);
 }
 
 QPoint TerminalDisplay::findWordStart(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;
 
     while (true) {
         for (;;j--, x--) {
             if (x > 0) {
                 if (charClass(image[j - 1]) == selClass) {
                     continue;
                 }
                 goto out;
             } else if (i > 0) {
                 if (((lineProperties[i - 1] & LINE_WRAPPED) != 0) &&
                     charClass(image[j - 1]) == selClass) {
                     x = _columns;
                     i--;
                     y--;
                     continue;
                 }
                 goto out;
             } else if (y > 0) {
                 break;
             } else {
                 goto out;
             }
         }
         int newRegStart = qMax(0, y - regSize);
         lineProperties = screen->getLineProperties(newRegStart, y - 1);
         i = y - newRegStart;
         if (tmp_image == nullptr) {
             tmp_image = new Character[imageSize];
             image = tmp_image;
         }
         screen->getImage(tmp_image, imageSize, newRegStart, y - 1);
         j = loc(x, i);
     }
 out:
     delete[] tmp_image;
 
     return QPoint(x, y - curLine);
 }
 
 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) {
                     continue;
                 }
                 goto out;
             } else if (i < lineCount - 1) {
                 if (((lineProperties[i] & LINE_WRAPPED) != 0) &&
                     charClass(image[j + 1]) == selClass) {
                     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 QPoint(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;
         }
     }
 
     if (!text.isEmpty()) {
         text.replace(QLatin1Char('\n'), QLatin1Char('\r'));
         if (bracketedPasteMode()) {
             text.remove(QLatin1String("\033"));
             text.prepend(QLatin1String("\033[200~"));
             text.append(QLatin1String("\033[201~"));
         }
         // perform paste by simulating keypress events
         QKeyEvent e(QEvent::KeyPress, 0, Qt::NoModifier, text);
         emit keyPressedSignal(&e);
     }
 }
 
 void TerminalDisplay::setAutoCopySelectedText(bool enabled)
 {
     _autoCopySelectedText = enabled;
 }
 
 void TerminalDisplay::setMiddleClickPasteMode(Enum::MiddleClickPasteModeEnum mode)
 {
     _middleClickPasteMode = mode;
 }
 
 void TerminalDisplay::setCopyTextAsHTML(bool enabled)
 {
     _copyTextAsHTML = enabled;
 }
 
 void TerminalDisplay::copyToX11Selection()
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
 
     const QString &text = _screenWindow->selectedText(currentDecodingOptions());
     if (text.isEmpty()) {
         return;
     }
 
     auto mimeData = new QMimeData;
     mimeData->setText(text);
 
     if (_copyTextAsHTML) {
         mimeData->setHtml(_screenWindow->selectedText(currentDecodingOptions() | Screen::ConvertToHtml));
     }
 
     if (QApplication::clipboard()->supportsSelection()) {
         QApplication::clipboard()->setMimeData(mimeData, QClipboard::Selection);
     }
 
     if (_autoCopySelectedText) {
         QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
     }
 }
 
 void TerminalDisplay::copyToClipboard()
 {
     if (_screenWindow.isNull()) {
         return;
     }
 
     const QString &text = _screenWindow->selectedText(currentDecodingOptions());
     if (text.isEmpty()) {
         return;
     }
 
     auto mimeData = new QMimeData;
     mimeData->setText(text);
 
     if (_copyTextAsHTML) {
         mimeData->setHtml(_screenWindow->selectedText(currentDecodingOptions() | Screen::ConvertToHtml));
     }
 
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
 }
 
 void TerminalDisplay::pasteFromClipboard(bool appendEnter)
 {
     QString text = QApplication::clipboard()->text(QClipboard::Clipboard);
     doPaste(text, appendEnter);
 }
 
 void TerminalDisplay::pasteFromX11Selection(bool appendEnter)
 {
     if (QApplication::clipboard()->supportsSelection()) {
         QString text = QApplication::clipboard()->text(QClipboard::Selection);
         doPaste(text, appendEnter);
     }
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Input Method                               */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TerminalDisplay::inputMethodEvent(QInputMethodEvent* event)
 {
     if (!event->commitString().isEmpty()) {
         QKeyEvent keyEvent(QEvent::KeyPress, 0, Qt::NoModifier, event->commitString());
         emit keyPressedSignal(&keyEvent);
     }
 
     if (!_readOnly && isCursorOnDisplay()) {
         _inputMethodData.preeditString = event->preeditString();
         update(preeditRect() | _inputMethodData.previousPreeditRect);
     }
     event->accept();
 }
 
 QVariant TerminalDisplay::inputMethodQuery(Qt::InputMethodQuery query) const
 {
     const QPoint cursorPos = cursorPosition();
     switch (query) {
     case Qt::ImMicroFocus:
         return imageToWidget(QRect(cursorPos.x(), cursorPos.y(), 1, 1));
     case Qt::ImFont:
         return font();
     case Qt::ImCursorPosition:
         // return the cursor position within the current line
         return cursorPos.x();
     case Qt::ImSurroundingText: {
         // return the text from the current line
         QString lineText;
         QTextStream stream(&lineText);
         PlainTextDecoder decoder;
         decoder.begin(&stream);
         if (isCursorOnDisplay()) {
             decoder.decodeLine(&_image[loc(0, cursorPos.y())], _usedColumns, LINE_DEFAULT);
         }
         decoder.end();
         return lineText;
     }
     case Qt::ImCurrentSelection:
         return QString();
     default:
         break;
     }
 
     return QVariant();
 }
 
 QRect TerminalDisplay::preeditRect() const
 {
     const int preeditLength = Character::stringWidth(_inputMethodData.preeditString);
 
     if (preeditLength == 0) {
         return QRect();
     }
     const QRect stringRect(_contentRect.left() + _fontWidth * cursorPosition().x(),
                            _contentRect.top() + _fontHeight * cursorPosition().y(),
                            _fontWidth * preeditLength,
                            _fontHeight);
 
     return stringRect.intersected(_contentRect);
 }
 
 void TerminalDisplay::drawInputMethodPreeditString(QPainter& painter , const QRect& rect)
 {
     if (_inputMethodData.preeditString.isEmpty() || !isCursorOnDisplay()) {
         return;
     }
 
     const QPoint cursorPos = cursorPosition();
 
     bool invertColors = false;
     const QColor background = _colorTable[DEFAULT_BACK_COLOR];
     const QColor foreground = _colorTable[DEFAULT_FORE_COLOR];
     const Character* style = &_image[loc(cursorPos.x(), cursorPos.y())];
 
     drawBackground(painter, rect, background, true);
     drawCursor(painter, rect, foreground, background, invertColors);
     drawCharacters(painter, rect, _inputMethodData.preeditString, style, invertColors);
 
     _inputMethodData.previousPreeditRect = rect;
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Keyboard                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TerminalDisplay::setFlowControlWarningEnabled(bool enable)
 {
     _flowControlWarningEnabled = enable;
 
     // if the dialog is currently visible and the flow control warning has
     // been disabled then hide the dialog
     if (!enable) {
         outputSuspended(false);
     }
 }
 
 void TerminalDisplay::outputSuspended(bool suspended)
 {
     //create the label when this function is first called
     if (_outputSuspendedMessageWidget == nullptr) {
         //This label includes a link to an English language website
         //describing the 'flow control' (Xon/Xoff) feature found in almost
         //all terminal emulators.
         //If there isn't a suitable article available in the target language the link
         //can simply be removed.
         _outputSuspendedMessageWidget = createMessageWidget(i18n("<qt>Output has been "
                                                     "<a href=\"http://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(0, 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)) {
         _searchBar->hide();
     }
 
     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:
         _scrollBar->setPalette(QApplication::palette());
         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();
+        QApplication::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.
+#ifndef WITHOUT_KNOTIFY
         KNotification::event(hasFocus() ? QStringLiteral("BellVisible") : QStringLiteral("BellInvisible"),
                              message, QPixmap(), this);
+#else
+        QApplication::alert(this);
+#endif
         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]() {
         _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;
 
     update();
 }
 
 /* --------------------------------------------------------------------- */
 /*                                                                       */
 /* 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();
     }
 }
 
 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()) {
         for (int i = 0 ; i < urls.count() ; i++) {
             KIO::StatJob* job = KIO::mostLocalUrl(urls[i], KIO::HideProgressInfo);
             bool ok = job->exec();
             if (!ok) {
                 continue;
             }
 
             QUrl url = job->mostLocalUrl();
             QString urlText;
 
             if (url.isLocalFile()) {
                 urlText = url.path();
             } else {
                 urlText = url.url();
             }
 
             // 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)
             urlText = KShell::quoteArg(urlText);
 
             dropText += urlText;
 
             // Each filename(including the last) should be followed by one space.
             dropText += QLatin1Char(' ');
         }
 
         // 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);
             pasteAction->setData(dropText);
             connect(pasteAction, &QAction::triggered, this, &TerminalDisplay::dropMenuPasteActionTriggered);
 
             QList<QAction*> additionalActions;
             additionalActions.append(pasteAction);
 
             if (urls.count() == 1) {
                 KIO::StatJob* job = KIO::mostLocalUrl(urls[0], KIO::HideProgressInfo);
                 bool ok = job->exec();
                 if (ok) {
                     const QUrl url = job->mostLocalUrl();
 
                     if (url.isLocalFile()) {
                         const QFileInfo fileInfo(url.path());
 
                         if (fileInfo.isDir()) {
                             QAction* cdAction = new QAction(i18n("Change &Directory To"), this);
                             dropText = QLatin1String(" cd ") + dropText + QLatin1Char('\n');
                             cdAction->setData(dropText);
                             connect(cdAction, &QAction::triggered, this, &TerminalDisplay::dropMenuCdActionTriggered);
                             additionalActions.append(cdAction);
                         }
                     }
                 }
             }
 
             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::dropMenuPasteActionTriggered()
 {
     if (sender() != nullptr) {
         const QAction* action = qobject_cast<const QAction*>(sender());
         if (action != nullptr) {
             emit sendStringToEmu(action->data().toString().toLocal8Bit());
         }
     }
 }
 
 void TerminalDisplay::dropMenuCdActionTriggered()
 {
     if (sender() != nullptr) {
         const QAction* action = qobject_cast<const QAction*>(sender());
         if (action != nullptr) {
             emit sendStringToEmu(action->data().toString().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;
 }
 
 SessionController* TerminalDisplay::sessionController()
 {
     return _sessionController;
 }
 
 IncrementalSearchBar *TerminalDisplay::searchBar() const
 {
     return _searchBar;
 }
 
 AutoScrollHandler::AutoScrollHandler(QWidget* parent)
     : QObject(parent)
     , _timerId(0)
 {
     parent->installEventFilter(this);
 }
 void AutoScrollHandler::timerEvent(QTimerEvent* event)
 {
     if (event->timerId() != _timerId) {
         return;
     }
 
     QMouseEvent mouseEvent(QEvent::MouseMove,
                            widget()->mapFromGlobal(QCursor::pos()),
                            Qt::NoButton,
                            Qt::LeftButton,
                            Qt::NoModifier);
 
     QApplication::sendEvent(widget(), &mouseEvent);
 }
 bool AutoScrollHandler::eventFilter(QObject* watched, QEvent* event)
 {
     Q_ASSERT(watched == parent());
     Q_UNUSED(watched);
 
     switch (event->type()) {
     case QEvent::MouseMove: {
         QMouseEvent* 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: {
         QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
         if ((_timerId != 0) && ((mouseEvent->buttons() & ~Qt::LeftButton) != 0u)) {
             killTimer(_timerId);
             _timerId = 0;
         }
         break;
     }
     default:
         break;
     };
 
     return false;
 }
 
diff --git a/src/config-konsole.h.cmake b/src/config-konsole.h.cmake
index 0d162285..70773748 100644
--- a/src/config-konsole.h.cmake
+++ b/src/config-konsole.h.cmake
@@ -1,12 +1,14 @@
 #define KONSOLE_VERSION "${KDE_APPLICATIONS_VERSION}"
 
 /* Defined if you want detaching enabled */
 #cmakedefine ENABLE_DETACHING 1
 
 /* Defined if on DragonFly BSD */
 #cmakedefine HAVE_OS_DRAGONFLYBSD 1
 
 #cmakedefine01 HAVE_X11
 
 /* If defined, remove public access to dbus sendInput/runCommand */
 #cmakedefine REMOVE_SENDTEXT_RUNCOMMAND_DBUS_METHODS
+
+#cmakedefine WITHOUT_KNOTIFY