diff --git a/src/Application.cpp b/src/Application.cpp
index 7d5da3f8..3d00ef06 100644
--- a/src/Application.cpp
+++ b/src/Application.cpp
@@ -1,608 +1,596 @@
 /*
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "Application.h"
 
 // Qt
 #include <QHashIterator>
 #include <QFileInfo>
 #include <QDir>
 #include <QCommandLineParser>
 #include <QStandardPaths>
 
 // KDE
 #include <KActionCollection>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 
 // Konsole
 #include "SessionManager.h"
 #include "ProfileManager.h"
 #include "MainWindow.h"
 #include "Session.h"
 #include "ShellCommand.h"
 #include "KonsoleSettings.h"
 #include "ViewManager.h"
 #include "SessionController.h"
 #include "WindowSystemInfo.h"
 
 using namespace Konsole;
 
 Application::Application(QSharedPointer<QCommandLineParser> parser,
                          const QStringList &customCommand) :
     _backgroundInstance(nullptr),
     m_parser(parser),
     m_customCommand(customCommand)
 {
 }
 
 void Application::populateCommandLineParser(QCommandLineParser *parser)
 {
     auto options = QVector<QCommandLineOption> {
         { { QStringLiteral("profile") },
             i18nc("@info:shell", "Name of profile to use for new Konsole instance"),
             QStringLiteral("name")
         },
         { { QStringLiteral("fallback-profile") },
             i18nc("@info:shell", "Use the internal FALLBACK profile")
         },
         { { QStringLiteral("workdir") },
             i18nc("@info:shell", "Set the initial working directory of the new tab or window to 'dir'"),
             QStringLiteral("dir")
         },
         { { QStringLiteral("hold"), QStringLiteral("noclose") },
            i18nc("@info:shell", "Do not close the initial session automatically when it ends.")
         },
         {  {QStringLiteral("new-tab") },
             i18nc("@info:shell", "Create a new tab in an existing window rather than creating a new window")
         },
         { { QStringLiteral("tabs-from-file") },
             i18nc("@info:shell","Create tabs as specified in given tabs configuration"" file"),
             QStringLiteral("file")
         },
         { { QStringLiteral("background-mode") },
             i18nc("@info:shell", "Start Konsole in the background and bring to the front when Ctrl+Shift+F12 (by default) is pressed")
         },
         { { QStringLiteral("separate"), QStringLiteral("nofork") },
             i18nc("@info:shell", "Run in a separate process")
         },
         { { QStringLiteral("show-menubar") },
             i18nc("@info:shell", "Show the menubar, overriding the default setting")
         },
         { { QStringLiteral("hide-menubar") },
             i18nc("@info:shell", "Hide the menubar, overriding the default setting")
         },
         { { QStringLiteral("show-tabbar") },
             i18nc("@info:shell", "Show the tabbar, overriding the default setting")
         },
         { { QStringLiteral("hide-tabbar") },
             i18nc("@info:shell", "Hide the tabbar, overriding the default setting")
         },
         { { QStringLiteral("fullscreen") },
             i18nc("@info:shell", "Start Konsole in fullscreen mode")
         },
         { { QStringLiteral("notransparency") },
             i18nc("@info:shell", "Disable transparent backgrounds, even if the system supports them.")
         },
         { { QStringLiteral("list-profiles") },
             i18nc("@info:shell", "List the available profiles")
         },
         { { QStringLiteral("list-profile-properties") },
             i18nc("@info:shell", "List all the profile properties names and their type (for use with -p)")
         },
         { { QStringLiteral("p") },
             i18nc("@info:shell", "Change the value of a profile property."),
             QStringLiteral("property=value")
         },
         { { QStringLiteral("e") },
             i18nc("@info:shell", "Command to execute. This option will catch all following arguments, so use it as the last option."),
             QStringLiteral("cmd")
         }
     };
     foreach(const auto& option, options) {
         parser->addOption(option);
     }
 
     parser->addPositionalArgument(QStringLiteral("[args]"),
                                   i18nc("@info:shell", "Arguments passed to command"));
 
     // Add a no-op compatibility option to make Konsole compatible with
     // Debian's policy on X terminal emulators.
     // -T is technically meant to set a title, that is not really meaningful
     // for Konsole as we have multiple user-facing options controlling
     // the title and overriding whatever is set elsewhere.
     // https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=532029
     // https://www.debian.org/doc/debian-policy/ch-customized-programs.html#s11.8.3
     auto titleOption = QCommandLineOption({ QStringLiteral("T") },
                                           QStringLiteral("Debian policy compatibility, not used"),
                                           QStringLiteral("value"));
     titleOption.setHidden(true);
     parser->addOption(titleOption);
 }
 
 QStringList Application::getCustomCommand(QStringList &args)
 {
     int i = args.indexOf(QStringLiteral("-e"));
     QStringList customCommand;
     if ((0 < i) && (i < (args.size() - 1))) {
         // -e was specified with at least one extra argument
         // if -e was specified without arguments, QCommandLineParser will deal
         // with that
         args.removeAt(i);
         while (args.size() > i) {
             customCommand << args.takeAt(i);
         }
     }
     return customCommand;
 }
 
 Application::~Application()
 {
     SessionManager::instance()->closeAllSessions();
     ProfileManager::instance()->saveSettings();
 }
 
 MainWindow *Application::newMainWindow()
 {
     WindowSystemInfo::HAVE_TRANSPARENCY = !m_parser->isSet(QStringLiteral("notransparency"));
 
     auto window = new MainWindow();
 
     connect(window, &Konsole::MainWindow::newWindowRequest, this,
             &Konsole::Application::createWindow);
     connect(window, &Konsole::MainWindow::viewDetached, this, &Konsole::Application::detachView);
 
     return window;
 }
 
 void Application::createWindow(Profile::Ptr profile, const QString &directory)
 {
     MainWindow *window = newMainWindow();
     window->createSession(profile, directory);
     finalizeNewMainWindow(window);
 }
 
 void Application::detachView(Session *session)
 {
     MainWindow *window = newMainWindow();
     window->viewManager()->createView(session);
 
     // When detaching a view, the size of the new window should equal the
     // size of the source window
     Session *newsession = window->viewManager()->activeViewController()->session();
     newsession->setSize(session->size());
     window->adjustSize();
     // Since user is dragging and dropping, move dnd window to where
     // the user has the cursor (correct multiple monitor setups).
     window->move(QCursor::pos());
     window->show();
 }
 
 int Application::newInstance()
 {
     // handle session management
 
     // returns from processWindowArgs(args, createdNewMainWindow)
     // if a new window was created
     bool createdNewMainWindow = false;
 
     // check for arguments to print help or other information to the
     // terminal, quit if such an argument was found
     if (processHelpArgs()) {
         return 0;
     }
 
     // create a new window or use an existing one
     MainWindow *window = processWindowArgs(createdNewMainWindow);
 
     if (m_parser->isSet(QStringLiteral("tabs-from-file"))) {
         // create new session(s) as described in file
         if (!processTabsFromFileArgs(window)) {
             return 0;
         }
     }
 
     // select profile to use
     Profile::Ptr baseProfile = processProfileSelectArgs();
 
     // process various command-line options which cause a property of the
     // selected profile to be changed
     Profile::Ptr newProfile = processProfileChangeArgs(baseProfile);
 
     // create new session
     Session *session = window->createSession(newProfile, QString());
 
     if (m_parser->isSet(QStringLiteral("noclose"))) {
         session->setAutoClose(false);
     }
 
     // if the background-mode argument is supplied, start the background
     // session ( or bring to the front if it already exists )
     if (m_parser->isSet(QStringLiteral("background-mode"))) {
         startBackgroundMode(window);
     } else {
         // Qt constrains top-level windows which have not been manually
         // resized (via QWidget::resize()) to a maximum of 2/3rds of the
         //  screen size.
         //
         // This means that the terminal display might not get the width/
         // height it asks for.  To work around this, the widget must be
         // manually resized to its sizeHint().
         //
         // This problem only affects the first time the application is run.
         // run. After that KMainWindow will have manually resized the
         // window to its saved size at this point (so the Qt::WA_Resized
         // attribute will be set)
 
         // If not restoring size from last time or only adding new tab,
         // resize window to chosen profile size (see Bug:345403)
         if (createdNewMainWindow) {
             finalizeNewMainWindow(window);
         } else {
             window->show();
         }
     }
 
     return 1;
 }
 
 /* Documentation for tab file:
  *
  * ;; is the token separator
  * # at the beginning of line results in line being ignored.
  * supported tokens: title, command, profile and workdir
  *
  * Note that the title is static and the tab will close when the
  * command is complete (do not use --noclose).  You can start new tabs.
  *
  * Example below will create 6 tabs as listed and a 7th default tab
 title: This is the title;; command: ssh localhost
 title: This is the title;; command: ssh localhost;; profile: Shell
 title: Top this!;; command: top
 title: mc this!;; command: mc;; workdir: /tmp
 #this line is comment
 command: ssh localhost
 profile: Shell
 */
 bool Application::processTabsFromFileArgs(MainWindow *window)
 {
     // Open tab configuration file
     const QString tabsFileName(m_parser->value(QStringLiteral("tabs-from-file")));
     QFile tabsFile(tabsFileName);
     if (!tabsFile.open(QFile::ReadOnly)) {
         qWarning() << "ERROR: Cannot open tabs file "
                    << tabsFileName.toLocal8Bit().data();
         return false;
     }
 
     unsigned int sessions = 0;
     while (!tabsFile.atEnd()) {
         QString lineString(QString::fromUtf8(tabsFile.readLine()).trimmed());
         if ((lineString.isEmpty()) || (lineString[0] == QLatin1Char('#'))) {
             continue;
         }
 
         QHash<QString, QString> lineTokens;
         QStringList lineParts = lineString.split(QStringLiteral(";;"), QString::SkipEmptyParts);
 
         for (int i = 0; i < lineParts.size(); ++i) {
             QString key = lineParts.at(i).section(QLatin1Char(':'), 0, 0).trimmed().toLower();
             QString value = lineParts.at(i).section(QLatin1Char(':'), 1, -1).trimmed();
             lineTokens[key] = value;
         }
         // should contain at least one of 'command' and 'profile'
         if (lineTokens.contains(QStringLiteral("command"))
             || lineTokens.contains(QStringLiteral("profile"))) {
             createTabFromArgs(window, lineTokens);
             sessions++;
         } else {
             qWarning() << "Each line should contain at least one of 'command' and 'profile'.";
         }
     }
     tabsFile.close();
 
     if (sessions < 1) {
         qWarning() << "No valid lines found in "
                    << tabsFileName.toLocal8Bit().data();
         return false;
     }
 
     return true;
 }
 
 void Application::createTabFromArgs(MainWindow *window, const QHash<QString, QString> &tokens)
 {
     const QString &title = tokens[QStringLiteral("title")];
     const QString &command = tokens[QStringLiteral("command")];
     const QString &profile = tokens[QStringLiteral("profile")];
     const QString &workdir = tokens[QStringLiteral("workdir")];
 
     Profile::Ptr baseProfile;
     if (!profile.isEmpty()) {
         baseProfile = ProfileManager::instance()->loadProfile(profile);
     }
     if (!baseProfile) {
         // fallback to default profile
         baseProfile = ProfileManager::instance()->defaultProfile();
     }
 
     Profile::Ptr newProfile = Profile::Ptr(new Profile(baseProfile));
     newProfile->setHidden(true);
 
     // FIXME: the method of determining whether to use newProfile does not
     // scale well when we support more fields in the future
     bool shouldUseNewProfile = false;
 
     if (!command.isEmpty()) {
         newProfile->setProperty(Profile::Command, command);
         newProfile->setProperty(Profile::Arguments, command.split(QLatin1Char(' ')));
         shouldUseNewProfile = true;
     }
 
     if (!title.isEmpty()) {
         newProfile->setProperty(Profile::LocalTabTitleFormat, title);
         newProfile->setProperty(Profile::RemoteTabTitleFormat, title);
         shouldUseNewProfile = true;
     }
 
     if (m_parser->isSet(QStringLiteral("workdir"))) {
         newProfile->setProperty(Profile::Directory, m_parser->value(QStringLiteral("workdir")));
         shouldUseNewProfile = true;
     }
 
     if (!workdir.isEmpty()) {
         newProfile->setProperty(Profile::Directory, workdir);
         shouldUseNewProfile = true;
     }
 
     // Create the new session
     Profile::Ptr theProfile = shouldUseNewProfile ? newProfile : baseProfile;
     Session *session = window->createSession(theProfile, QString());
 
     if (m_parser->isSet(QStringLiteral("noclose"))) {
         session->setAutoClose(false);
     }
 
     if (!window->testAttribute(Qt::WA_Resized)) {
         window->resize(window->sizeHint());
     }
 
     // FIXME: this ugly hack here is to make the session start running, so that
     // its tab title is displayed as expected.
     //
     // This is another side effect of the commit fixing BKO 176902.
     window->show();
     window->hide();
 }
 
 // Creates a new Konsole window.
 // If --new-tab is given, use existing window.
 MainWindow *Application::processWindowArgs(bool &createdNewMainWindow)
 {
     MainWindow *window = nullptr;
     if (m_parser->isSet(QStringLiteral("new-tab"))) {
         QListIterator<QWidget *> iter(QApplication::topLevelWidgets());
         iter.toBack();
         while (iter.hasPrevious()) {
             window = qobject_cast<MainWindow *>(iter.previous());
             if (window != nullptr) {
                 break;
             }
         }
     }
 
     if (window == nullptr) {
         createdNewMainWindow = true;
         window = newMainWindow();
 
         // override default menubar visibility
         if (m_parser->isSet(QStringLiteral("show-menubar"))) {
             window->setMenuBarInitialVisibility(true);
         }
         if (m_parser->isSet(QStringLiteral("hide-menubar"))) {
             window->setMenuBarInitialVisibility(false);
         }
         if (m_parser->isSet(QStringLiteral("fullscreen"))) {
             window->viewFullScreen(true);
         }
-
-        // override default tabbbar visibility
-        // FIXME: remove those magic number
-        // see ViewContainer::NavigationVisibility
-        if (m_parser->isSet(QStringLiteral("show-tabbar"))) {
-            // always show
-            window->viewManager()->setNavigationVisibility(0);
-        }
-        if (m_parser->isSet(QStringLiteral("hide-tabbar"))) {
-            // never show
-            window->viewManager()->setNavigationVisibility(2);
-        }
     }
     return window;
 }
 
 // Loads a profile.
 // If --profile <name> is given, loads profile <name>.
 // If --fallback-profile is given, loads profile FALLBACK/.
 // Else loads the default profile.
 Profile::Ptr Application::processProfileSelectArgs()
 {
     Profile::Ptr defaultProfile = ProfileManager::instance()->defaultProfile();
 
     if (m_parser->isSet(QStringLiteral("profile"))) {
         Profile::Ptr profile = ProfileManager::instance()->loadProfile(
             m_parser->value(QStringLiteral("profile")));
         if (profile) {
             return profile;
         }
     } else if (m_parser->isSet(QStringLiteral("fallback-profile"))) {
         Profile::Ptr profile = ProfileManager::instance()->loadProfile(QStringLiteral("FALLBACK/"));
         if (profile) {
             return profile;
         }
     }
 
     return defaultProfile;
 }
 
 bool Application::processHelpArgs()
 {
     if (m_parser->isSet(QStringLiteral("list-profiles"))) {
         listAvailableProfiles();
         return true;
     } else if (m_parser->isSet(QStringLiteral("list-profile-properties"))) {
         listProfilePropertyInfo();
         return true;
     }
     return false;
 }
 
 void Application::listAvailableProfiles()
 {
     QStringList paths = ProfileManager::instance()->availableProfilePaths();
 
     foreach (const QString &path, paths) {
         QFileInfo info(path);
         printf("%s\n", info.completeBaseName().toLocal8Bit().constData());
     }
 }
 
 void Application::listProfilePropertyInfo()
 {
     Profile::Ptr tempProfile = ProfileManager::instance()->defaultProfile();
     const QStringList names = tempProfile->propertiesInfoList();
 
     foreach (const QString &name, names) {
         printf("%s\n", name.toLocal8Bit().constData());
     }
 }
 
 Profile::Ptr Application::processProfileChangeArgs(Profile::Ptr baseProfile)
 {
     bool shouldUseNewProfile = false;
 
     Profile::Ptr newProfile = Profile::Ptr(new Profile(baseProfile));
     newProfile->setHidden(true);
 
     // change the initial working directory
     if (m_parser->isSet(QStringLiteral("workdir"))) {
         newProfile->setProperty(Profile::Directory, m_parser->value(QStringLiteral("workdir")));
         shouldUseNewProfile = true;
     }
 
     // temporary changes to profile options specified on the command line
     const QStringList profileProperties = m_parser->values(QStringLiteral("p"));
     foreach (const QString &value, profileProperties) {
         ProfileCommandParser parser;
 
         QHashIterator<Profile::Property, QVariant> iter(parser.parse(value));
         while (iter.hasNext()) {
             iter.next();
             newProfile->setProperty(iter.key(), iter.value());
         }
 
         shouldUseNewProfile = true;
     }
 
     // run a custom command
     if (!m_customCommand.isEmpty()) {
         // Example: konsole -e man ls
         QString commandExec = m_customCommand[0];
         QStringList commandArguments(m_customCommand);
         if ((m_customCommand.size() == 1)
             && (QStandardPaths::findExecutable(commandExec).isEmpty())) {
             // Example: konsole -e "man ls"
             ShellCommand shellCommand(commandExec);
             commandExec = shellCommand.command();
             commandArguments = shellCommand.arguments();
         }
 
         if (commandExec.startsWith(QLatin1String("./"))) {
             commandExec = QDir::currentPath() + commandExec.mid(1);
         }
 
         newProfile->setProperty(Profile::Command, commandExec);
         newProfile->setProperty(Profile::Arguments, commandArguments);
 
         shouldUseNewProfile = true;
     }
 
     if (shouldUseNewProfile) {
         return newProfile;
     } else {
         return baseProfile;
     }
 }
 
 void Application::startBackgroundMode(MainWindow *window)
 {
     if (_backgroundInstance != nullptr) {
         return;
     }
 
     KActionCollection* collection = window->actionCollection();
     QAction* action = collection->addAction(QStringLiteral("toggle-background-window"));
     action->setObjectName(QStringLiteral("Konsole Background Mode"));
     action->setText(i18nc("@item", "Toggle Background Window"));
     KGlobalAccel::self()->setGlobalShortcut(action, QKeySequence(Konsole::ACCEL + Qt::SHIFT + Qt::Key_F12));
     connect(action, &QAction::triggered, this, &Application::toggleBackgroundInstance);
 
     _backgroundInstance = window;
 }
 
 void Application::toggleBackgroundInstance()
 {
     Q_ASSERT(_backgroundInstance);
 
     if (!_backgroundInstance->isVisible()) {
         _backgroundInstance->show();
         // ensure that the active terminal display has the focus. Without
         // this, an odd problem occurred where the focus widget would change
         // each time the background instance was shown
         _backgroundInstance->setFocus();
     } else {
         _backgroundInstance->hide();
     }
 }
 
 void Application::slotActivateRequested(QStringList args, const QString & /*workingDir*/)
 {
     // QCommandLineParser expects the first argument to be the executable name
     // In the current version it just strips it away
     args.prepend(qApp->applicationFilePath());
 
     m_customCommand = getCustomCommand(args);
 
     // We can't re-use QCommandLineParser instances, it preserves earlier parsed values
     auto parser = new QCommandLineParser;
     populateCommandLineParser(parser);
     parser->parse(args);
     m_parser.reset(parser);
 
     newInstance();
 }
 
 void Application::finalizeNewMainWindow(MainWindow *window)
 {
     if (!KonsoleSettings::saveGeometryOnExit()) {
         window->resize(window->sizeHint());
     }
     window->show();
 }
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index ff632b62..feb4f5a2 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,217 +1,210 @@
 # cmake-options : -DCMAKE_DISABLE_FIND_PACKAGE_LibKonq=TRUE or FALSE; default is FALSE
 
 add_definitions(-DTRANSLATION_DOMAIN=\"konsole\")
 
-### 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)
 
 ### Font Embedder and LineFont.h
 option(KONSOLE_BUILD_FONTEMBEDDER "Konsole: build fontembedder executable" OFF)
 option(KONSOLE_GENERATE_LINEFONT "Konsole: regenerate LineFont file" 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
-                        ViewContainerTabBar.cpp
                         ViewManager.cpp
                         ViewProperties.cpp
                         ViewSplitter.cpp
                         Vt102Emulation.cpp
                         ZModemDialog.cpp
                         PrintOptions.cpp
                         konsole_wcwidth.cpp
                         WindowSystemInfo.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(${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
 )
 
 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})
 
 ### konsoleprofile command-line tool
 install(PROGRAMS konsoleprofile DESTINATION ${KDE_INSTALL_BINDIR})
 
diff --git a/src/DetachableTabBar.cpp b/src/DetachableTabBar.cpp
new file mode 100644
index 00000000..3067e431
--- /dev/null
+++ b/src/DetachableTabBar.cpp
@@ -0,0 +1,30 @@
+#include "DetachableTabBar.h"
+#include <QMouseEvent>
+
+DetachableTabBar::DetachableTabBar(QWidget *parent) :
+    QTabBar(parent),
+    _draggingOutside(false) {}
+
+void DetachableTabBar::mouseMoveEvent(QMouseEvent *event)
+{
+    QTabBar::mouseMoveEvent(event);
+    if (!contentsRect().adjusted(-30,-30,30,30).contains(event->pos())) {
+        if (!_draggingOutside) {
+            _draggingOutside = true;
+            _originalCursor = cursor();
+            setCursor(QCursor(Qt::DragCopyCursor));
+        }
+    } else if (_draggingOutside) {
+        _draggingOutside = false;
+        setCursor(_originalCursor);
+    }
+}
+
+void DetachableTabBar::mouseReleaseEvent(QMouseEvent *event)
+{
+    QTabBar::mouseReleaseEvent(event);
+    if (!contentsRect().adjusted(-30,-30,30,30).contains(event->pos())) {
+        setCursor(_originalCursor);
+        emit detachTab(currentIndex());
+    }
+}
diff --git a/src/DetachableTabBar.h b/src/DetachableTabBar.h
new file mode 100644
index 00000000..c356206b
--- /dev/null
+++ b/src/DetachableTabBar.h
@@ -0,0 +1,21 @@
+#ifndef DETACHABLETABBAR_H
+#define DETACHABLETABBAR_H
+
+#include <QTabBar>
+#include <QCursor>
+
+class DetachableTabBar : public QTabBar {
+    Q_OBJECT
+public:
+    DetachableTabBar(QWidget *parent = nullptr);
+Q_SIGNALS:
+    void detachTab(int idx);
+protected:
+    void mouseMoveEvent(QMouseEvent*event) override;
+    void mouseReleaseEvent(QMouseEvent *event) override;
+private:
+    bool _draggingOutside;
+    QCursor _originalCursor;
+};
+
+#endif
diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
index 6df3b3d2..26990345 100644
--- a/src/MainWindow.cpp
+++ b/src/MainWindow.cpp
@@ -1,891 +1,854 @@
 /*
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "MainWindow.h"
 
 // Qt
 #include <QVBoxLayout>
 
 // 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>
 
 // 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 "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);
 
     // create the main widget
     setupMainWidget();
 
     // 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);
 
     // 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;
 
     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);
 
     KStandardAction::configureNotifications(this, SLOT(configureNotifications()), collection);
     KStandardAction::keyBindings(this, SLOT(showShortcutsDialog()), collection);
     KStandardAction::preferences(this, SLOT(showSettingsDialog()), collection);
 
     menuAction = collection->addAction(QStringLiteral("manage-profiles"));
     menuAction->setText(i18nc("@action:inmenu", "Manage Profiles..."));
     menuAction->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::showManageProfilesDialog);
 
     // Set up an shortcut-only action for activating menu bar.
     menuAction = collection->addAction(QStringLiteral("activate-menu"));
     menuAction->setText(i18nc("@item", "Activate Menu"));
     collection->setDefaultShortcut(menuAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_F10);
     connect(menuAction, &QAction::triggered, this, &Konsole::MainWindow::activateMenuBar);
 }
 
 void MainWindow::viewFullScreen(bool fullScreen)
 {
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);
     }
 }
 
 BookmarkHandler *MainWindow::bookmarkHandler() const
 {
     return _bookmarkHandler;
 }
 
 void MainWindow::setProfileList(ProfileList *list)
 {
     profileListChanged(list->actions());
 
     connect(list, &Konsole::ProfileList::profileSelected, this,
             &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->setNavigationVisibility(KonsoleSettings::tabBarVisibility());
-    _viewManager->setNavigationPosition(KonsoleSettings::tabBarPosition());
-    _viewManager->setNavigationBehavior(KonsoleSettings::newTabBehavior());
-    _viewManager->setNavigationTabWidthExpanding(KonsoleSettings::expandTabWidth());
-    _viewManager->setShowQuickButtons(KonsoleSettings::showQuickButtons());
-
-    if (KonsoleSettings::tabBarUseUserStyleSheet()) {
-        setNavigationStyleSheetFromFile(KonsoleSettings::tabBarUserStyleSheetFile());
-    } else {
-        // Apply default values
-        _viewManager->setNavigationStyleSheet(KonsoleSettings::tabBarStyleSheet());
-    }
-
     setAutoSaveSettings(QStringLiteral("MainWindow"), KonsoleSettings::saveGeometryOnExit());
-
     updateWindowCaption();
 }
 
-
-void MainWindow::setNavigationStyleSheetFromFile(const QUrl &styleSheetFile)
-{
-    // Let's only deal w/ local files for now
-    if (!styleSheetFile.isLocalFile()) {
-        _viewManager->setNavigationStyleSheet(KonsoleSettings::tabBarStyleSheet());
-    }
-
-    QFile file(styleSheetFile.toLocalFile());
-    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-        _viewManager->setNavigationStyleSheet(KonsoleSettings::tabBarStyleSheet());
-    }
-
-    QString styleSheetText;
-    QTextStream in(&file);
-    while (!in.atEnd()) {
-        styleSheetText.append(in.readLine());
-    }
-
-    // Replace current style sheet w/ loaded file
-    _viewManager->setNavigationStyleSheet(styleSheetText);
-}
-
 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::setupMainWidget()
 {
     auto mainWindowWidget = new QWidget(this);
     auto mainWindowLayout = new QVBoxLayout();
 
     mainWindowLayout->addWidget(_viewManager->widget());
     mainWindowLayout->setContentsMargins(0, 0, 0, 0);
     mainWindowLayout->setSpacing(0);
 
     mainWindowWidget->setLayout(mainWindowLayout);
 
     setCentralWidget(mainWindowWidget);
 }
 
 void MainWindow::configureNotifications()
 {
     KNotifyConfigWidget::configure(this);
 }
 
 void MainWindow::setBlur(bool blur)
 {
     if (_pluggedController.isNull()) {
         return;
     }
 
     if (!_pluggedController->isKonsolePart()) {
         KWindowEffects::enableBlurBehind(winId(), blur);
     }
 }
 
 void MainWindow::setMenuBarInitialVisibility(bool visible)
 {
     _menuBarInitialVisibility = visible;
 }
 
 void MainWindow::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);
 }
 
 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/MainWindow.h b/src/MainWindow.h
index 6ad0c3d7..11e65a25 100644
--- a/src/MainWindow.h
+++ b/src/MainWindow.h
@@ -1,197 +1,195 @@
 /*
     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.
 */
 
 #ifndef MAINWINDOW_H
 #define MAINWINDOW_H
 
 // Qt
 #include <QPointer>
 #include <QUrl>
 
 // KDE
 #include <KXmlGuiWindow>
 
 // Konsole
 #include "Profile.h"
 
 class QAction;
 class KActionMenu;
 class KToggleAction;
 
 namespace Konsole {
 class IncrementalSearchBar;
 class ViewManager;
 class ViewProperties;
 class Session;
 class SessionController;
 class ProfileList;
 class BookmarkHandler;
 
 /**
  * The main window.  This contains the menus and an area which contains the terminal displays.
  *
  * The main window does not create the views or the container widgets which hold the views.
  * This is done by the ViewManager class.  When a MainWindow is instantiated, it creates
  * a new ViewManager.  The ViewManager can then be used to create new terminal displays
  * inside the window.
  *
  * Do not construct new main windows directly, use Application's newMainWindow() method.
  */
 class MainWindow : public KXmlGuiWindow
 {
     Q_OBJECT
 
 public:
     /**
      * Constructs a new main window.  Do not create new main windows directly, use Application's
      * newMainWindow() method instead.
      */
     MainWindow();
 
     /**
      * Returns the view manager associated with this window.  The view manager can be used to
      * create new views on particular session objects inside this window.
      */
     ViewManager *viewManager() const;
 
     /**
      * Create a new session.
      *
      * @param profile The profile to use to create the new session.
      * @param directory Initial working directory for the new session or empty
      * if the default working directory associated with the profile should be used.
      */
     Session *createSession(Profile::Ptr profile, const QString &directory);
 
     /**
      * create a new SSH session.
      *
      * @param profile The profile to use to create the new session.
      * @param url the URL representing the new SSH connection
      */
     Session *createSSHSession(Profile::Ptr profile, const QUrl &url);
 
     /**
      * Helper method to make this window get input focus
      */
     void setFocus();
 
     /**
      * Set the initial visibility of the menubar.
      */
     void setMenuBarInitialVisibility(bool visible);
 
-    void setNavigationStyleSheetFromFile(const QUrl &styleSheetFile);
-
 Q_SIGNALS:
 
     /**
      * Emitted by the main window to request the creation of a
      * new session in a new window.
      *
      * @param profile The profile to use to create the
      * first session in the new window.
      * @param directory Initial working directory for the new window or empty
      * if the default working directory associated with the profile should
      * be used.
      */
     void newWindowRequest(Profile::Ptr profile, const QString &directory);
 
     /**
      * Emitted when a view for one session is detached from this window
      */
     void viewDetached(Session *session);
 
 protected:
     // Reimplemented for internal reasons.
     void showEvent(QShowEvent *event) Q_DECL_OVERRIDE;
 
     // reimplemented from KMainWindow
     bool queryClose() Q_DECL_OVERRIDE;
     void saveProperties(KConfigGroup &group) Q_DECL_OVERRIDE;
     void readProperties(const KConfigGroup &group) Q_DECL_OVERRIDE;
     void saveGlobalProperties(KConfig *config) Q_DECL_OVERRIDE;
     void readGlobalProperties(KConfig *config) Q_DECL_OVERRIDE;
 
     // reimplemented from QWidget
     bool focusNextPrevChild(bool next) Q_DECL_OVERRIDE;
 
 private Q_SLOTS:
     void newTab();
     void cloneTab();
     void newWindow();
     void showManageProfilesDialog();
     void activateMenuBar();
     void showSettingsDialog(const bool showProfilePage = false);
     void showShortcutsDialog();
     void newFromProfile(Profile::Ptr profile);
     void activeViewChanged(SessionController *controller);
     void disconnectController(SessionController *controller);
     void activeViewTitleChanged(ViewProperties *);
 
     void profileListChanged(const QList<QAction *> &sessionActions);
     void configureNotifications();
     void setBlur(bool blur);
 
     void updateWindowIcon();
     void updateWindowCaption();
     void openUrls(const QList<QUrl> &urls);
 
     // Sets the list of profiles to be displayed under the "New Tab" action
     void setProfileList(ProfileList *list);
 
     void applyKonsoleSettings();
 
     void updateUseTransparency();
 
 public Q_SLOTS:
     void viewFullScreen(bool fullScreen);
 
 private:
     void correctStandardShortcuts();
     void rememberMenuAccelerators();
     void removeMenuAccelerators();
     void restoreMenuAccelerators();
     void setupActions();
     void setupMainWidget();
     QString activeSessionDir() const;
 
     /**
      * Returns the bookmark handler associated with this window.
      */
     BookmarkHandler *bookmarkHandler() const;
 
     // sets the active shortcuts of actions in 'dest' to the shortcuts of actions
     // with the same name in 'source' (see QAction::ActiveShortcut)
     static void syncActiveShortcuts(KActionCollection *dest, const KActionCollection *source);
 
 private:
     ViewManager *_viewManager;
     BookmarkHandler *_bookmarkHandler;
     KToggleAction *_toggleMenuBarAction;
     KActionMenu *_newTabMenuAction;
 
     QPointer<SessionController> _pluggedController;
 
     bool _menuBarInitialVisibility;
     bool _menuBarInitialVisibilityApplied;
 };
 }
 
 #endif // MAINWINDOW_H
diff --git a/src/Session.cpp b/src/Session.cpp
index 5e9cd062..92e37a48 100644
--- a/src/Session.cpp
+++ b/src/Session.cpp
@@ -1,1772 +1,1770 @@
 /*
     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>
 
 // 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);
-
-    connect(this, &Konsole::Session::tabRenamedByUser, this, &Konsole::Session::tabTitleSetByUser);
 }
 
 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;
         }
     }
 
     KNotification::event(hasFocus ? QStringLiteral("Silence") : QStringLiteral("SilenceHidden"),
             i18n("Silence in session '%1'", _nameTitle), QPixmap(),
             QApplication::activeWindow(),
             KNotification::CloseWhenWidgetActivated);
     emit stateChanged(NOTIFYSILENCE);
 }
 
 void Session::activityTimerDone()
 {
     _notifiedActivity = false;
 }
 
 void Session::updateFlowControlState(bool suspended)
 {
     if (suspended) {
         if (flowControlEnabled()) {
             foreach(TerminalDisplay * display, _views) {
                 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) {
             KNotification::event(hasFocus ? QStringLiteral("Activity") : QStringLiteral("ActivityHidden"),
                                  i18n("Activity in session '%1'", _nameTitle), QPixmap(),
                                  QApplication::activeWindow(),
                                  KNotification::CloseWhenWidgetActivated);
 
             // mask activity notification for a while to avoid flooding
             _notifiedActivity = true;
             _activityTimer->start(activityMaskInSeconds * 1000);
         }
 
         // reset the counter for monitoring continuous silence since there is activity
         if (_monitorSilence) {
             _silenceTimer->start(_silenceSeconds * 1000);
         }
     }
 
     if (state == NOTIFYACTIVITY && !_monitorActivity) {
         state = NOTIFYNORMAL;
     }
     if (state == NOTIFYSILENCE && !_monitorSilence) {
         state = NOTIFYNORMAL;
     }
 
     emit stateChanged(state);
 }
 
 void Session::onViewSizeChange(int /*height*/, int /*width*/)
 {
     updateTerminalSize();
 }
 
 void Session::updateTerminalSize()
 {
     int minLines = -1;
     int minColumns = -1;
 
     // minimum number of lines and columns that views require for
     // their size to be taken into consideration ( to avoid problems
     // with new view widgets which haven't yet been set to their correct size )
     const int VIEW_LINES_THRESHOLD = 2;
     const int VIEW_COLUMNS_THRESHOLD = 2;
 
     //select largest number of lines and columns that will fit in all visible views
     foreach(TerminalDisplay* view, _views) {
         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;
     }
 
     _emulation->sendText(text + eol);
 }
 
 // Only D-Bus calls this function (via SendText or runCommand)
 void Session::sendText(const QString& text) const
 {
     if (isReadOnly()) {
         return;
     }
 
 #if !defined(REMOVE_SENDTEXT_RUNCOMMAND_DBUS_METHODS)
     if (show_disallow_certain_dbus_methods_message) {
 
         KNotification::event(KNotification::Warning, QStringLiteral("Konsole D-Bus Warning"),
             i18n("The D-Bus methods sendText/runCommand were just used.  There are security concerns about allowing these methods to be public.  If desired, these methods can be changed to internal use only by re-compiling Konsole. <p>This warning will only show once for this Konsole instance.</p>"));
 
         show_disallow_certain_dbus_methods_message = false;
     }
 #endif
 
     _emulation->sendText(text);
 }
 
 // Only D-Bus calls this function
 void Session::runCommand(const QString& command) const
 {
     sendText(command + QLatin1Char('\n'));
 }
 
 void Session::sendMouseEvent(int buttons, int column, int line, int eventType)
 {
     _emulation->sendMouseEvent(buttons, column, line, eventType);
 }
 
 void Session::done(int exitCode, QProcess::ExitStatus exitStatus)
 {
     // This slot should be triggered only one time
     disconnect(_shellProcess, 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);
         }
 
         //FIXME: See comments in Session::silenceTimerDone()
         KNotification::event(QStringLiteral("Finished"), message , QPixmap(),
                              QApplication::activeWindow(),
                              KNotification::CloseWhenWidgetActivated);
     }
 
     if (exitStatus != QProcess::NormalExit) {
         // this seeming duplicated line is for the case when exitCode is 0
         message = i18n("Program '%1' crashed.", _program);
         terminalWarning(message);
     } else {
         emit finished();
     }
 }
 
 Emulation* Session::emulation() const
 {
     return _emulation;
 }
 
 QString Session::keyBindings() const
 {
     return _emulation->keyBindings();
 }
 
 QStringList Session::environment() const
 {
     return _environment;
 }
 
 void Session::setEnvironment(const QStringList& environment)
 {
     if (isReadOnly()) {
         return;
     }
 
     _environment = environment;
 }
 
 void Session::addEnvironmentEntry(const QString& entry)
 {
     _environment << entry;
 }
 
 int Session::sessionId() const
 {
     return _sessionId;
 }
 
 void Session::setKeyBindings(const QString& name)
 {
     _emulation->setKeyBindings(name);
 }
 
 void Session::setTitle(TitleRole role , const QString& newTitle)
 {
     if (title(role) != newTitle) {
         if (role == NameRole) {
             _nameTitle = newTitle;
         } else if (role == DisplayedTitleRole) {
             _displayTitle = newTitle;
         }
 
         emit sessionAttributeChanged();
     }
 }
 
 QString Session::title(TitleRole role) const
 {
     if (role == NameRole) {
         return _nameTitle;
     } else if (role == DisplayedTitleRole) {
         return _displayTitle;
     } else {
         return QString();
     }
 }
 
 ProcessInfo* Session::getProcessInfo()
 {
     ProcessInfo* process = nullptr;
 
     if (isForegroundProcessActive() && updateForegroundProcessInfo()) {
         process = _foregroundProcessInfo;
     } else {
         updateSessionProcessInfo();
         process = _sessionProcessInfo;
     }
 
     return process;
 }
 
 void Session::updateSessionProcessInfo()
 {
     Q_ASSERT(_shellProcess);
 
     bool ok;
     // The checking for pid changing looks stupid, but it is needed
     // at the moment to workaround the problem that processId() might
     // return 0
     if ((_sessionProcessInfo == nullptr) ||
             (processId() != 0 && processId() != _sessionProcessInfo->pid(&ok))) {
         delete _sessionProcessInfo;
         _sessionProcessInfo = ProcessInfo::newInstance(processId(),
                     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"), process->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 024b0690..07f97f3d 100644
--- a/src/Session.h
+++ b/src/Session.h
@@ -1,904 +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);
 
     /**
      * 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();
 
-    /**
-     * Relays the tabRenamedByUser signal from SessionController
-     */
-    void tabRenamedByUser(bool renamed) const;
-
 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);
 
-    void tabTitleSetByUser(bool set);
-
 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/SessionController.cpp b/src/SessionController.cpp
index b0bb53bf..5cff9c4a 100644
--- a/src/SessionController.cpp
+++ b/src/SessionController.cpp
@@ -1,2118 +1,2118 @@
 /*
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
     Copyright 2009 by Thomas Dreibholz <dreibh@iem.uni-due.de>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "SessionController.h"
 
 #include "ProfileManager.h"
 #include "konsoledebug.h"
 
 // Qt
 #include <QApplication>
 #include <QAction>
 #include <QMenu>
 #include <QKeyEvent>
 #include <QPrinter>
 #include <QPrintDialog>
 #include <QFileDialog>
 #include <QPainter>
 #include <QStandardPaths>
 #include <QUrl>
 #include <QIcon>
 
 // KDE
 #include <KActionMenu>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KRun>
 #include <KShell>
 #include <KToolInvocation>
 #include <KToggleAction>
 #include <KSelectAction>
 #include <KXmlGuiWindow>
 #include <KXMLGUIFactory>
 #include <KXMLGUIBuilder>
 #include <KUriFilter>
 #include <KStringHandler>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KCodecAction>
 
 // Konsole
 #include "EditProfileDialog.h"
 #include "CopyInputDialog.h"
 #include "Emulation.h"
 #include "Filter.h"
 #include "History.h"
 #include "HistorySizeDialog.h"
 #include "IncrementalSearchBar.h"
 #include "RenameTabDialog.h"
 #include "ScreenWindow.h"
 #include "Session.h"
 #include "ProfileList.h"
 #include "TerminalDisplay.h"
 #include "SessionManager.h"
 #include "Enumeration.h"
 #include "PrintOptions.h"
 
 // for SaveHistoryTask
 #include <KIO/Job>
 #include <KJob>
 #include "TerminalCharacterDecoder.h"
 
 // For Unix signal names
 #include <signal.h>
 
 using namespace Konsole;
 
 // TODO - Replace the icon choices below when suitable icons for silence and
 // activity are available
 Q_GLOBAL_STATIC_WITH_ARGS(QIcon, _activityIcon, (QIcon::fromTheme(QLatin1String("dialog-information"))))
 Q_GLOBAL_STATIC_WITH_ARGS(QIcon, _silenceIcon, (QIcon::fromTheme(QLatin1String("dialog-information"))))
 Q_GLOBAL_STATIC_WITH_ARGS(QIcon, _broadcastIcon, (QIcon::fromTheme(QLatin1String("emblem-important"))))
 
 QSet<SessionController*> SessionController::_allControllers;
 int SessionController::_lastControllerId;
 
 SessionController::SessionController(Session* session , TerminalDisplay* view, QObject* parent)
     : ViewProperties(parent)
     , KXMLGUIClient()
     , _session(session)
     , _view(view)
     , _copyToGroup(nullptr)
     , _profileList(nullptr)
     , _sessionIcon(QIcon())
     , _sessionIconName(QString())
     , _previousState(-1)
     , _searchFilter(nullptr)
     , _urlFilter(nullptr)
     , _fileFilter(nullptr)
     , _copyInputToAllTabsAction(nullptr)
     , _findAction(nullptr)
     , _findNextAction(nullptr)
     , _findPreviousAction(nullptr)
     , _interactionTimer(nullptr)
     , _searchStartLine(0)
     , _prevSearchResultLine(0)
     , _codecAction(nullptr)
     , _switchProfileMenu(nullptr)
     , _webSearchMenu(nullptr)
     , _listenForScreenWindowUpdates(false)
     , _preventClose(false)
     , _keepIconUntilInteraction(false)
     , _selectedText(QString())
     , _showMenuAction(nullptr)
     , _bookmarkValidProgramsToClear(QStringList())
     , _isSearchBarEnabled(false)
     , _editProfileDialog(nullptr)
     , _searchBar(view->searchBar())
 {
     Q_ASSERT(session);
     Q_ASSERT(view);
 
     // handle user interface related to session (menus etc.)
     if (isKonsolePart()) {
         setComponentName(QStringLiteral("konsole"), i18n("Konsole"));
         setXMLFile(QStringLiteral("partui.rc"));
         setupCommonActions();
     } else {
         setXMLFile(QStringLiteral("sessionui.rc"));
         setupCommonActions();
         setupExtraActions();
     }
 
     actionCollection()->addAssociatedWidget(view);
     foreach(QAction * action, actionCollection()->actions()) {
         action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     }
 
     setIdentifier(++_lastControllerId);
     sessionAttributeChanged();
 
     view->installEventFilter(this);
     view->setSessionController(this);
 
     // install filter on the view to highlight URLs and files
     updateFilterList(SessionManager::instance()->sessionProfile(_session));
 
     // listen for changes in session, we might need to change the enabled filters
     connect(ProfileManager::instance(), &Konsole::ProfileManager::profileChanged, this, &Konsole::SessionController::updateFilterList);
 
     // listen for session resize requests
     connect(_session.data(), &Konsole::Session::resizeRequest, this, &Konsole::SessionController::sessionResizeRequest);
 
     // listen for popup menu requests
     connect(_view.data(), &Konsole::TerminalDisplay::configureRequest, this, &Konsole::SessionController::showDisplayContextMenu);
 
     // move view to newest output when keystrokes occur
     connect(_view.data(), &Konsole::TerminalDisplay::keyPressedSignal, this, &Konsole::SessionController::trackOutput);
 
     // listen to activity / silence notifications from session
     connect(_session.data(), &Konsole::Session::stateChanged, this, &Konsole::SessionController::sessionStateChanged);
     // listen to title and icon changes
     connect(_session.data(), &Konsole::Session::sessionAttributeChanged, this, &Konsole::SessionController::sessionAttributeChanged);
     connect(_session.data(), &Konsole::Session::readOnlyChanged, this, &Konsole::SessionController::sessionReadOnlyChanged);
 
-    connect(this, &Konsole::SessionController::tabRenamedByUser,  _session,  &Konsole::Session::tabRenamedByUser);
+    connect(this, &Konsole::SessionController::tabRenamedByUser,  _session,  &Konsole::Session::tabTitleSetByUser);
 
     connect(_session.data() , &Konsole::Session::currentDirectoryChanged , this , &Konsole::SessionController::currentDirectoryChanged);
 
     // listen for color changes
     connect(_session.data(), &Konsole::Session::changeBackgroundColorRequest, _view.data(), &Konsole::TerminalDisplay::setBackgroundColor);
     connect(_session.data(), &Konsole::Session::changeForegroundColorRequest, _view.data(), &Konsole::TerminalDisplay::setForegroundColor);
 
     // update the title when the session starts
     connect(_session.data(), &Konsole::Session::started, this, &Konsole::SessionController::snapshot);
 
     // listen for output changes to set activity flag
     connect(_session->emulation(), &Konsole::Emulation::outputChanged, this, &Konsole::SessionController::fireActivity);
 
     // listen for detection of ZModem transfer
     connect(_session.data(), &Konsole::Session::zmodemDownloadDetected, this, &Konsole::SessionController::zmodemDownload);
     connect(_session.data(), &Konsole::Session::zmodemUploadDetected, this, &Konsole::SessionController::zmodemUpload);
 
     // listen for flow control status changes
     connect(_session.data(), &Konsole::Session::flowControlEnabledChanged, _view.data(), &Konsole::TerminalDisplay::setFlowControlWarningEnabled);
     _view->setFlowControlWarningEnabled(_session->flowControlEnabled());
 
     // take a snapshot of the session state every so often when
     // user activity occurs
     //
     // the timer is owned by the session so that it will be destroyed along
     // with the session
     _interactionTimer = new QTimer(_session);
     _interactionTimer->setSingleShot(true);
     _interactionTimer->setInterval(500);
     connect(_interactionTimer, &QTimer::timeout, this, &Konsole::SessionController::snapshot);
     connect(_view.data(), &Konsole::TerminalDisplay::keyPressedSignal, this, &Konsole::SessionController::interactionHandler);
 
     // take a snapshot of the session state periodically in the background
     auto backgroundTimer = new QTimer(_session);
     backgroundTimer->setSingleShot(false);
     backgroundTimer->setInterval(2000);
     connect(backgroundTimer, &QTimer::timeout, this, &Konsole::SessionController::snapshot);
     backgroundTimer->start();
 
     // xterm '11;?' request
     connect(_session.data(), &Konsole::Session::getBackgroundColor,
             this, &Konsole::SessionController::sendBackgroundColor);
 
     _allControllers.insert(this);
 
     // A list of programs that accept Ctrl+C to clear command line used
     // before outputting bookmark.
     _bookmarkValidProgramsToClear << QStringLiteral("bash") << QStringLiteral("fish") << QStringLiteral("sh");
     _bookmarkValidProgramsToClear << QStringLiteral("tcsh") << QStringLiteral("zsh");
     setupSearchBar();
     _searchBar->setVisible(_isSearchBarEnabled);
 }
 
 SessionController::~SessionController()
 {
     if (!_view.isNull()) {
         _view->setScreenWindow(nullptr);
     }
 
     _allControllers.remove(this);
 
     if (!_editProfileDialog.isNull()) {
         delete _editProfileDialog.data();
     }
 }
 void SessionController::trackOutput(QKeyEvent* event)
 {
     Q_ASSERT(_view->screenWindow());
 
     // Only jump to the bottom if the user actually typed something in,
     // not if the user e. g. just pressed a modifier.
     if (event->text().isEmpty() && (event->modifiers() != 0u)) {
         return;
     }
 
     _view->screenWindow()->setTrackOutput(true);
 }
 void SessionController::interactionHandler()
 {
     // This flag is used to make sure those special icons indicating interest
     // events (activity/silence/bell?) remain in the tab until user interaction
     // happens. Otherwise, those special icons will quickly be replaced by
     // normal icon when ::snapshot() is triggered
     _keepIconUntilInteraction = false;
     _interactionTimer->start();
 }
 
 void SessionController::snapshot()
 {
     Q_ASSERT(!_session.isNull());
 
     QString title = _session->getDynamicTitle();
     title         = title.simplified();
 
     // Visualize that the session is broadcasting to others
     if ((_copyToGroup != nullptr) && _copyToGroup->sessions().count() > 1) {
         title.append(QLatin1Char('*'));
     }
 
     // use the fallback title if needed
     if (title.isEmpty()) {
         title = _session->title(Session::NameRole);
     }
 
     // apply new title
     _session->setTitle(Session::DisplayedTitleRole, title);
 
     // do not forget icon
     updateSessionIcon();
 }
 
 QString SessionController::currentDir() const
 {
     return _session->currentWorkingDirectory();
 }
 
 QUrl SessionController::url() const
 {
     return _session->getUrl();
 }
 
 void SessionController::rename()
 {
     renameSession();
 }
 
 void SessionController::openUrl(const QUrl& url)
 {
     // Clear shell's command line
     if (!_session->isForegroundProcessActive()
             && _bookmarkValidProgramsToClear.contains(_session->foregroundProcessName())) {
         _session->sendTextToTerminal(QChar(0x03), QLatin1Char('\n')); // Ctrl+C
     }
 
     // handle local paths
     if (url.isLocalFile()) {
         QString path = url.toLocalFile();
         _session->sendTextToTerminal(QStringLiteral("cd ") + KShell::quoteArg(path), QLatin1Char('\r'));
     } else if (url.scheme().isEmpty()) {
         // QUrl couldn't parse what the user entered into the URL field
         // so just dump it to the shell
         QString command = url.toDisplayString();
         if (!command.isEmpty()) {
             _session->sendTextToTerminal(command, QLatin1Char('\r'));
         }
     } else if (url.scheme() == QLatin1String("ssh")) {
         QString sshCommand = QStringLiteral("ssh ");
 
         if (url.port() > -1) {
             sshCommand += QStringLiteral("-p %1 ").arg(url.port());
         }
         if (!url.userName().isEmpty()) {
             sshCommand += (url.userName() + QLatin1Char('@'));
         }
         if (!url.host().isEmpty()) {
             sshCommand += url.host();
         }
         _session->sendTextToTerminal(sshCommand, QLatin1Char('\r'));
 
     } else if (url.scheme() == QLatin1String("telnet")) {
         QString telnetCommand = QStringLiteral("telnet ");
 
         if (!url.userName().isEmpty()) {
             telnetCommand += QStringLiteral("-l %1 ").arg(url.userName());
         }
         if (!url.host().isEmpty()) {
             telnetCommand += (url.host() + QLatin1Char(' '));
         }
         if (url.port() > -1) {
             telnetCommand += QString::number(url.port());
         }
 
         _session->sendTextToTerminal(telnetCommand, QLatin1Char('\r'));
 
     } else {
         //TODO Implement handling for other Url types
 
         KMessageBox::sorry(_view->window(),
                            i18n("Konsole does not know how to open the bookmark: ") +
                            url.toDisplayString());
 
         qCDebug(KonsoleDebug) << "Unable to open bookmark at url" << url << ", I do not know"
                    << " how to handle the protocol " << url.scheme();
     }
 }
 
 void SessionController::setupPrimaryScreenSpecificActions(bool use)
 {
     KActionCollection* collection = actionCollection();
     QAction* clearAction = collection->action(QStringLiteral("clear-history"));
     QAction* resetAction = collection->action(QStringLiteral("clear-history-and-reset"));
     QAction* selectAllAction = collection->action(QStringLiteral("select-all"));
     QAction* selectLineAction = collection->action(QStringLiteral("select-line"));
 
     // these actions are meaningful only when primary screen is used.
     clearAction->setEnabled(use);
     resetAction->setEnabled(use);
     selectAllAction->setEnabled(use);
     selectLineAction->setEnabled(use);
 }
 
 void SessionController::selectionChanged(const QString& selectedText)
 {
     _selectedText = selectedText;
     updateCopyAction(selectedText);
 }
 
 void SessionController::updateCopyAction(const QString& selectedText)
 {
     QAction* copyAction = actionCollection()->action(QStringLiteral("edit_copy"));
 
     // copy action is meaningful only when some text is selected.
     copyAction->setEnabled(!selectedText.isEmpty());
 }
 
 void SessionController::updateWebSearchMenu()
 {
     // reset
     _webSearchMenu->setVisible(false);
     _webSearchMenu->menu()->clear();
 
     if (_selectedText.isEmpty()) {
         return;
     }
 
     QString searchText = _selectedText;
     searchText = searchText.replace(QLatin1Char('\n'), QLatin1Char(' ')).replace(QLatin1Char('\r'), QLatin1Char(' ')).simplified();
 
     if (searchText.isEmpty()) {
         return;
     }
 
     KUriFilterData filterData(searchText);
     filterData.setSearchFilteringOptions(KUriFilterData::RetrievePreferredSearchProvidersOnly);
 
     if (KUriFilter::self()->filterSearchUri(filterData, KUriFilter::NormalTextFilter)) {
         const QStringList searchProviders = filterData.preferredSearchProviders();
         if (!searchProviders.isEmpty()) {
             _webSearchMenu->setText(i18n("Search for '%1' with",  KStringHandler::rsqueeze(searchText, 16)));
 
             QAction* action = nullptr;
 
             foreach(const QString& searchProvider, searchProviders) {
                 action = new QAction(searchProvider, _webSearchMenu);
                 action->setIcon(QIcon::fromTheme(filterData.iconNameForPreferredSearchProvider(searchProvider)));
                 action->setData(filterData.queryForPreferredSearchProvider(searchProvider));
                 connect(action, &QAction::triggered, this, &Konsole::SessionController::handleWebShortcutAction);
                 _webSearchMenu->addAction(action);
             }
 
             _webSearchMenu->addSeparator();
 
             action = new QAction(i18n("Configure Web Shortcuts..."), _webSearchMenu);
             action->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
             connect(action, &QAction::triggered, this, &Konsole::SessionController::configureWebShortcuts);
             _webSearchMenu->addAction(action);
 
             _webSearchMenu->setVisible(true);
         }
     }
 }
 
 void SessionController::handleWebShortcutAction()
 {
     QAction * action = qobject_cast<QAction*>(sender());
     if (action == nullptr) {
         return;
     }
 
     KUriFilterData filterData(action->data().toString());
 
     if (KUriFilter::self()->filterUri(filterData, QStringList() << QStringLiteral("kurisearchfilter"))) {
         const QUrl& url = filterData.uri();
         new KRun(url, QApplication::activeWindow());
     }
 }
 
 void SessionController::configureWebShortcuts()
 {
     KToolInvocation::kdeinitExec(QStringLiteral("kcmshell5"), QStringList() << QStringLiteral("webshortcuts"));
 }
 
 void SessionController::sendSignal(QAction* action)
 {
     const int signal = action->data().value<int>();
     _session->sendSignal(signal);
 }
 
 void SessionController::sendBackgroundColor()
 {
     const QColor c = _view->getBackgroundColor();
     _session->reportBackgroundColor(c);
 }
 
 void SessionController::toggleReadOnly()
 {
     QAction *action = qobject_cast<QAction*>(sender());
     if (action != nullptr) {
         bool readonly = !isReadOnly();
         _session->setReadOnly(readonly);
     }
 }
 
 bool SessionController::eventFilter(QObject* watched , QEvent* event)
 {
     if (event->type() == QEvent::FocusIn && watched == _view) {
         // notify the world that the view associated with this session has been focused
         // used by the view manager to update the title of the MainWindow widget containing the view
         emit focused(this);
 
         // when the view is focused, set bell events from the associated session to be delivered
         // by the focused view
 
         // first, disconnect any other views which are listening for bell signals from the session
         disconnect(_session.data(), &Konsole::Session::bellRequest, nullptr, nullptr);
         // second, connect the newly focused view to listen for the session's bell signal
         connect(_session.data(), &Konsole::Session::bellRequest, _view.data(), &Konsole::TerminalDisplay::bell);
 
         if ((_copyInputToAllTabsAction != nullptr) && _copyInputToAllTabsAction->isChecked()) {
             // A session with "Copy To All Tabs" has come into focus:
             // Ensure that newly created sessions are included in _copyToGroup!
             copyInputToAllTabs();
         }
     }
     return Konsole::ViewProperties::eventFilter(watched, event);
 }
 
 void SessionController::removeSearchFilter()
 {
     if (_searchFilter == nullptr) {
         return;
     }
 
     _view->filterChain()->removeFilter(_searchFilter);
     delete _searchFilter;
     _searchFilter = nullptr;
 }
 
 void SessionController::setupSearchBar()
 {
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::unhandledMovementKeyPressed, this, &Konsole::SessionController::movementKeyFromSearchBarReceived);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::closeClicked, this, &Konsole::SessionController::searchClosed);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchFromClicked, this, &Konsole::SessionController::searchFrom);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::findNextClicked, this, &Konsole::SessionController::findNextInHistory);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::findPreviousClicked, this, &Konsole::SessionController::findPreviousInHistory);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::highlightMatchesToggled , this , &Konsole::SessionController::highlightMatches);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::matchCaseToggled, this, &Konsole::SessionController::changeSearchMatch);
     connect(_searchBar.data(), &Konsole::IncrementalSearchBar::matchRegExpToggled, this, &Konsole::SessionController::changeSearchMatch);
 }
 
 void SessionController::setShowMenuAction(QAction* action)
 {
     _showMenuAction = action;
 }
 
 void SessionController::setupCommonActions()
 {
     KActionCollection* collection = actionCollection();
 
     // Close Session
     QAction* action = collection->addAction(QStringLiteral("close-session"), this, SLOT(closeSession()));
     if (isKonsolePart()) {
         action->setText(i18n("&Close Session"));
     } else {
         action->setText(i18n("&Close Tab"));
     }
 
     action->setIcon(QIcon::fromTheme(QStringLiteral("tab-close")));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_W);
 
     // Open Browser
     action = collection->addAction(QStringLiteral("open-browser"), this, SLOT(openBrowser()));
     action->setText(i18n("Open File Manager"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("system-file-manager")));
 
     // Copy and Paste
     action = KStandardAction::copy(this, SLOT(copy()), collection);
 #ifdef Q_OS_MACOS
     // Don't use the Konsole::ACCEL const here, we really want the Command key (Qt::META)
     // TODO: check what happens if we leave it to Qt to assign the default?
     collection->setDefaultShortcut(action, Qt::META + Qt::Key_C);
 #else
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_C);
 #endif
     // disabled at first, since nothing has been selected now
     action->setEnabled(false);
 
     action = KStandardAction::paste(this, SLOT(paste()), collection);
     QList<QKeySequence> pasteShortcut;
 #ifdef Q_OS_MACOS
     pasteShortcut.append(QKeySequence(Qt::META + Qt::Key_V));
     // No Insert key on Mac keyboards
 #else
     pasteShortcut.append(QKeySequence(Konsole::ACCEL + Qt::SHIFT + Qt::Key_V));
     pasteShortcut.append(QKeySequence(Qt::SHIFT + Qt::Key_Insert));
 #endif
     collection->setDefaultShortcuts(action, pasteShortcut);
 
     action = collection->addAction(QStringLiteral("paste-selection"), this, SLOT(pasteFromX11Selection()));
     action->setText(i18n("Paste Selection"));
 #ifdef Q_OS_MACOS
     collection->setDefaultShortcut(action, Qt::META + Qt::SHIFT + Qt::Key_V);
 #else
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_Insert);
 #endif
 
     _webSearchMenu = new KActionMenu(i18n("Web Search"), this);
     _webSearchMenu->setIcon(QIcon::fromTheme(QStringLiteral("preferences-web-browser-shortcuts")));
     _webSearchMenu->setVisible(false);
     collection->addAction(QStringLiteral("web-search"), _webSearchMenu);
 
 
     action = collection->addAction(QStringLiteral("select-all"), this, SLOT(selectAll()));
     action->setText(i18n("&Select All"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-select-all")));
 
     action = collection->addAction(QStringLiteral("select-line"), this, SLOT(selectLine()));
     action->setText(i18n("Select &Line"));
 
     action = KStandardAction::saveAs(this, SLOT(saveHistory()), collection);
     action->setText(i18n("Save Output &As..."));
 #ifdef Q_OS_MACOS
     action->setShortcut(QKeySequence(Qt::META + Qt::Key_S));
 #endif
 
     action = KStandardAction::print(this, SLOT(print_screen()), collection);
     action->setText(i18n("&Print Screen..."));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_P);
 
     action = collection->addAction(QStringLiteral("adjust-history"), this, SLOT(showHistoryOptions()));
     action->setText(i18n("Adjust Scrollback..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
 
     action = collection->addAction(QStringLiteral("clear-history"), this, SLOT(clearHistory()));
     action->setText(i18n("Clear Scrollback"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-clear-history")));
 
     action = collection->addAction(QStringLiteral("clear-history-and-reset"), this, SLOT(clearHistoryAndReset()));
     action->setText(i18n("Clear Scrollback and Reset"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-clear-history")));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::SHIFT + Qt::Key_K);
 
     // Profile Options
     action = collection->addAction(QStringLiteral("edit-current-profile"), this, SLOT(editCurrentProfile()));
     action->setText(i18n("Edit Current Profile..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("document-properties")));
 
     _switchProfileMenu = new KActionMenu(i18n("Switch Profile"), this);
     collection->addAction(QStringLiteral("switch-profile"), _switchProfileMenu);
     connect(_switchProfileMenu->menu(), &QMenu::aboutToShow, this, &Konsole::SessionController::prepareSwitchProfileMenu);
 
     // History
     _findAction = KStandardAction::find(this, SLOT(searchBarEvent()), collection);
     collection->setDefaultShortcut(_findAction, QKeySequence());
 
     _findNextAction = KStandardAction::findNext(this, SLOT(findNextInHistory()), collection);
     collection->setDefaultShortcut(_findNextAction, QKeySequence());
     _findNextAction->setEnabled(false);
 
     _findPreviousAction = KStandardAction::findPrev(this, SLOT(findPreviousInHistory()), collection);
     collection->setDefaultShortcut(_findPreviousAction, QKeySequence());
     _findPreviousAction->setEnabled(false);
 
     // Character Encoding
     _codecAction = new KCodecAction(i18n("Set &Encoding"), this);
     _codecAction->setIcon(QIcon::fromTheme(QStringLiteral("character-set")));
     collection->addAction(QStringLiteral("set-encoding"), _codecAction);
     connect(_codecAction->menu(), &QMenu::aboutToShow, this, &Konsole::SessionController::updateCodecAction);
     connect(_codecAction, static_cast<void(KCodecAction::*)(QTextCodec*)>(&KCodecAction::triggered), this, &Konsole::SessionController::changeCodec);
 
     // Read-only
     action = collection->addAction(QStringLiteral("view-readonly"), this, SLOT(toggleReadOnly()));
     action->setText(i18nc("@item:inmenu A read only (locked) session", "Read-only"));
     action->setCheckable(true);
     updateReadOnlyActionStates();
 }
 
 void SessionController::setupExtraActions()
 {
     KActionCollection* collection = actionCollection();
 
     // Rename Session
     QAction* action = collection->addAction(QStringLiteral("rename-session"), this, SLOT(renameSession()));
     action->setText(i18n("&Rename Tab..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-rename")));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::ALT + Qt::Key_S);
 
     // Copy input to ==> all tabs
     KToggleAction* copyInputToAllTabsAction = collection->add<KToggleAction>(QStringLiteral("copy-input-to-all-tabs"));
     copyInputToAllTabsAction->setText(i18n("&All Tabs in Current Window"));
     copyInputToAllTabsAction->setData(CopyInputToAllTabsMode);
     // this action is also used in other place, so remember it
     _copyInputToAllTabsAction = copyInputToAllTabsAction;
 
     // Copy input to ==> selected tabs
     KToggleAction* copyInputToSelectedTabsAction = collection->add<KToggleAction>(QStringLiteral("copy-input-to-selected-tabs"));
     copyInputToSelectedTabsAction->setText(i18n("&Select Tabs..."));
     collection->setDefaultShortcut(copyInputToSelectedTabsAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_Period);
     copyInputToSelectedTabsAction->setData(CopyInputToSelectedTabsMode);
 
     // Copy input to ==> none
     KToggleAction* copyInputToNoneAction = collection->add<KToggleAction>(QStringLiteral("copy-input-to-none"));
     copyInputToNoneAction->setText(i18nc("@action:inmenu Do not select any tabs", "&None"));
     collection->setDefaultShortcut(copyInputToNoneAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_Slash);
     copyInputToNoneAction->setData(CopyInputToNoneMode);
     copyInputToNoneAction->setChecked(true); // the default state
 
     // The "Copy Input To" submenu
     // The above three choices are represented as combo boxes
     KSelectAction* copyInputActions = collection->add<KSelectAction>(QStringLiteral("copy-input-to"));
     copyInputActions->setText(i18n("Copy Input To"));
     copyInputActions->addAction(copyInputToAllTabsAction);
     copyInputActions->addAction(copyInputToSelectedTabsAction);
     copyInputActions->addAction(copyInputToNoneAction);
     connect(copyInputActions, static_cast<void(KSelectAction::*)(QAction*)>(&KSelectAction::triggered), this, &Konsole::SessionController::copyInputActionsTriggered);
 
     action = collection->addAction(QStringLiteral("zmodem-upload"), this, SLOT(zmodemUpload()));
     action->setText(i18n("&ZModem Upload..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("document-open")));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::ALT + Qt::Key_U);
 
     // Monitor
     KToggleAction* toggleAction = new KToggleAction(i18n("Monitor for &Activity"), this);
     collection->setDefaultShortcut(toggleAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_A);
     action = collection->addAction(QStringLiteral("monitor-activity"), toggleAction);
     connect(action, &QAction::toggled, this, &Konsole::SessionController::monitorActivity);
 
     toggleAction = new KToggleAction(i18n("Monitor for &Silence"), this);
     collection->setDefaultShortcut(toggleAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_I);
     action = collection->addAction(QStringLiteral("monitor-silence"), toggleAction);
     connect(action, &QAction::toggled, this, &Konsole::SessionController::monitorSilence);
 
     // Text Size
     action = collection->addAction(QStringLiteral("enlarge-font"), this, SLOT(increaseFontSize()));
     action->setText(i18n("Enlarge Font"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("format-font-size-more")));
     QList<QKeySequence> enlargeFontShortcut;
     enlargeFontShortcut.append(QKeySequence(Konsole::ACCEL + Qt::Key_Plus));
     enlargeFontShortcut.append(QKeySequence(Konsole::ACCEL + Qt::Key_Equal));
     collection->setDefaultShortcuts(action, enlargeFontShortcut);
 
     action = collection->addAction(QStringLiteral("shrink-font"), this, SLOT(decreaseFontSize()));
     action->setText(i18n("Shrink Font"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("format-font-size-less")));
     collection->setDefaultShortcut(action, Konsole::ACCEL + Qt::Key_Minus);
 
 
     // Send signal
     KSelectAction* sendSignalActions = collection->add<KSelectAction>(QStringLiteral("send-signal"));
     sendSignalActions->setText(i18n("Send Signal"));
     connect(sendSignalActions, static_cast<void(KSelectAction::*)(QAction*)>(&KSelectAction::triggered), this, &Konsole::SessionController::sendSignal);
 
     action = collection->addAction(QStringLiteral("sigstop-signal"));
     action->setText(i18n("&Suspend Task")   + QStringLiteral(" (STOP)"));
     action->setData(SIGSTOP);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigcont-signal"));
     action->setText(i18n("&Continue Task")  + QStringLiteral(" (CONT)"));
     action->setData(SIGCONT);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sighup-signal"));
     action->setText(i18n("&Hangup")         + QStringLiteral(" (HUP)"));
     action->setData(SIGHUP);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigint-signal"));
     action->setText(i18n("&Interrupt Task") + QStringLiteral(" (INT)"));
     action->setData(SIGINT);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigterm-signal"));
     action->setText(i18n("&Terminate Task") + QStringLiteral(" (TERM)"));
     action->setData(SIGTERM);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigkill-signal"));
     action->setText(i18n("&Kill Task")      + QStringLiteral(" (KILL)"));
     action->setData(SIGKILL);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigusr1-signal"));
     action->setText(i18n("User Signal &1")   + QStringLiteral(" (USR1)"));
     action->setData(SIGUSR1);
     sendSignalActions->addAction(action);
 
     action = collection->addAction(QStringLiteral("sigusr2-signal"));
     action->setText(i18n("User Signal &2")   + QStringLiteral(" (USR2)"));
     action->setData(SIGUSR2);
     sendSignalActions->addAction(action);
 
 #ifdef Q_OS_MACOS
     collection->setDefaultShortcut(_findAction, Qt::META + Qt::Key_F);
     collection->setDefaultShortcut(_findNextAction, Qt::META + Qt::Key_G);
     collection->setDefaultShortcut(_findPreviousAction, Qt::META + Qt::SHIFT + Qt::Key_G);
 #else
     collection->setDefaultShortcut(_findAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_F);
     collection->setDefaultShortcut(_findNextAction, Qt::Key_F3);
     collection->setDefaultShortcut(_findPreviousAction, Qt::SHIFT + Qt::Key_F3);
 #endif
 }
 
 void SessionController::switchProfile(Profile::Ptr profile)
 {
     SessionManager::instance()->setSessionProfile(_session, profile);
     updateFilterList(profile);
 }
 
 void SessionController::prepareSwitchProfileMenu()
 {
     if (_switchProfileMenu->menu()->isEmpty()) {
         _profileList = new ProfileList(false, this);
         connect(_profileList, &Konsole::ProfileList::profileSelected, this, &Konsole::SessionController::switchProfile);
     }
 
     _switchProfileMenu->menu()->clear();
     _switchProfileMenu->menu()->addActions(_profileList->actions());
 }
 void SessionController::updateCodecAction()
 {
     _codecAction->setCurrentCodec(QString::fromUtf8(_session->codec()));
 }
 
 void SessionController::changeCodec(QTextCodec* codec)
 {
     _session->setCodec(codec);
 }
 
 EditProfileDialog* SessionController::profileDialogPointer()
 {
     return _editProfileDialog.data();
 }
 
 void SessionController::editCurrentProfile()
 {
     // Searching for Edit profile dialog opened with the same profile
     const QList<SessionController*> allSessionsControllers = _allControllers.values();
     foreach (SessionController* session, allSessionsControllers) {
         if ((session->profileDialogPointer() != nullptr)
                 && session->profileDialogPointer()->isVisible()
                 && session->profileDialogPointer()->lookupProfile() == SessionManager::instance()->sessionProfile(_session)) {
             session->profileDialogPointer()->close();
         }
     }
 
     // NOTE bug311270: For to prevent the crash, the profile must be reset.
     if (!_editProfileDialog.isNull()) {
         // exists but not visible
         delete _editProfileDialog.data();
     }
 
     _editProfileDialog = new EditProfileDialog(QApplication::activeWindow());
     _editProfileDialog.data()->setProfile(SessionManager::instance()->sessionProfile(_session));
     _editProfileDialog.data()->show();
 }
 
 void SessionController::renameSession()
 {
     const QString &sessionLocalTabTitleFormat = _session->tabTitleFormat(Session::LocalTabTitle);
     const QString &sessionRemoteTabTitleFormat = _session->tabTitleFormat(Session::RemoteTabTitle);
 
     QScopedPointer<RenameTabDialog> dialog(new RenameTabDialog(QApplication::activeWindow()));
     dialog->setTabTitleText(sessionLocalTabTitleFormat);
     dialog->setRemoteTabTitleText(sessionRemoteTabTitleFormat);
 
     if (_session->isRemote()) {
         dialog->focusRemoteTabTitleText();
     } else {
         dialog->focusTabTitleText();
     }
 
     QPointer<Session> guard(_session);
     int result = dialog->exec();
     if (guard.isNull()) {
         return;
     }
 
     if (result != 0) {
         const QString &tabTitle = dialog->tabTitleText();
         const QString &remoteTabTitle = dialog->remoteTabTitleText();
 
         if (tabTitle != sessionLocalTabTitleFormat) {
             _session->setTabTitleFormat(Session::LocalTabTitle, tabTitle);
             emit tabRenamedByUser(true);
             // trigger an update of the tab text
             snapshot();
         }
 
         if(remoteTabTitle != sessionRemoteTabTitleFormat) {
             _session->setTabTitleFormat(Session::RemoteTabTitle, remoteTabTitle);
             emit tabRenamedByUser(true);
             snapshot();
         }
     }
 }
 
 bool SessionController::confirmClose() const
 {
     if (_session->isForegroundProcessActive()) {
         QString title = _session->foregroundProcessName();
 
         // hard coded for now.  In future make it possible for the user to specify which programs
         // are ignored when considering whether to display a confirmation
         QStringList ignoreList;
         ignoreList << QString::fromUtf8(qgetenv("SHELL")).section(QLatin1Char('/'), -1);
         if (ignoreList.contains(title)) {
             return true;
         }
 
         QString question;
         if (title.isEmpty()) {
             question = i18n("A program is currently running in this session."
                             "  Are you sure you want to close it?");
         } else {
             question = i18n("The program '%1' is currently running in this session."
                             "  Are you sure you want to close it?", title);
         }
 
         int result = KMessageBox::warningYesNo(_view->window(), question, i18n("Confirm Close"));
         return result == KMessageBox::Yes;
     }
     return true;
 }
 bool SessionController::confirmForceClose() const
 {
     if (_session->isRunning()) {
         QString title = _session->program();
 
         // hard coded for now.  In future make it possible for the user to specify which programs
         // are ignored when considering whether to display a confirmation
         QStringList ignoreList;
         ignoreList << QString::fromUtf8(qgetenv("SHELL")).section(QLatin1Char('/'), -1);
         if (ignoreList.contains(title)) {
             return true;
         }
 
         QString question;
         if (title.isEmpty()) {
             question = i18n("A program in this session would not die."
                             "  Are you sure you want to kill it by force?");
         } else {
             question = i18n("The program '%1' is in this session would not die."
                             "  Are you sure you want to kill it by force?", title);
         }
 
         int result = KMessageBox::warningYesNo(_view->window(), question, i18n("Confirm Close"));
         return result == KMessageBox::Yes;
     }
     return true;
 }
 void SessionController::closeSession()
 {
     if (_preventClose) {
         return;
     }
 
     if (confirmClose()) {
         if (_session->closeInNormalWay()) {
             return;
         } else if (confirmForceClose()) {
             if (_session->closeInForceWay()) {
                 return;
             } else {
                 qCDebug(KonsoleDebug) << "Konsole failed to close a session in any way.";
             }
         }
     }
 }
 
 // Trying to open a remote Url may produce unexpected results.
 // Therefore, if a remote url, open the user's home path.
 // TODO consider: 1) disable menu upon remote session
 //   2) transform url to get the desired result (ssh -> sftp, etc)
 void SessionController::openBrowser()
 {
     const QUrl currentUrl = url();
 
     if (currentUrl.isLocalFile()) {
         new KRun(currentUrl, QApplication::activeWindow(), true);
     } else {
         new KRun(QUrl::fromLocalFile(QDir::homePath()), QApplication::activeWindow(), true);
     }
 }
 
 void SessionController::copy()
 {
     _view->copyToClipboard();
 }
 
 void SessionController::paste()
 {
     _view->pasteFromClipboard();
 }
 void SessionController::pasteFromX11Selection()
 {
     _view->pasteFromX11Selection();
 }
 void SessionController::selectAll()
 {
     _view->selectAll();
 }
 void SessionController::selectLine()
 {
     _view->selectCurrentLine();
 }
 static const KXmlGuiWindow* findWindow(const QObject* object)
 {
     // Walk up the QObject hierarchy to find a KXmlGuiWindow.
     while (object != nullptr) {
         const KXmlGuiWindow* window = qobject_cast<const KXmlGuiWindow*>(object);
         if (window != nullptr) {
             return(window);
         }
         object = object->parent();
     }
     return(nullptr);
 }
 
 static bool hasTerminalDisplayInSameWindow(const Session* session, const KXmlGuiWindow* window)
 {
     // Iterate all TerminalDisplays of this Session ...
     foreach(const TerminalDisplay* terminalDisplay, session->views()) {
         // ... and check whether a TerminalDisplay has the same
         // window as given in the parameter
         if (window == findWindow(terminalDisplay)) {
             return(true);
         }
     }
     return(false);
 }
 
 void SessionController::copyInputActionsTriggered(QAction* action)
 {
     const int mode = action->data().value<int>();
 
     switch (mode) {
     case CopyInputToAllTabsMode:
         copyInputToAllTabs();
         break;
     case CopyInputToSelectedTabsMode:
         copyInputToSelectedTabs();
         break;
     case CopyInputToNoneMode:
         copyInputToNone();
         break;
     default:
         Q_ASSERT(false);
     }
 }
 
 void SessionController::copyInputToAllTabs()
 {
     if (_copyToGroup == nullptr) {
         _copyToGroup = new SessionGroup(this);
     }
 
     // Find our window ...
     const KXmlGuiWindow* myWindow = findWindow(_view);
 
     QSet<Session*> group =
         QSet<Session*>::fromList(SessionManager::instance()->sessions());
     for (auto session : group) {
         // First, ensure that the session is removed
         // (necessary to avoid duplicates on addSession()!)
         _copyToGroup->removeSession(session);
 
         // Add current session if it is displayed our window
         if (hasTerminalDisplayInSameWindow(session, myWindow)) {
             _copyToGroup->addSession(session);
         }
     }
     _copyToGroup->setMasterStatus(_session, true);
     _copyToGroup->setMasterMode(SessionGroup::CopyInputToAll);
 
     snapshot();
 }
 
 void SessionController::copyInputToSelectedTabs()
 {
     if (_copyToGroup == nullptr) {
         _copyToGroup = new SessionGroup(this);
         _copyToGroup->addSession(_session);
         _copyToGroup->setMasterStatus(_session, true);
         _copyToGroup->setMasterMode(SessionGroup::CopyInputToAll);
     }
 
     QPointer<CopyInputDialog> dialog = new CopyInputDialog(_view);
     dialog->setMasterSession(_session);
 
     QSet<Session*> currentGroup = QSet<Session*>::fromList(_copyToGroup->sessions());
     currentGroup.remove(_session);
 
     dialog->setChosenSessions(currentGroup);
 
     QPointer<Session> guard(_session);
     int result = dialog->exec();
     if (guard.isNull()) {
         return;
     }
 
     if (result == QDialog::Accepted) {
         QSet<Session*> newGroup = dialog->chosenSessions();
         newGroup.remove(_session);
 
         QSet<Session*> completeGroup = newGroup | currentGroup;
         foreach(Session * session, completeGroup) {
             if (newGroup.contains(session) && !currentGroup.contains(session)) {
                 _copyToGroup->addSession(session);
             } else if (!newGroup.contains(session) && currentGroup.contains(session)) {
                 _copyToGroup->removeSession(session);
             }
         }
 
         _copyToGroup->setMasterStatus(_session, true);
         _copyToGroup->setMasterMode(SessionGroup::CopyInputToAll);
         snapshot();
     }
 }
 
 void SessionController::copyInputToNone()
 {
     if (_copyToGroup == nullptr) {      // No 'Copy To' is active
         return;
     }
 
     QSet<Session*> group =
         QSet<Session*>::fromList(SessionManager::instance()->sessions());
     for (auto iterator : group) {
         Session* session = iterator;
 
         if (session != _session) {
             _copyToGroup->removeSession(iterator);
         }
     }
     delete _copyToGroup;
     _copyToGroup = nullptr;
     snapshot();
 }
 
 void SessionController::searchClosed()
 {
     _isSearchBarEnabled = false;
     searchHistory(false);
 }
 
 void SessionController::updateFilterList(Profile::Ptr profile)
 {
     if (profile != SessionManager::instance()->sessionProfile(_session)) {
         return;
     }
 
     bool underlineFiles = profile->underlineFilesEnabled();
 
     if (!underlineFiles && (_fileFilter != nullptr)) {
         _view->filterChain()->removeFilter(_fileFilter);
         delete _fileFilter;
         _fileFilter = nullptr;
     } else if (underlineFiles && (_fileFilter == nullptr)) {
         _fileFilter = new FileFilter(_session);
         _view->filterChain()->addFilter(_fileFilter);
     }
 
     bool underlineLinks = profile->underlineLinksEnabled();
     if (!underlineLinks && (_urlFilter != nullptr)) {
         _view->filterChain()->removeFilter(_urlFilter);
         delete _urlFilter;
         _urlFilter = nullptr;
     } else if (underlineLinks && (_urlFilter == nullptr)) {
         _urlFilter = new UrlFilter();
         _view->filterChain()->addFilter(_urlFilter);
     }
 }
 
 void SessionController::setSearchStartToWindowCurrentLine()
 {
     setSearchStartTo(-1);
 }
 
 void SessionController::setSearchStartTo(int line)
 {
     _searchStartLine = line;
     _prevSearchResultLine = line;
 }
 
 void SessionController::listenForScreenWindowUpdates()
 {
     if (_listenForScreenWindowUpdates) {
         return;
     }
 
     connect(_view->screenWindow(), &Konsole::ScreenWindow::outputChanged, this, &Konsole::SessionController::updateSearchFilter);
     connect(_view->screenWindow(), &Konsole::ScreenWindow::scrolled, this, &Konsole::SessionController::updateSearchFilter);
     connect(_view->screenWindow(), &Konsole::ScreenWindow::currentResultLineChanged, _view.data(), static_cast<void(TerminalDisplay::*)()>(&Konsole::TerminalDisplay::update));
 
     _listenForScreenWindowUpdates = true;
 }
 
 void SessionController::updateSearchFilter()
 {
     if ((_searchFilter != nullptr) && (!_searchBar.isNull())) {
         _view->processFilters();
     }
 }
 
 void SessionController::searchBarEvent()
 {
     QString selectedText = _view->screenWindow()->selectedText(Screen::PreserveLineBreaks | Screen::TrimLeadingWhitespace | Screen::TrimTrailingWhitespace);
     if (!selectedText.isEmpty()) {
         _searchBar->setSearchText(selectedText);
     }
 
     if (_searchBar->isVisible()) {
         _searchBar->focusLineEdit();
     } else {
         searchHistory(true);
         _isSearchBarEnabled = true;
     }
 }
 
 void SessionController::enableSearchBar(bool showSearchBar)
 {
     if (_searchBar.isNull()) {
         return;
     }
 
     if (showSearchBar && !_searchBar->isVisible()) {
         setSearchStartToWindowCurrentLine();
     }
 
     _searchBar->setVisible(showSearchBar);
     if (showSearchBar) {
         connect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchChanged, this, &Konsole::SessionController::searchTextChanged);
         connect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchReturnPressed, this, &Konsole::SessionController::findPreviousInHistory);
         connect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchShiftPlusReturnPressed, this, &Konsole::SessionController::findNextInHistory);
     } else {
         disconnect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchChanged, this,
                    &Konsole::SessionController::searchTextChanged);
         disconnect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchReturnPressed, this,
                    &Konsole::SessionController::findPreviousInHistory);
         disconnect(_searchBar.data(), &Konsole::IncrementalSearchBar::searchShiftPlusReturnPressed, this,
                    &Konsole::SessionController::findNextInHistory);
         if ((!_view.isNull()) && (_view->screenWindow() != nullptr)) {
             _view->screenWindow()->setCurrentResultLine(-1);
         }
     }
 }
 
 
 bool SessionController::reverseSearchChecked() const
 {
     Q_ASSERT(_searchBar);
 
     QBitArray options = _searchBar->optionsChecked();
     return options.at(IncrementalSearchBar::ReverseSearch);
 }
 
 QRegularExpression SessionController::regexpFromSearchBarOptions() const
 {
     QBitArray options = _searchBar->optionsChecked();
 
     QString text(_searchBar->searchText());
 
     QRegularExpression regExp;
     if (options.at(IncrementalSearchBar::RegExp)) {
         regExp.setPattern(text);
     } else {
         regExp.setPattern(QRegularExpression::escape(text));
     }
 
     if (!options.at(IncrementalSearchBar::MatchCase)) {
         regExp.setPatternOptions(QRegularExpression::CaseInsensitiveOption);
     }
 
     return regExp;
 }
 
 // searchHistory() may be called either as a result of clicking a menu item or
 // as a result of changing the search bar widget
 void SessionController::searchHistory(bool showSearchBar)
 {
     enableSearchBar(showSearchBar);
 
     if (!_searchBar.isNull()) {
         if (showSearchBar) {
             removeSearchFilter();
 
             listenForScreenWindowUpdates();
 
             _searchFilter = new RegExpFilter();
             _searchFilter->setRegExp(regexpFromSearchBarOptions());
             _view->filterChain()->addFilter(_searchFilter);
             _view->processFilters();
 
             setFindNextPrevEnabled(true);
         } else {
             setFindNextPrevEnabled(false);
 
             removeSearchFilter();
 
             _view->setFocus(Qt::ActiveWindowFocusReason);
         }
     }
 }
 
 void SessionController::setFindNextPrevEnabled(bool enabled)
 {
     _findNextAction->setEnabled(enabled);
     _findPreviousAction->setEnabled(enabled);
 }
 void SessionController::searchTextChanged(const QString& text)
 {
     Q_ASSERT(_view->screenWindow());
 
     if (_searchText == text) {
         return;
     }
 
     _searchText = text;
 
     if (text.isEmpty()) {
         _view->screenWindow()->clearSelection();
         _view->screenWindow()->scrollTo(_searchStartLine);
     }
 
     // update search.  this is called even when the text is
     // empty to clear the view's filters
     beginSearch(text , reverseSearchChecked() ? Enum::BackwardsSearch : Enum::ForwardsSearch);
 }
 void SessionController::searchCompleted(bool success)
 {
     _prevSearchResultLine = _view->screenWindow()->currentResultLine();
 
     if (!_searchBar.isNull()) {
         _searchBar->setFoundMatch(success);
     }
 }
 
 void SessionController::beginSearch(const QString& text, Enum::SearchDirection direction)
 {
     Q_ASSERT(_searchBar);
     Q_ASSERT(_searchFilter);
 
     QRegularExpression regExp = regexpFromSearchBarOptions();
     _searchFilter->setRegExp(regExp);
 
     if (_searchStartLine < 0 || _searchStartLine > _view->screenWindow()->lineCount()) {
         if (direction == Enum::ForwardsSearch) {
             setSearchStartTo(_view->screenWindow()->currentLine());
         } else {
             setSearchStartTo(_view->screenWindow()->currentLine() + _view->screenWindow()->windowLines());
         }
     }
 
     if (!regExp.pattern().isEmpty()) {
         _view->screenWindow()->setCurrentResultLine(-1);
         auto task = new SearchHistoryTask(this);
 
         connect(task, &Konsole::SearchHistoryTask::completed, this, &Konsole::SessionController::searchCompleted);
 
         task->setRegExp(regExp);
         task->setSearchDirection(direction);
         task->setAutoDelete(true);
         task->setStartLine(_searchStartLine);
         task->addScreenWindow(_session , _view->screenWindow());
         task->execute();
     } else if (text.isEmpty()) {
         searchCompleted(false);
     }
 
     _view->processFilters();
 }
 void SessionController::highlightMatches(bool highlight)
 {
     if (highlight) {
         _view->filterChain()->addFilter(_searchFilter);
         _view->processFilters();
     } else {
         _view->filterChain()->removeFilter(_searchFilter);
     }
 
     _view->update();
 }
 
 void SessionController::searchFrom()
 {
     Q_ASSERT(_searchBar);
     Q_ASSERT(_searchFilter);
 
     if (reverseSearchChecked()) {
         setSearchStartTo(_view->screenWindow()->lineCount());
     } else {
         setSearchStartTo(0);
     }
 
 
     beginSearch(_searchBar->searchText(), reverseSearchChecked() ? Enum::BackwardsSearch : Enum::ForwardsSearch);
 }
 void SessionController::findNextInHistory()
 {
     Q_ASSERT(_searchBar);
     Q_ASSERT(_searchFilter);
 
     setSearchStartTo(_prevSearchResultLine);
 
     beginSearch(_searchBar->searchText(), reverseSearchChecked() ? Enum::BackwardsSearch : Enum::ForwardsSearch);
 }
 void SessionController::findPreviousInHistory()
 {
     Q_ASSERT(_searchBar);
     Q_ASSERT(_searchFilter);
 
     setSearchStartTo(_prevSearchResultLine);
 
     beginSearch(_searchBar->searchText(), reverseSearchChecked() ? Enum::ForwardsSearch : Enum::BackwardsSearch);
 }
 void SessionController::changeSearchMatch()
 {
     Q_ASSERT(_searchBar);
     Q_ASSERT(_searchFilter);
 
     // reset Selection for new case match
     _view->screenWindow()->clearSelection();
     beginSearch(_searchBar->searchText(), reverseSearchChecked() ? Enum::BackwardsSearch : Enum::ForwardsSearch);
 }
 void SessionController::showHistoryOptions()
 {
     QScopedPointer<HistorySizeDialog> dialog(new HistorySizeDialog(QApplication::activeWindow()));
     const HistoryType& currentHistory = _session->historyType();
 
     if (currentHistory.isEnabled()) {
         if (currentHistory.isUnlimited()) {
             dialog->setMode(Enum::UnlimitedHistory);
         } else {
             dialog->setMode(Enum::FixedSizeHistory);
             dialog->setLineCount(currentHistory.maximumLineCount());
         }
     } else {
         dialog->setMode(Enum::NoHistory);
     }
 
     QPointer<Session> guard(_session);
     int result = dialog->exec();
     if (guard.isNull()) {
         return;
     }
 
     if (result != 0) {
         scrollBackOptionsChanged(dialog->mode(), dialog->lineCount());
     }
 }
 void SessionController::sessionResizeRequest(const QSize& size)
 {
     ////qDebug() << "View resize requested to " << size;
     _view->setSize(size.width(), size.height());
 }
 void SessionController::scrollBackOptionsChanged(int mode, int lines)
 {
     switch (mode) {
     case Enum::NoHistory:
         _session->setHistoryType(HistoryTypeNone());
         break;
     case Enum::FixedSizeHistory:
         _session->setHistoryType(CompactHistoryType(lines));
         break;
     case Enum::UnlimitedHistory:
         _session->setHistoryType(HistoryTypeFile());
         break;
     }
 }
 
 void SessionController::print_screen()
 {
     QPrinter printer;
 
     QPointer<QPrintDialog> dialog = new QPrintDialog(&printer, _view);
     auto options = new PrintOptions();
 
     dialog->setOptionTabs(QList<QWidget*>() << options);
     dialog->setWindowTitle(i18n("Print Shell"));
     connect(dialog.data(), static_cast<void(QPrintDialog::*)()>(&QPrintDialog::accepted), options, &Konsole::PrintOptions::saveSettings);
     if (dialog->exec() != QDialog::Accepted) {
         return;
     }
 
     QPainter painter;
     painter.begin(&printer);
 
     KConfigGroup configGroup(KSharedConfig::openConfig(), "PrintOptions");
 
     if (configGroup.readEntry("ScaleOutput", true)) {
         double scale = qMin(printer.pageRect().width() / static_cast<double>(_view->width()),
                             printer.pageRect().height() / static_cast<double>(_view->height()));
         painter.scale(scale, scale);
     }
 
     _view->printContent(painter, configGroup.readEntry("PrinterFriendly", true));
 }
 
 void SessionController::saveHistory()
 {
     SessionTask* task = new SaveHistoryTask(this);
     task->setAutoDelete(true);
     task->addSession(_session);
     task->execute();
 }
 
 void SessionController::clearHistory()
 {
     _session->clearHistory();
     _view->updateImage();   // To reset view scrollbar
     _view->repaint();
 }
 
 void SessionController::clearHistoryAndReset()
 {
     Profile::Ptr profile = SessionManager::instance()->sessionProfile(_session);
     QByteArray name = profile->defaultEncoding().toUtf8();
 
     Emulation* emulation = _session->emulation();
     emulation->reset();
     _session->refresh();
     _session->setCodec(QTextCodec::codecForName(name));
     clearHistory();
 }
 
 void SessionController::increaseFontSize()
 {
     _view->increaseFontSize();
 }
 
 void SessionController::decreaseFontSize()
 {
     _view->decreaseFontSize();
 }
 
 void SessionController::monitorActivity(bool monitor)
 {
     _session->setMonitorActivity(monitor);
 }
 void SessionController::monitorSilence(bool monitor)
 {
     _session->setMonitorSilence(monitor);
 }
 void SessionController::updateSessionIcon()
 {
     // Visualize that the session is broadcasting to others
     if ((_copyToGroup != nullptr) && _copyToGroup->sessions().count() > 1) {
         // Master Mode: set different icon, to warn the user to be careful
         setIcon(*_broadcastIcon);
     } else {
         if (!_keepIconUntilInteraction) {
             // Not in Master Mode: use normal icon
             setIcon(_sessionIcon);
         }
     }
 }
 
 void SessionController::updateReadOnlyActionStates()
 {
     bool readonly = isReadOnly();
     QAction *readonlyAction = actionCollection()->action(QStringLiteral("view-readonly"));
     Q_ASSERT(readonlyAction != nullptr);
     readonlyAction->setIcon(QIcon::fromTheme(readonly ? QStringLiteral("object-locked") : QStringLiteral("object-unlocked")));
     readonlyAction->setChecked(readonly);
 
     auto updateActionState = [this, readonly](const QString &name) {
         QAction *action = actionCollection()->action(name);
         if (action != nullptr) {
             action->setEnabled(!readonly);
         }
     };
 
     updateActionState(QStringLiteral("edit_paste"));
     updateActionState(QStringLiteral("clear-history"));
     updateActionState(QStringLiteral("clear-history-and-reset"));
     updateActionState(QStringLiteral("edit-current-profile"));
     updateActionState(QStringLiteral("switch-profile"));
     updateActionState(QStringLiteral("adjust-history"));
     updateActionState(QStringLiteral("send-signal"));
     updateActionState(QStringLiteral("zmodem-upload"));
 
     _codecAction->setEnabled(!readonly);
 
     // Without the timer, when detaching a tab while the message widget is visible,
     // the size of the terminal becomes really small...
     QTimer::singleShot(0, this, [this, readonly]() {
         _view->updateReadOnlyState(readonly);
     });
 }
 
 bool SessionController::isReadOnly() const
 {
     if (!_session.isNull()) {
         return _session->isReadOnly();
     } else {
         return false;
     }
 }
 
 void SessionController::sessionAttributeChanged()
 {
     if (_sessionIconName != _session->iconName()) {
         _sessionIconName = _session->iconName();
         _sessionIcon = QIcon::fromTheme(_sessionIconName);
         updateSessionIcon();
     }
 
     QString title = _session->title(Session::DisplayedTitleRole);
 
     // special handling for the "%w" marker which is replaced with the
     // window title set by the shell
     title.replace(QLatin1String("%w"), _session->userTitle());
     // special handling for the "%#" marker which is replaced with the
     // number of the shell
     title.replace(QLatin1String("%#"), QString::number(_session->sessionId()));
 
     if (title.isEmpty()) {
         title = _session->title(Session::NameRole);
     }
 
     setTitle(title);
     emit rawTitleChanged();
 }
 
 void SessionController::sessionReadOnlyChanged() {
     // Trigger icon update
     sessionAttributeChanged();
 
     updateReadOnlyActionStates();
 
     // Update all views
     for (TerminalDisplay* view : session()->views()) {
         if (view != _view.data()) {
             view->updateReadOnlyState(isReadOnly());
         }
     }
 }
 
 void SessionController::showDisplayContextMenu(const QPoint& position)
 {
     // needed to make sure the popup menu is available, even if a hosting
     // application did not merge our GUI.
     if (factory() == nullptr) {
         if (clientBuilder() == nullptr) {
             setClientBuilder(new KXMLGUIBuilder(_view));
         }
 
         auto factory = new KXMLGUIFactory(clientBuilder(), this);
         factory->addClient(this);
         ////qDebug() << "Created xmlgui factory" << factory;
     }
 
     QPointer<QMenu> popup = qobject_cast<QMenu*>(factory()->container(QStringLiteral("session-popup-menu"), this));
     if (!popup.isNull()) {
         updateReadOnlyActionStates();
 
         // prepend content-specific actions such as "Open Link", "Copy Email Address" etc.
         QList<QAction*> contentActions = _view->filterActions(position);
         auto contentSeparator = new QAction(popup);
         contentSeparator->setSeparator(true);
         contentActions << contentSeparator;
         popup->insertActions(popup->actions().value(0, nullptr), contentActions);
 
         // always update this submenu before showing the context menu,
         // because the available search services might have changed
         // since the context menu is shown last time
         updateWebSearchMenu();
 
         _preventClose = true;
 
         if (_showMenuAction != nullptr) {
             if (  _showMenuAction->isChecked() ) {
                 popup->removeAction( _showMenuAction);
             } else {
                 popup->insertAction(_switchProfileMenu, _showMenuAction);
             }
         }
 
         QAction* chosen = popup->exec(_view->mapToGlobal(position));
 
         // check for validity of the pointer to the popup menu
         if (!popup.isNull()) {
             // Remove content-specific actions
             //
             // If the close action was chosen, the popup menu will be partially
             // destroyed at this point, and the rest will be destroyed later by
             // 'chosen->trigger()'
             foreach(QAction * action, contentActions) {
                 popup->removeAction(action);
             }
 
             delete contentSeparator;
         }
 
         _preventClose = false;
 
         if ((chosen != nullptr) && chosen->objectName() == QLatin1String("close-session")) {
             chosen->trigger();
         }
     } else {
         qCDebug(KonsoleDebug) << "Unable to display popup menu for session"
                    << _session->title(Session::NameRole)
                    << ", no GUI factory available to build the popup.";
     }
 }
 
 void SessionController::movementKeyFromSearchBarReceived(QKeyEvent *event)
 {
     QCoreApplication::sendEvent(_view, event);
     setSearchStartToWindowCurrentLine();
 }
 
 void SessionController::sessionStateChanged(int state)
 {
     if (state == _previousState) {
         return;
     }
 
     if (state == NOTIFYACTIVITY) {
         setIcon(*_activityIcon);
         _keepIconUntilInteraction = true;
     } else if (state == NOTIFYSILENCE) {
         setIcon(*_silenceIcon);
         _keepIconUntilInteraction = true;
     } else if (state == NOTIFYNORMAL) {
         if (_sessionIconName != _session->iconName()) {
             _sessionIconName = _session->iconName();
             _sessionIcon = QIcon::fromTheme(_sessionIconName);
         }
 
         updateSessionIcon();
     }
 
     _previousState = state;
 }
 
 void SessionController::zmodemDownload()
 {
     QString zmodem = QStandardPaths::findExecutable(QStringLiteral("rz"));
     if (zmodem.isEmpty()) {
         zmodem = QStandardPaths::findExecutable(QStringLiteral("lrz"));
     }
     if (!zmodem.isEmpty()) {
         const QString path = QFileDialog::getExistingDirectory(_view,
                 i18n("Save ZModem Download to..."),
                 QDir::homePath(),
                 QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
 
         if (!path.isEmpty()) {
             _session->startZModem(zmodem, path, QStringList());
             return;
         }
     } else {
         KMessageBox::error(_view,
                            i18n("<p>A ZModem file transfer attempt has been detected, "
                                 "but no suitable ZModem software was found on this system.</p>"
                                 "<p>You may wish to install the 'rzsz' or 'lrzsz' package.</p>"));
     }
     _session->cancelZModem();
     return;
 }
 
 void SessionController::zmodemUpload()
 {
     if (_session->isZModemBusy()) {
         KMessageBox::sorry(_view,
                            i18n("<p>The current session already has a ZModem file transfer in progress.</p>"));
         return;
     }
     _session->setZModemBusy(true);
 
     QString zmodem = QStandardPaths::findExecutable(QStringLiteral("sz"));
     if (zmodem.isEmpty()) {
         zmodem = QStandardPaths::findExecutable(QStringLiteral("lsz"));
     }
     if (zmodem.isEmpty()) {
         KMessageBox::sorry(_view,
                            i18n("<p>No suitable ZModem software was found on this system.</p>"
                                 "<p>You may wish to install the 'rzsz' or 'lrzsz' package.</p>"));
         return;
     }
 
     QStringList files = QFileDialog::getOpenFileNames(_view,
                         i18n("Select Files for ZModem Upload"),
                         QDir::homePath());
     if (!files.isEmpty()) {
         _session->startZModem(zmodem, QString(), files);
     }
 }
 
 bool SessionController::isKonsolePart() const
 {
     // Check to see if we are being called from Konsole or a KPart
     return !(qApp->applicationName() == QLatin1String("konsole"));
 }
 
 SessionTask::SessionTask(QObject* parent)
     :  QObject(parent)
     ,  _autoDelete(false)
 {
 }
 void SessionTask::setAutoDelete(bool enable)
 {
     _autoDelete = enable;
 }
 bool SessionTask::autoDelete() const
 {
     return _autoDelete;
 }
 void SessionTask::addSession(Session* session)
 {
     _sessions << session;
 }
 QList<SessionPtr> SessionTask::sessions() const
 {
     return _sessions;
 }
 
 SaveHistoryTask::SaveHistoryTask(QObject* parent)
     : SessionTask(parent)
 {
 }
 SaveHistoryTask::~SaveHistoryTask() = default;
 
 void SaveHistoryTask::execute()
 {
     // TODO - think about the UI when saving multiple history sessions, if there are more than two or
     //        three then providing a URL for each one will be tedious
 
     // TODO - show a warning ( preferably passive ) if saving the history output fails
     QFileDialog* dialog = new QFileDialog(QApplication::activeWindow(),
             QString(),
             QDir::homePath());
     dialog->setAcceptMode(QFileDialog::AcceptSave);
 
     QStringList mimeTypes;
     mimeTypes << QStringLiteral("text/plain");
     mimeTypes << QStringLiteral("text/html");
     dialog->setMimeTypeFilters(mimeTypes);
 
     // iterate over each session in the task and display a dialog to allow the user to choose where
     // to save that session's history.
     // then start a KIO job to transfer the data from the history to the chosen URL
     foreach(const SessionPtr& session, sessions()) {
         dialog->setWindowTitle(i18n("Save Output From %1", session->title(Session::NameRole)));
 
         int result = dialog->exec();
 
         if (result != QDialog::Accepted) {
             continue;
         }
 
         QUrl url = (dialog->selectedUrls()).at(0);
 
         if (!url.isValid()) {
             // UI:  Can we make this friendlier?
             KMessageBox::sorry(nullptr , i18n("%1 is an invalid URL, the output could not be saved.", url.url()));
             continue;
         }
 
         KIO::TransferJob* job = KIO::put(url,
                                          -1,   // no special permissions
                                          // overwrite existing files
                                          // do not resume an existing transfer
                                          // show progress information only for remote
                                          // URLs
                                          KIO::Overwrite | (url.isLocalFile() ? KIO::HideProgressInfo : KIO::DefaultFlags)
                                          // a better solution would be to show progress
                                          // information after a certain period of time
                                          // instead, since the overall speed of transfer
                                          // depends on factors other than just the protocol
                                          // used
                                         );
 
         SaveJob jobInfo;
         jobInfo.session = session;
         jobInfo.lastLineFetched = -1;  // when each request for data comes in from the KIO subsystem
         // lastLineFetched is used to keep track of how much of the history
         // has already been sent, and where the next request should continue
         // from.
         // this is set to -1 to indicate the job has just been started
 
         if (((dialog->selectedNameFilter()).contains(QLatin1String("html"), Qt::CaseInsensitive)) ||
            ((dialog->selectedFiles()).at(0).endsWith(QLatin1String("html"), Qt::CaseInsensitive))) {
             jobInfo.decoder = new HTMLDecoder();
         } else {
             jobInfo.decoder = new PlainTextDecoder();
         }
 
         _jobSession.insert(job, jobInfo);
 
         connect(job, &KIO::TransferJob::dataReq, this, &Konsole::SaveHistoryTask::jobDataRequested);
         connect(job, &KIO::TransferJob::result, this, &Konsole::SaveHistoryTask::jobResult);
     }
 
     dialog->deleteLater();
 }
 void SaveHistoryTask::jobDataRequested(KIO::Job* job , QByteArray& data)
 {
     // TODO - Report progress information for the job
 
     // PERFORMANCE:  Do some tests and tweak this value to get faster saving
     const int LINES_PER_REQUEST = 500;
 
     SaveJob& info = _jobSession[job];
 
     // transfer LINES_PER_REQUEST lines from the session's history
     // to the save location
     if (!info.session.isNull()) {
         // note:  when retrieving lines from the emulation,
         // the first line is at index 0.
 
         int sessionLines = info.session->emulation()->lineCount();
 
         if (sessionLines - 1 == info.lastLineFetched) {
             return; // if there is no more data to transfer then stop the job
         }
 
         int copyUpToLine = qMin(info.lastLineFetched + LINES_PER_REQUEST ,
                                 sessionLines - 1);
 
         QTextStream stream(&data, QIODevice::ReadWrite);
         info.decoder->begin(&stream);
         info.session->emulation()->writeToStream(info.decoder , info.lastLineFetched + 1 , copyUpToLine);
         info.decoder->end();
 
         info.lastLineFetched = copyUpToLine;
     }
 }
 void SaveHistoryTask::jobResult(KJob* job)
 {
     if (job->error() != 0) {
         KMessageBox::sorry(nullptr , i18n("A problem occurred when saving the output.\n%1", job->errorString()));
     }
 
     TerminalCharacterDecoder * decoder = _jobSession[job].decoder;
 
     _jobSession.remove(job);
 
     delete decoder;
 
     // notify the world that the task is done
     emit completed(true);
 
     if (autoDelete()) {
         deleteLater();
     }
 }
 void SearchHistoryTask::addScreenWindow(Session* session , ScreenWindow* searchWindow)
 {
     _windows.insert(session, searchWindow);
 }
 void SearchHistoryTask::execute()
 {
     QMapIterator< SessionPtr , ScreenWindowPtr > iter(_windows);
 
     while (iter.hasNext()) {
         iter.next();
         executeOnScreenWindow(iter.key() , iter.value());
     }
 }
 
 void SearchHistoryTask::executeOnScreenWindow(SessionPtr session , ScreenWindowPtr window)
 {
     Q_ASSERT(session);
     Q_ASSERT(window);
 
     Emulation* emulation = session->emulation();
 
     if (!_regExp.pattern().isEmpty()) {
         int pos = -1;
         const bool forwards = (_direction == Enum::ForwardsSearch);
         const int lastLine = window->lineCount() - 1;
 
         int startLine;
         if (forwards && (_startLine == lastLine)) {
             startLine = 0;
         } else if (!forwards && (_startLine == 0)) {
             startLine = lastLine;
         } else {
             startLine = _startLine + (forwards ? 1 : -1);
         }
 
         QString string;
 
         //text stream to read history into string for pattern or regular expression searching
         QTextStream searchStream(&string);
 
         PlainTextDecoder decoder;
         decoder.setRecordLinePositions(true);
 
         //setup first and last lines depending on search direction
         int line = startLine;
 
         //read through and search history in blocks of 10K lines.
         //this balances the need to retrieve lots of data from the history each time
         //(for efficient searching)
         //without using silly amounts of memory if the history is very large.
         const int maxDelta = qMin(window->lineCount(), 10000);
         int delta = forwards ? maxDelta : -maxDelta;
 
         int endLine = line;
         bool hasWrapped = false;  // set to true when we reach the top/bottom
         // of the output and continue from the other
         // end
 
         //loop through history in blocks of <delta> lines.
         do {
             // ensure that application does not appear to hang
             // if searching through a lengthy output
             QApplication::processEvents();
 
             // calculate lines to search in this iteration
             if (hasWrapped) {
                 if (endLine == lastLine) {
                     line = 0;
                 } else if (endLine == 0) {
                     line = lastLine;
                 }
 
                 endLine += delta;
 
                 if (forwards) {
                     endLine = qMin(startLine , endLine);
                 } else {
                     endLine = qMax(startLine , endLine);
                 }
             } else {
                 endLine += delta;
 
                 if (endLine > lastLine) {
                     hasWrapped = true;
                     endLine = lastLine;
                 } else if (endLine < 0) {
                     hasWrapped = true;
                     endLine = 0;
                 }
             }
 
             decoder.begin(&searchStream);
             emulation->writeToStream(&decoder, qMin(endLine, line) , qMax(endLine, line));
             decoder.end();
 
             // line number search below assumes that the buffer ends with a new-line
             string.append(QLatin1Char('\n'));
 
             if (forwards) {
                 pos = string.indexOf(_regExp);
             } else {
                 pos = string.lastIndexOf(_regExp);
             }
 
             //if a match is found, position the cursor on that line and update the screen
             if (pos != -1) {
                 int newLines = 0;
                 QList<int> linePositions = decoder.linePositions();
                 while (newLines < linePositions.count() && linePositions[newLines] <= pos) {
                     newLines++;
                 }
 
                 // ignore the new line at the start of the buffer
                 newLines--;
 
                 int findPos = qMin(line, endLine) + newLines;
 
                 highlightResult(window, findPos);
 
                 emit completed(true);
 
                 return;
             }
 
             //clear the current block of text and move to the next one
             string.clear();
             line = endLine;
         } while (startLine != endLine);
 
         // if no match was found, clear selection to indicate this
         window->clearSelection();
         window->notifyOutputChanged();
     }
 
     emit completed(false);
 }
 void SearchHistoryTask::highlightResult(ScreenWindowPtr window , int findPos)
 {
     //work out how many lines into the current block of text the search result was found
     //- looks a little painful, but it only has to be done once per search.
 
     ////qDebug() << "Found result at line " << findPos;
 
     //update display to show area of history containing selection
     if ((findPos < window->currentLine()) ||
             (findPos >= (window->currentLine() + window->windowLines()))) {
         int centeredScrollPos = findPos - window->windowLines() / 2;
         if (centeredScrollPos < 0) {
             centeredScrollPos = 0;
         }
 
         window->scrollTo(centeredScrollPos);
     }
 
     window->setTrackOutput(false);
     window->notifyOutputChanged();
     window->setCurrentResultLine(findPos);
 }
 
 SearchHistoryTask::SearchHistoryTask(QObject* parent)
     : SessionTask(parent)
     , _direction(Enum::BackwardsSearch)
     , _startLine(0)
 {
 }
 void SearchHistoryTask::setSearchDirection(Enum::SearchDirection direction)
 {
     _direction = direction;
 }
 void SearchHistoryTask::setStartLine(int line)
 {
     _startLine = line;
 }
 Enum::SearchDirection SearchHistoryTask::searchDirection() const
 {
     return _direction;
 }
 void SearchHistoryTask::setRegExp(const QRegularExpression &expression)
 {
     _regExp = expression;
 }
 QRegularExpression SearchHistoryTask::regExp() const
 {
     return _regExp;
 }
 
 QString SessionController::userTitle() const
 {
     if (!_session.isNull()) {
         return _session->userTitle();
     } else {
         return QString();
     }
 }
 
diff --git a/src/TerminalDisplay.cpp b/src/TerminalDisplay.cpp
index 3c736196..256a57a4 100644
--- a/src/TerminalDisplay.cpp
+++ b/src/TerminalDisplay.cpp
@@ -1,3966 +1,3967 @@
 /*
     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>
 
 // Konsole
 #include "Filter.h"
 #include "konsoledebug.h"
 #include "konsole_wcwidth.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
     // enorgous 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);
 }
 
 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)
     , _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)
 {
     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.setPen(originalPen);
 }
 
 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 artefacts, 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
 
     int urlNumber = 0;
     QList<Filter::HotSpot*> spots = _filterChain->hotSpots();
     foreach(Filter::HotSpot* spot, spots) {
         urlNumber++;
 
         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 = konsole_wcwidth(_image[cursorLocation].character);
     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 continiously 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 continiously 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:
     if (tmp_image != nullptr) {
         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--;
         }
     }
     if (tmp_image != nullptr) {
         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 = string_width(_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 hintSelected = event->key() - 0x31;
         if (hintSelected >= 0 && hintSelected < 10 && hintSelected < _filterChain->hotSpots().count()) {
             _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);
         }
     }
 
     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();
         break;
     case Enum::NotifyBell:
         // STABLE API:
         //     Please note that these event names, "BellVisible" and "BellInvisible",
         //     should not change and should be kept stable, because other applications
         //     that use this code via KPart rely on these names for notifications.
         KNotification::event(hasFocus() ? QStringLiteral("BellVisible") : QStringLiteral("BellInvisible"),
                              message, QPixmap(), this);
         break;
     case Enum::VisualBell:
         visualBell();
         break;
     default:
         break;
     }
 
     // limit the rate at which bells can occur.
     // ...mainly for sound effects where rapid bells in sequence
     // produce a horrible noise.
     _bellMasked = true;
     QTimer::singleShot(500, [this]() {
         _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()
 {
     _dragInfo.state = diDragging;
     _dragInfo.dragObject = new QDrag(this);
     auto mimeData = new QMimeData();
     mimeData->setText(QApplication::clipboard()->mimeData(QClipboard::Selection)->text());
     mimeData->setHtml(QApplication::clipboard()->mimeData(QClipboard::Selection)->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/ViewContainer.cpp b/src/ViewContainer.cpp
index 37025a0d..3d280f72 100644
--- a/src/ViewContainer.cpp
+++ b/src/ViewContainer.cpp
@@ -1,832 +1,422 @@
 /*
     This file is part of the Konsole Terminal.
 
     Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "ViewContainer.h"
-
 #include <config-konsole.h>
 
 // Qt
-#include <QStackedWidget>
-#include <QToolButton>
-#include <QDrag>
-#include <QDragMoveEvent>
-#include <QMimeData>
-#include <QHBoxLayout>
-#include <QVBoxLayout>
+#include <QTabBar>
+#include <QMenu>
+#include <QFile>
+#include <QOperatingSystemVersion>
+#include <QMouseEvent>
 
 // KDE
 #include <KColorScheme>
 #include <KColorUtils>
 #include <KLocalizedString>
 #include <KActionCollection>
-#include <QMenu>
 
 // Konsole
 #include "IncrementalSearchBar.h"
 #include "ViewProperties.h"
-#include "ViewContainerTabBar.h"
 #include "ProfileList.h"
 #include "ViewManager.h"
 #include "KonsoleSettings.h"
 #include "SessionController.h"
+#include "DetachableTabBar.h"
 
 // TODO Perhaps move everything which is Konsole-specific into different files
 
 using namespace Konsole;
 
-ViewContainer::ViewContainer(NavigationPosition position, QObject *parent) :
-    QObject(parent),
-    _navigationVisibility(AlwaysShowNavigation),
-    _navigationPosition(position),
-    _views(QList<QWidget *>()),
-    _navigation(QHash<QWidget *, ViewProperties *>()),
-    _features(nullptr),
-    _searchBar(nullptr)
-{
-}
 
-ViewContainer::~ViewContainer()
+TabbedViewContainer::TabbedViewContainer(ViewManager *connectedViewManager, QWidget *parent) :
+    QTabWidget(parent),
+    _connectedViewManager(connectedViewManager),
+    _newTabButton(new QToolButton()),
+    _contextMenuTabIndex(-1)
 {
-    foreach (QWidget *view, _views) {
-        disconnect(view, &QWidget::destroyed, this, &Konsole::ViewContainer::viewDestroyed);
-    }
-
-    if (_searchBar != nullptr) {
-        _searchBar->deleteLater();
-    }
-
-    emit destroyed(this);
-}
+    auto tabBarWidget = new DetachableTabBar();
+    setTabBar(tabBarWidget);
+    setDocumentMode(true);
+    setMovable(true);
 
-void ViewContainer::moveViewWidget(int, int)
-{
-}
+    tabBar()->setContextMenuPolicy(Qt::CustomContextMenu);
 
-void ViewContainer::setFeatures(Features features)
-{
-    _features = features;
-}
-
-ViewContainer::Features ViewContainer::features() const
-{
-    return _features;
-}
+    _newTabButton->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
+    _newTabButton->setAutoRaise(true);
+    connect(_newTabButton, &QToolButton::clicked, this, [this]{
+        emit newViewRequest();
+    });
 
-void ViewContainer::moveActiveView(MoveDirection direction)
-{
-    const int currentIndex = _views.indexOf(activeView());
-    int newIndex = -1;
-
-    switch (direction) {
-    case MoveViewLeft:
-        newIndex = qMax(currentIndex - 1, 0);
-        break;
-    case MoveViewRight:
-        newIndex = qMin(currentIndex + 1, _views.count() - 1);
-        break;
-    }
+    connect(tabBar(), &QTabBar::tabCloseRequested,
+        this, &TabbedViewContainer::closeTerminalTab);
+    connect(tabBar(), &QTabBar::tabBarDoubleClicked, this,
+        &Konsole::TabbedViewContainer::tabDoubleClicked);
+    connect(tabBar(), &QTabBar::customContextMenuRequested, this,
+        &Konsole::TabbedViewContainer::openTabContextMenu);
+    connect(tabBarWidget, &DetachableTabBar::detachTab, this, [this](int idx) {
+        emit detachTab(this, widget(idx));
+    });
+    connect(this, &TabbedViewContainer::currentChanged, this, [this](int index) {
+        if (index != -1) {
+            widget(index)->setFocus();
+        }
+    });
 
-    Q_ASSERT(newIndex != -1);
+    // The context menu of tab bar
+    _contextPopupMenu = new QMenu(tabBar());
+    connect(_contextPopupMenu, &QMenu::aboutToHide, this, [this]() {
+        // Remove the read-only action when the popup closes
+        for (auto &action : _contextPopupMenu->actions()) {
+            if (action->objectName() == QStringLiteral("view-readonly")) {
+                _contextPopupMenu->removeAction(action);
+                break;
+            }
+        }
+    });
 
-    moveViewWidget(currentIndex, newIndex);
+    auto detachAction = _contextPopupMenu->addAction(
+        QIcon::fromTheme(QStringLiteral("tab-detach")),
+        i18nc("@action:inmenu", "&Detach Tab"), this,
+        [this] { emit detachTab(this, widget(_contextMenuTabIndex)); }
+    );
+    detachAction->setObjectName(QStringLiteral("tab-detach"));
+
+    auto editAction = _contextPopupMenu->addAction(
+        QIcon::fromTheme(QStringLiteral("edit-rename")),
+        i18nc("@action:inmenu", "&Rename Tab..."), this,
+        [this]{ renameTab(_contextMenuTabIndex); }
+    );
+    editAction->setObjectName(QStringLiteral("edit-rename"));
+
+    auto closeAction = _contextPopupMenu->addAction(
+        QIcon::fromTheme(QStringLiteral("tab-close")),
+        i18nc("@action:inmenu", "Close Tab"), this,
+        [this] { closeTerminalTab(_contextMenuTabIndex); }
+    );
+    closeAction->setVisible(!KonsoleSettings::showQuickButtons());
+    closeAction->setObjectName(QStringLiteral("tab-close"));
+    connect(KonsoleSettings::self(), &KonsoleSettings::configChanged, [closeAction] {
+        closeAction->setVisible(!KonsoleSettings::showQuickButtons());
+    });
 
-    _views.swap(currentIndex, newIndex);
+    auto profileMenu = new QMenu();
+    auto profileList = new ProfileList(false, profileMenu);
+    profileList->syncWidgetActions(profileMenu, true);
+    connect(profileList, &Konsole::ProfileList::profileSelected, this,
+            static_cast<void (TabbedViewContainer::*)(Profile::Ptr)>(&Konsole::TabbedViewContainer::newViewRequest));
+  //  setNewViewMenu(profileMenu);
 
-    setActiveView(_views[newIndex]);
+    konsoleConfigChanged();
+    connect(KonsoleSettings::self(), &KonsoleSettings::configChanged, this, &TabbedViewContainer::konsoleConfigChanged);
 }
 
-void ViewContainer::setNavigationVisibility(NavigationVisibility mode)
+TabbedViewContainer::~TabbedViewContainer()
 {
-    _navigationVisibility = mode;
-    navigationVisibilityChanged(mode);
-}
+    for(int i = 0, end = count(); i < end; i++) {
+        auto view = widget(i);
+        disconnect(view, &QWidget::destroyed, this, &Konsole::TabbedViewContainer::viewDestroyed);
+    }
 
-ViewContainer::NavigationPosition ViewContainer::navigationPosition() const
-{
-    return _navigationPosition;
+    emit destroyed(this);
 }
 
-void ViewContainer::setNavigationPosition(NavigationPosition position)
+void TabbedViewContainer::konsoleConfigChanged()
 {
-    // assert that this position is supported
-    Q_ASSERT(supportedNavigationPositions().contains(position));
+    setTabBarAutoHide((bool) KonsoleSettings::tabBarVisibility());
+    setTabPosition((QTabWidget::TabPosition) KonsoleSettings::tabBarPosition());
+    setTabsClosable(KonsoleSettings::showQuickButtons());
+    setCornerWidget( KonsoleSettings::showQuickButtons() ? _newTabButton : nullptr, Qt::TopLeftCorner);
 
-    _navigationPosition = position;
+    if (isVisible() && KonsoleSettings::showQuickButtons()) {
+        _newTabButton->setVisible(true);
+    }
 
-    navigationPositionChanged(position);
+    if (KonsoleSettings::tabBarUseUserStyleSheet()) {
+        setCssFromFile(KonsoleSettings::tabBarUserStyleSheetFile());
+    }
 }
 
-QList<ViewContainer::NavigationPosition> ViewContainer::supportedNavigationPositions() const
+void TabbedViewContainer::setCssFromFile(const QUrl &url)
 {
-    return QList<NavigationPosition>() << NavigationPositionTop;
-}
+    // Let's only deal w/ local files for now
+    if (!url.isLocalFile()) {
+        setStyleSheet(KonsoleSettings::tabBarStyleSheet());
+    }
 
-void ViewContainer::setNavigationTabWidthExpanding(bool expand)
-{
-    navigationTabWidthExpandingChanged(expand);
-}
+    QFile file(url.toLocalFile());
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        setStyleSheet(KonsoleSettings::tabBarStyleSheet());
+    }
 
-ViewContainer::NavigationVisibility ViewContainer::navigationVisibility() const
-{
-    return _navigationVisibility;
+    QString styleSheetText;
+    QTextStream in(&file);
+    while (!in.atEnd()) {
+        styleSheetText.append(in.readLine());
+    }
+    setStyleSheet(styleSheetText);
 }
 
-void ViewContainer::setNavigationTextMode(bool mode)
+void TabbedViewContainer::moveActiveView(MoveDirection direction)
 {
-    navigationTextModeChanged(mode);
+    const int currentIndex = indexOf(currentWidget());
+    int newIndex = direction  == MoveViewLeft ? qMax(currentIndex - 1, 0) : qMin(currentIndex + 1, count() - 1);
+
+    auto swappedWidget = widget(newIndex);
+    auto currentWidget = widget(currentIndex);
+    auto swappedContext = _navigation[swappedWidget];
+    auto currentContext = _navigation[currentWidget];
+
+    if (newIndex < currentIndex) {
+        insertTab(newIndex, currentWidget, currentContext->icon(), currentContext->title());
+        insertTab(currentIndex, swappedWidget, swappedContext->icon(), swappedContext->title());
+    } else {
+        insertTab(currentIndex, swappedWidget, swappedContext->icon(), swappedContext->title());
+        insertTab(newIndex, currentWidget, currentContext->icon(), currentContext->title());
+    }
+    setCurrentIndex(newIndex);
 }
 
-void ViewContainer::addView(QWidget *view, ViewProperties *item, int index)
+void TabbedViewContainer::addView(QWidget *view, ViewProperties *item, int index)
 {
     if (index == -1) {
-        _views.append(view);
+        addTab(view, item->icon(), item->title());
     } else {
-        _views.insert(index, view);
+        insertTab(index, view, item->icon(), item->title());
     }
 
     _navigation[view] = item;
-
-    connect(view, &QWidget::destroyed, this, &Konsole::ViewContainer::viewDestroyed);
-
-    addViewWidget(view, index);
-
+    connect(item, &Konsole::ViewProperties::titleChanged, this,
+            &Konsole::TabbedViewContainer::updateTitle);
+    connect(item, &Konsole::ViewProperties::iconChanged, this,
+            &Konsole::TabbedViewContainer::updateIcon);
+    connect(item, &Konsole::ViewProperties::activity, this,
+            &Konsole::TabbedViewContainer::updateActivity);
+    connect(view, &QWidget::destroyed, this,
+            &Konsole::TabbedViewContainer::viewDestroyed);
     emit viewAdded(view, item);
 }
 
-void ViewContainer::viewDestroyed(QObject *view)
+void TabbedViewContainer::viewDestroyed(QObject *view)
 {
-    QWidget *widget = qobject_cast<QWidget *>(view);
+    auto widget = static_cast<QWidget*>(view);
+    const auto idx = indexOf(widget);
+
+    removeTab(idx);
     forgetView(widget);
 }
 
-void ViewContainer::forgetView(QWidget *view)
+void TabbedViewContainer::forgetView(QWidget *view)
 {
-    _views.removeAll(view);
     _navigation.remove(view);
-
     emit viewRemoved(view);
-
-    if (_views.count() == 0) {
+    if (count() == 0) {
         emit empty(this);
     }
 }
 
-void ViewContainer::removeView(QWidget *view)
+void TabbedViewContainer::removeView(QWidget *view)
 {
-    disconnect(view, &QWidget::destroyed, this, &Konsole::ViewContainer::viewDestroyed);
-    removeViewWidget(view);
+    const int idx = indexOf(view);
+    disconnect(view, &QWidget::destroyed, this, &Konsole::TabbedViewContainer::viewDestroyed);
+    removeTab(idx);
     forgetView(view);
 }
 
-const QList<QWidget *> ViewContainer::views() const
+void TabbedViewContainer::activateNextView()
 {
-    return _views;
+    QWidget *active = currentWidget();
+    int index = indexOf(active);
+    setCurrentIndex(index == count() - 1 ? 0 : index + 1);
 }
 
-IncrementalSearchBar *ViewContainer::searchBar()
+void TabbedViewContainer::activateLastView()
 {
-    if (_searchBar == nullptr) {
-        _searchBar = new IncrementalSearchBar(nullptr);
-        _searchBar->setVisible(false);
-        connect(_searchBar, &Konsole::IncrementalSearchBar::destroyed, this,
-                &Konsole::ViewContainer::searchBarDestroyed);
-    }
-    return _searchBar;
+    setCurrentIndex(count() - 1);
 }
 
-void ViewContainer::searchBarDestroyed()
+void TabbedViewContainer::activatePreviousView()
 {
-    _searchBar = nullptr;
+    QWidget *active = currentWidget();
+    int index = indexOf(active);
+    setCurrentIndex(index == 0 ? count() - 1 : index - 1);
 }
 
-void ViewContainer::activateNextView()
-{
-    QWidget *active = activeView();
-
-    int index = _views.indexOf(active);
-
-    if (index == -1) {
-        return;
-    }
-
-    if (index == _views.count() - 1) {
-        index = 0;
-    } else {
-        index++;
-    }
-
-    setActiveView(_views.at(index));
-}
-
-void ViewContainer::activateLastView()
-{
-    setActiveView(_views.at(_views.count() - 1));
-}
-
-void ViewContainer::activatePreviousView()
-{
-    QWidget *active = activeView();
-
-    int index = _views.indexOf(active);
-
-    if (index == -1) {
-        return;
-    }
-
-    if (index == 0) {
-        index = _views.count() - 1;
-    } else {
-        index--;
-    }
-
-    setActiveView(_views.at(index));
-}
-
-ViewProperties *ViewContainer::viewProperties(QWidget *view) const
+ViewProperties *TabbedViewContainer::viewProperties(QWidget *view) const
 {
     Q_ASSERT(_navigation.contains(view));
-
     return _navigation[view];
 }
 
-QList<QWidget *> ViewContainer::widgetsForItem(ViewProperties *item) const
+QList<QWidget *> TabbedViewContainer::widgetsForItem(ViewProperties *item) const
 {
     return _navigation.keys(item);
 }
 
-TabbedViewContainer::TabbedViewContainer(NavigationPosition position,
-                                         ViewManager *connectedViewManager, QObject *parent) :
-    ViewContainer(position, parent),
-    _tabBar(nullptr),
-    _stackWidget(nullptr),
-    _containerWidget(nullptr),
-    _connectedViewManager(connectedViewManager),
-    _layout(nullptr),
-    _tabBarLayout(nullptr),
-    _newTabButton(nullptr),
-    _closeTabButton(nullptr),
-    _contextMenuTabIndex(0),
-    _contextPopupMenu(nullptr)
-{
-    _containerWidget = new QWidget;
-    _stackWidget = new QStackedWidget();
-    connect(_stackWidget.data(), &QStackedWidget::widgetRemoved, this,
-            &TabbedViewContainer::widgetRemoved);
-
-    // The tab bar
-    _tabBar = new ViewContainerTabBar(_containerWidget, this);
-    _tabBar->setContextMenuPolicy(Qt::CustomContextMenu);
-    _tabBar->setSupportedMimeType(ViewProperties::mimeType());
-
-    connect(_tabBar, &Konsole::ViewContainerTabBar::currentChanged, this,
-            &Konsole::TabbedViewContainer::currentTabChanged);
-    connect(_tabBar, &Konsole::ViewContainerTabBar::tabBarDoubleClicked, this,
-            &Konsole::TabbedViewContainer::tabDoubleClicked);
-    connect(_tabBar, &Konsole::ViewContainerTabBar::querySourceIndex, this,
-            &Konsole::TabbedViewContainer::querySourceIndex);
-    connect(_tabBar, &Konsole::ViewContainerTabBar::moveViewRequest, this,
-            &Konsole::TabbedViewContainer::onMoveViewRequest);
-    connect(_tabBar, &Konsole::ViewContainerTabBar::customContextMenuRequested, this,
-            &Konsole::TabbedViewContainer::openTabContextMenu);
-
-    connect(_tabBar, &Konsole::ViewContainerTabBar::initiateDrag, this,
-            &Konsole::TabbedViewContainer::startTabDrag);
-
-    // The context menu of tab bar
-    _contextPopupMenu = new QMenu(_tabBar);
-    connect(_contextPopupMenu, &QMenu::aboutToHide, this, [this]() {
-        // Remove the read-only action when the popup closes
-        for (auto &action : _contextPopupMenu->actions()) {
-            if (action->objectName() == QStringLiteral("view-readonly")) {
-                _contextPopupMenu->removeAction(action);
-                break;
-            }
-        }
-    });
-
-#if defined(ENABLE_DETACHING)
-    _contextPopupMenu->addAction(QIcon::fromTheme(QStringLiteral("tab-detach")),
-                                 i18nc("@action:inmenu", "&Detach Tab"), this,
-                                 SLOT(tabContextMenuDetachTab()));
-#endif
-
-    _contextPopupMenu->addAction(QIcon::fromTheme(QStringLiteral("edit-rename")),
-                                 i18nc("@action:inmenu", "&Rename Tab..."), this,
-                                 SLOT(tabContextMenuRenameTab()));
-    const auto contextPopupMenuActions = _contextPopupMenu->actions();
-    contextPopupMenuActions.last()->setObjectName(QStringLiteral("edit-rename"));
-
-    _contextPopupMenu->addSeparator();
-
-    _contextPopupMenu->addAction(QIcon::fromTheme(QStringLiteral("tab-close")),
-                                 i18nc("@action:inmenu", "&Close Tab"), this,
-                                 SLOT(tabContextMenuCloseTab()));
-    // The 'new tab' and 'close tab' button
-    _newTabButton = new QToolButton(_containerWidget);
-    _newTabButton->setFocusPolicy(Qt::NoFocus);
-    _newTabButton->setIcon(QIcon::fromTheme(QStringLiteral("tab-new")));
-    _newTabButton->setToolTip(i18nc("@info:tooltip", "Create new tab"));
-    _newTabButton->setWhatsThis(i18nc("@info:whatsthis",
-                                      "Create a new tab. Press and hold to select profile from menu"));
-    _newTabButton->adjustSize();
-
-    auto profileMenu = new QMenu(_newTabButton);
-    auto profileList = new ProfileList(false, profileMenu);
-    profileList->syncWidgetActions(profileMenu, true);
-    connect(profileList, &Konsole::ProfileList::profileSelected, this,
-            static_cast<void (TabbedViewContainer::*)(Profile::Ptr)>(&Konsole::TabbedViewContainer::
-                                                                     newViewRequest));
-    setNewViewMenu(profileMenu);
-
-    _closeTabButton = new QToolButton(_containerWidget);
-    _closeTabButton->setFocusPolicy(Qt::NoFocus);
-    _closeTabButton->setIcon(QIcon::fromTheme(QStringLiteral("tab-close")));
-    _closeTabButton->setToolTip(i18nc("@info:tooltip", "Close tab"));
-    _closeTabButton->setWhatsThis(i18nc("@info:whatsthis", "Close the active tab"));
-    _closeTabButton->adjustSize();
-
-    // 'new tab' button is initially hidden. It will be shown when setFeatures()
-    // is called with the QuickNewView flag enabled. The 'close tab' is the same.
-    _newTabButton->setHidden(true);
-    _closeTabButton->setHidden(true);
-
-    connect(_newTabButton, &QToolButton::clicked, this,
-            static_cast<void (TabbedViewContainer::*)()>(&Konsole::TabbedViewContainer::newViewRequest));
-    connect(_closeTabButton, &QToolButton::clicked, this,
-            &Konsole::TabbedViewContainer::closeCurrentTab);
-
-    // Combine tab bar and 'new/close tab' buttons
-    _tabBarLayout = new QHBoxLayout;
-    _tabBarLayout->setSpacing(0);
-    _tabBarLayout->setContentsMargins(0, 0, 0, 0);
-    _tabBarLayout->addWidget(_newTabButton);
-    _tabBarLayout->addWidget(_tabBar);
-    _tabBarLayout->addWidget(_closeTabButton);
-
-    // The search bar
-    searchBar()->setParent(_containerWidget);
-
-    // The overall layout
-    _layout = new QVBoxLayout;
-    _layout->setSpacing(0);
-    _layout->setContentsMargins(0, 0, 0, 0);
-
-    setNavigationPosition(position);
-
-    _containerWidget->setLayout(_layout);
-}
-
-void TabbedViewContainer::setNewViewMenu(QMenu *menu)
-{
-    _newTabButton->setMenu(menu);
-}
-
-ViewContainer::Features TabbedViewContainer::supportedFeatures() const
-{
-    return QuickNewView | QuickCloseView;
-}
-
-void TabbedViewContainer::setFeatures(Features features)
-{
-    ViewContainer::setFeatures(features);
-    updateVisibilityOfQuickButtons();
-}
-
 void TabbedViewContainer::closeCurrentTab()
 {
-    if (_stackWidget->currentIndex() != -1) {
-        emit closeTab(this, _stackWidget->widget(_stackWidget->currentIndex()));
+    if (currentIndex() != -1) {
+        closeTerminalTab(currentIndex());
     }
 }
 
-void TabbedViewContainer::updateVisibilityOfQuickButtons()
-{
-    const bool tabBarHidden = _tabBar->isHidden();
-    _newTabButton->setVisible(!tabBarHidden && ((features() & QuickNewView) != 0));
-    _closeTabButton->setVisible(!tabBarHidden && ((features() & QuickCloseView) != 0));
-}
-
-void TabbedViewContainer::setTabBarVisible(bool visible)
-{
-    _tabBar->setVisible(visible);
-    updateVisibilityOfQuickButtons();
-}
-
-QList<ViewContainer::NavigationPosition> TabbedViewContainer::supportedNavigationPositions() const
-{
-    return QList<NavigationPosition>() << NavigationPositionTop << NavigationPositionBottom;
-}
-
-void TabbedViewContainer::navigationPositionChanged(NavigationPosition position)
-{
-    // this method assumes that there are three or zero items in the layout
-    Q_ASSERT(_layout->count() == 3 || _layout->count() == 0);
-
-    // clear all existing items from the layout
-    _layout->removeItem(_tabBarLayout);
-    _tabBarLayout->setParent(nullptr); // suppress the warning of "already has a parent"
-    _layout->removeWidget(_stackWidget);
-    _layout->removeWidget(searchBar());
-
-    if (position == NavigationPositionTop) {
-        _layout->insertLayout(-1, _tabBarLayout);
-        _layout->insertWidget(-1, _stackWidget);
-        _layout->insertWidget(-1, searchBar());
-        _tabBar->setShape(QTabBar::RoundedNorth);
-    } else if (position == NavigationPositionBottom) {
-        _layout->insertWidget(-1, _stackWidget);
-        _layout->insertWidget(-1, searchBar());
-        _layout->insertLayout(-1, _tabBarLayout);
-        _tabBar->setShape(QTabBar::RoundedSouth);
-    } else {
-        Q_ASSERT(false); // should never reach here
-    }
-}
-
-void TabbedViewContainer::navigationTabWidthExpandingChanged(bool expand)
-{
-    _tabBar->setExpanding(expand);
-}
-
-void TabbedViewContainer::navigationVisibilityChanged(NavigationVisibility mode)
-{
-    if (mode == AlwaysShowNavigation && _tabBar->isHidden()) {
-        setTabBarVisible(true);
-    }
-
-    if (mode == AlwaysHideNavigation && !_tabBar->isHidden()) {
-        setTabBarVisible(false);
-    }
-
-    if (mode == ShowNavigationAsNeeded) {
-        dynamicTabBarVisibility();
-    }
-}
-
-void TabbedViewContainer::dynamicTabBarVisibility()
-{
-    if (_tabBar->count() > 1 && _tabBar->isHidden()) {
-        setTabBarVisible(true);
-    }
-
-    if (_tabBar->count() < 2 && !_tabBar->isHidden()) {
-        setTabBarVisible(false);
-    }
-}
-
-void TabbedViewContainer::setStyleSheet(const QString &styleSheet)
-{
-    _tabBar->setStyleSheet(styleSheet);
-}
-
-// TODO: Only called via dbus method - remove
-void TabbedViewContainer::navigationTextModeChanged(bool useTextWidth)
-{
-    // Qt 5.9 changed how tabs are displayed
-    if (useTextWidth) {
-        _tabBar->setStyleSheet(QStringLiteral("QTabBar::tab { }"));
-        _tabBar->setExpanding(false);
-        _tabBar->setElideMode(Qt::ElideNone);
-    } else {
-        _tabBar->setStyleSheet(QStringLiteral("QTabBar::tab { min-width: 2em; max-width: 25em }"));
-        _tabBar->setExpanding(true);
-        _tabBar->setElideMode(Qt::ElideLeft);
-    }
-}
-
-TabbedViewContainer::~TabbedViewContainer()
-{
-    if (!_containerWidget.isNull()) {
-        _containerWidget->deleteLater();
-    }
-}
-
-void TabbedViewContainer::startTabDrag(int index)
-{
-    QPointer<QDrag> drag = new QDrag(_tabBar);
-    const QRect tabRect = _tabBar->tabRect(index);
-    QPixmap tabPixmap = _tabBar->dragDropPixmap(index);
-
-    drag->setPixmap(tabPixmap);
-
-    // offset the tab position so the tab will follow the cursor exactly
-    // where it was clicked (as opposed to centering on the origin of the pixmap)
-    QPoint mappedPos = _tabBar->mapFromGlobal(QCursor::pos());
-    mappedPos.rx() -= tabRect.x();
-
-    drag->setHotSpot(mappedPos);
-
-    const int id = viewProperties(views()[index])->identifier();
-    QWidget *view = views()[index];
-    drag->setMimeData(ViewProperties::createMimeData(id));
-
-    // start dragging
-    const Qt::DropAction action = drag->exec();
-
-    if ((!drag.isNull()) && (drag->target() != nullptr)) {
-        switch (action) {
-        case Qt::MoveAction:
-            // The MoveAction indicates the widget has been successfully
-            // moved into another tabbar/container, so remove the widget in
-            // current tabbar/container.
-            //
-            // Deleting the view may cause the view container to be deleted,
-            // which will also delete the QDrag object. This can cause a
-            // crash if Qt's internal drag-and-drop handling tries to delete
-            // it later.
-            //
-            // For now set the QDrag's parent to 0 so that it won't be
-            // deleted if this view container is destroyed.
-            //
-            // FIXME: Resolve this properly
-            drag->setParent(nullptr);
-            removeView(view);
-            break;
-        case Qt::IgnoreAction:
-            // The IgnoreAction is used by the tabbar to indicate the
-            // special case of dropping one tab into its existing position.
-            // So nothing need to do here.
-            break;
-        default:
-            break;
-        }
-    } else {
-        // if the tab is dragged onto something that does not accept this
-        // drop(for example, a different application or a different konsole
-        // process), then detach the tab to achieve the effect of "dragging tab
-        // out of current window and into its own window"
-        //
-        // It feels unnatural to do the detach when this is only one tab in the
-        // tabbar
-        if (_tabBar->count() > 1) {
-            emit detachTab(this, view);
-        }
-    }
-    delete drag;
-}
-
-void TabbedViewContainer::querySourceIndex(const QDropEvent *event, int &sourceIndex)
-{
-    const int droppedId = ViewProperties::decodeMimeData(event->mimeData());
-
-    const QList<QWidget *> viewList = views();
-    const int count = viewList.count();
-    int index = -1;
-    for (index = 0; index < count; index++) {
-        const int id = viewProperties(viewList[index])->identifier();
-        if (id == droppedId) {
-            break;
-        }
-    }
-
-    sourceIndex = index;
-}
-
-void TabbedViewContainer::onMoveViewRequest(int index, const QDropEvent *event, bool &success,
-                                            TabbedViewContainer *sourceTabbedContainer)
-{
-    const int droppedId = ViewProperties::decodeMimeData(event->mimeData());
-    emit moveViewRequest(index, droppedId, success, sourceTabbedContainer);
-}
-
 void TabbedViewContainer::tabDoubleClicked(int index)
 {
     if (index >= 0) {
         renameTab(index);
     } else {
         emit newViewRequest();
     }
 }
 
 void TabbedViewContainer::renameTab(int index)
 {
-    viewProperties(views()[index])->rename();
+    if (index != -1) {
+        _navigation[widget(index)]->rename();
+    }
 }
 
 void TabbedViewContainer::openTabContextMenu(const QPoint &point)
 {
     if (point.isNull()) {
         return;
     }
 
-    _contextMenuTabIndex = _tabBar->tabAt(point);
+    _contextMenuTabIndex = tabBar()->tabAt(point);
     if (_contextMenuTabIndex < 0) {
         return;
     }
 
-#if defined(ENABLE_DETACHING)
-    // Enable 'Detach Tab' menu item only if there is more than 1 tab
-    // Note: the code is coupled with that action's position within the menu
-    QAction *detachAction = _contextPopupMenu->actions().at(0);
-    detachAction->setEnabled(_tabBar->count() > 1);
-#endif
+    //TODO: add a countChanged signal so we can remove this for.
+    // Detaching in mac causes crashes.
+    const auto isDarwin = QOperatingSystemVersion::currentType() == QOperatingSystemVersion::MacOS;
+    for(auto action : _contextPopupMenu->actions()) {
+        if (action->objectName() == QStringLiteral("tab-detach")) {
+            action->setEnabled( !isDarwin && count() > 1);
+        }
+    }
 
     // Add the read-only action
-    SessionController *sessionController = qobject_cast<SessionController*>(viewProperties(views()[_contextMenuTabIndex]));
+    auto controller = _navigation[widget(_contextMenuTabIndex)];
+    auto sessionController = qobject_cast<SessionController*>(controller);
+
     if (sessionController != nullptr) {
         auto collection = sessionController->actionCollection();
         auto readonlyAction = collection->action(QStringLiteral("view-readonly"));
         if (readonlyAction != nullptr) {
             const auto readonlyActions = _contextPopupMenu->actions();
             _contextPopupMenu->insertAction(readonlyActions.last(), readonlyAction);
         }
 
         // Disable tab rename
         for (auto &action : _contextPopupMenu->actions()) {
             if (action->objectName() == QStringLiteral("edit-rename")) {
                 action->setEnabled(!sessionController->isReadOnly());
                 break;
             }
         }
     }
 
-    _contextPopupMenu->exec(_tabBar->mapToGlobal(point));
-}
-
-void TabbedViewContainer::tabContextMenuCloseTab()
-{
-    _tabBar->setCurrentIndex(_contextMenuTabIndex);// Required for this to work
-    emit closeTab(this, _stackWidget->widget(_contextMenuTabIndex));
-}
-
-void TabbedViewContainer::tabContextMenuDetachTab()
-{
-    emit detachTab(this, _stackWidget->widget(_contextMenuTabIndex));
-}
-
-void TabbedViewContainer::tabContextMenuRenameTab()
-{
-    renameTab(_contextMenuTabIndex);
-}
-
-void TabbedViewContainer::moveViewWidget(int fromIndex, int toIndex)
-{
-    QString text = _tabBar->tabText(fromIndex);
-    QIcon icon = _tabBar->tabIcon(fromIndex);
-
-    // FIXME (KF5?)- This will lose properties of the tab other than
-    // their text and icon when moving them
-
-    QWidget *widget = _stackWidget->widget(fromIndex);
-    // this also removes the tab from the tab bar
-    _stackWidget->removeWidget(widget);
-    _stackWidget->insertWidget(toIndex, widget);
-
-    _tabBar->insertTab(toIndex, icon, text);
-
-    if (navigationVisibility() == ShowNavigationAsNeeded) {
-        dynamicTabBarVisibility();
-    }
+    _contextPopupMenu->exec(tabBar()->mapToGlobal(point));
 }
 
 void TabbedViewContainer::currentTabChanged(int index)
 {
-    _stackWidget->setCurrentIndex(index);
-    if (_stackWidget->widget(index) != nullptr) {
-        emit activeViewChanged(_stackWidget->widget(index));
+    setCurrentIndex(index);
+    if (widget(index) != nullptr) {
+        emit activeViewChanged(widget(index));
     }
 
     // clear activity indicators
     setTabActivity(index, false);
 }
 
 void TabbedViewContainer::wheelScrolled(int delta)
 {
     if (delta < 0) {
         activateNextView();
     } else {
         activatePreviousView();
     }
 }
 
-QWidget *TabbedViewContainer::containerWidget() const
-{
-    return _containerWidget;
-}
-
-QWidget *TabbedViewContainer::activeView() const
-{
-    return _stackWidget->currentWidget();
-}
-
-void TabbedViewContainer::setActiveView(QWidget *view)
-{
-    const int index = _stackWidget->indexOf(view);
-
-    Q_ASSERT(index != -1);
-
-    _stackWidget->setCurrentWidget(view);
-    _tabBar->setCurrentIndex(index);
-}
-
-void TabbedViewContainer::addViewWidget(QWidget *view, int index)
-{
-    _stackWidget->insertWidget(index, view);
-    _stackWidget->updateGeometry();
-
-    ViewProperties *item = viewProperties(view);
-    connect(item, &Konsole::ViewProperties::titleChanged, this,
-            &Konsole::TabbedViewContainer::updateTitle);
-    connect(item, &Konsole::ViewProperties::iconChanged, this,
-            &Konsole::TabbedViewContainer::updateIcon);
-    connect(item, &Konsole::ViewProperties::activity, this,
-            &Konsole::TabbedViewContainer::updateActivity);
-
-    _tabBar->insertTab(index, item->icon(), item->title());
-
-    if (navigationVisibility() == ShowNavigationAsNeeded) {
-        dynamicTabBarVisibility();
-    }
-}
-
-void TabbedViewContainer::removeViewWidget(QWidget *view)
-{
-    if (_stackWidget.isNull()) {
-        return;
-    }
-    _stackWidget->removeWidget(view);
-}
-
-void TabbedViewContainer::widgetRemoved(int index)
-{
-    Q_ASSERT(index != -1);
-
-    _tabBar->removeTab(index);
-
-    if (navigationVisibility() == ShowNavigationAsNeeded) {
-        dynamicTabBarVisibility();
-    }
-}
-
 void TabbedViewContainer::setTabActivity(int index, bool activity)
 {
-    const QPalette &palette = _tabBar->palette();
+    const QPalette &palette = tabBar()->palette();
     KColorScheme colorScheme(palette.currentColorGroup());
     const QColor colorSchemeActive = colorScheme.foreground(KColorScheme::ActiveText).color();
 
     const QColor normalColor = palette.text().color();
     const QColor activityColor = KColorUtils::mix(normalColor, colorSchemeActive);
 
     QColor color = activity ? activityColor : QColor();
 
-    if (color != _tabBar->tabTextColor(index)) {
-        _tabBar->setTabTextColor(index, color);
+    if (color != tabBar()->tabTextColor(index)) {
+        tabBar()->setTabTextColor(index, color);
     }
 }
 
 void TabbedViewContainer::updateActivity(ViewProperties *item)
 {
     foreach (QWidget *widget, widgetsForItem(item)) {
-        const int index = _stackWidget->indexOf(widget);
+        const int index = indexOf(widget);
 
-        if (index != _stackWidget->currentIndex()) {
+        if (index != currentIndex()) {
             setTabActivity(index, true);
         }
     }
 }
 
 void TabbedViewContainer::updateTitle(ViewProperties *item)
 {
     foreach (QWidget *widget, widgetsForItem(item)) {
-        const int index = _stackWidget->indexOf(widget);
+        const int index = indexOf(widget);
         QString tabText = item->title();
 
-        _tabBar->setTabToolTip(index, tabText);
+        setTabToolTip(index, tabText);
 
         // To avoid having & replaced with _ (shortcut indicator)
         tabText.replace(QLatin1Char('&'), QLatin1String("&&"));
-        _tabBar->setTabText(index, tabText);
+        setTabText(index, tabText);
     }
 }
 
 void TabbedViewContainer::updateIcon(ViewProperties *item)
 {
     foreach (QWidget *widget, widgetsForItem(item)) {
-        const int index = _stackWidget->indexOf(widget);
-        _tabBar->setTabIcon(index, item->icon());
+        const int index = indexOf(widget);
+        setTabIcon(index, item->icon());
     }
 }
 
+void TabbedViewContainer::closeTerminalTab(int idx) {
+    auto currWidget = widget(idx);
+    auto controller = qobject_cast<SessionController *>(_navigation[currWidget]);
+    controller->closeSession();
+}
+
 ViewManager *TabbedViewContainer::connectedViewManager()
 {
     return _connectedViewManager;
 }
diff --git a/src/ViewContainer.h b/src/ViewContainer.h
index 0cf63d51..87a57f14 100644
--- a/src/ViewContainer.h
+++ b/src/ViewContainer.h
@@ -1,466 +1,205 @@
 /*
     This file is part of the Konsole Terminal.
 
     Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 #ifndef VIEWCONTAINER_H
 #define VIEWCONTAINER_H
 
 // Qt
 #include <QObject>
 #include <QPointer>
 #include <QHash>
 #include <QList>
+#include <QTabWidget>
+#include <QTabBar>
 
 // Konsole
 #include "Profile.h"
 
-class QStackedWidget;
-class QWidget;
-class QHBoxLayout;
-class QVBoxLayout;
-
-// TabbedViewContainer
 // Qt
 class QPoint;
 class QToolButton;
 class QMenu;
 class QDropEvent;
 
-// KDE
-class QMenu;
-
 namespace Konsole {
 class IncrementalSearchBar;
 class ViewProperties;
+class ViewManager;
 class TabbedViewContainer;
+
 /**
  * An interface for container widgets which can hold one or more views.
  *
  * The container widget typically displays a list of the views which
  * it has and provides a means of switching between them.
  *
  * Subclasses should reimplement the addViewWidget() and removeViewWidget() functions
  * to actually add or remove view widgets from the container widget, as well
  * as updating any navigation aids.
  */
-class ViewContainer : public QObject
+class TabbedViewContainer : public QTabWidget
 {
     Q_OBJECT
 
 public:
-    /**
-     * This enum describes the options for positioning the
-     * container's navigation widget.
-     */
-    enum NavigationPosition {
-        /** Position the navigation widget above the views. */
-        NavigationPositionTop,
-        /** Position the navigation widget below the views. */
-        NavigationPositionBottom,
-        /** Position the navigation widget to the left of the views. */
-        NavigationPositionLeft,
-        /** Position the navigation widget to the right of the views. */
-        NavigationPositionRight
-    };
-
     /**
      * Constructs a new view container with the specified parent.
      *
      * @param position The initial position of the navigation widget
      * @param parent The parent object of the container
      */
-    ViewContainer(NavigationPosition position, QObject *parent);
+    TabbedViewContainer(ViewManager *connectedViewManager, QWidget *parent);
 
     /**
      * Called when the ViewContainer is destroyed.  When reimplementing this in
      * subclasses, use object->deleteLater() to delete any widgets or other objects
      * instead of 'delete object'.
      */
-    ~ViewContainer() Q_DECL_OVERRIDE;
-
-    /** Returns the widget which contains the view widgets */
-    virtual QWidget *containerWidget() const = 0;
-
-    /**
-     * This enum describes the options for showing or hiding the
-     * container's navigation widget.
-     */
-    enum NavigationVisibility {
-        /** Always show the navigation widget. */
-        AlwaysShowNavigation,
-        /** Show the navigation widget only when the container has more than one view. */
-        ShowNavigationAsNeeded,
-        /** Always hide the navigation widget. */
-        AlwaysHideNavigation
-    };
-    /*
-     * Sets the visibility of the view container's navigation widget.
-     *
-     * The ViewContainer sub-class is responsible for ensuring that this
-     * setting is respected as views are added or removed from the
-     * container.
-     *
-     * ViewContainer sub-classes should reimplement the
-     * navigationVisibilityChanged() method to respond to changes
-     * of this property.
-     */
-    void setNavigationVisibility(NavigationVisibility mode);
-    /**
-     * Returns the current mode for controlling the visibility of the
-     * the view container's navigation widget.
-     */
-    NavigationVisibility navigationVisibility() const;
-
-    /**
-     * Sets the position of the navigation widget with
-     * respect to the main content area.
-     *
-     * Depending on the ViewContainer subclass, not all
-     * positions from the NavigationPosition enum may be
-     * supported.  A list of supported positions can be
-     * obtained by calling supportedNavigationPositions()
-     *
-     * ViewContainer sub-classes should re-implement the
-     * navigationPositionChanged() method to respond
-     * to changes of this property.
-     */
-    void setNavigationPosition(NavigationPosition position);
-
-    /**
-     * Returns the position of the navigation widget with
-     * respect to the main content area.
-     */
-    NavigationPosition navigationPosition() const;
-
-    /**
-     * Set whether tab width are expanding
-     */
-    void setNavigationTabWidthExpanding(bool expand);
-
-    /**
-     * Returns the list of supported navigation positions.
-     * The supported positions will depend upon the type of the
-     * navigation widget used by the ViewContainer subclass.
-     *
-     * The base implementation returns one item, NavigationPositionTop
-     */
-    virtual QList<NavigationPosition> supportedNavigationPositions() const;
-
-    /** Sets the navigation text mode
-     *  If mode is true, use the width of the title; otherwise use the
-     *  default width calculations.
-     */
-    void setNavigationTextMode(bool mode);
-
-    /** Sets the stylesheet for visual appearance
-     *
-     * The default implementation does nothing.
-     */
-    virtual void setStyleSheet(const QString &styleSheet)
-    {
-        Q_UNUSED(styleSheet);
-    }
+    ~TabbedViewContainer() Q_DECL_OVERRIDE;
 
     /** Adds a new view to the container widget */
     void addView(QWidget *view, ViewProperties *navigationItem, int index = -1);
 
     /** Removes a view from the container */
     void removeView(QWidget *view);
 
     /** Returns the ViewProperties instance associated with a particular view in the container */
     ViewProperties *viewProperties(QWidget *view) const;
+    void setTabActivity(int index, bool activity);
 
-    /** Returns a list of the contained views */
-    const QList<QWidget *> views() const;
-
-    /**
-     * Returns the view which currently has the focus or 0 if none
-     * of the child views have the focus.
-     */
-    virtual QWidget *activeView() const = 0;
-
-    /**
-     * Changes the focus to the specified view and updates
-     * navigation aids to reflect the change.
-     */
-    virtual void setActiveView(QWidget *widget) = 0;
-
-    /**
-     * @return the search widget for this view
-     */
-    IncrementalSearchBar *searchBar();
+    void updateTitle(ViewProperties *item);
+    void updateIcon(ViewProperties *item);
+    void updateActivity(ViewProperties *item);
 
     /** Changes the active view to the next view */
     void activateNextView();
 
     /** Changes the active view to the previous view */
     void activatePreviousView();
 
     /** Changes the active view to the last view */
     void activateLastView();
 
+    void setCssFromFile(const QUrl& url);
     /**
      * This enum describes the directions
      * in which views can be re-arranged within the container
      * using the moveActiveView() method.
      */
     enum MoveDirection {
         /** Moves the view to the left. */
         MoveViewLeft,
         /** Moves the view to the right. */
         MoveViewRight
     };
 
     /**
      * Moves the active view within the container and
      * updates the order in which the views are shown
      * in the container's navigation widget.
      *
      * The default implementation does nothing.
      */
     void moveActiveView(MoveDirection direction);
 
-    /** Enum describing extra UI features which can be
-     * provided by the container. */
-    enum Feature {
-        /** Provides a button which can be clicked to create new views quickly.
-         * When the button is clicked, a newViewRequest() signal is emitted. */
-        QuickNewView = 1,
-        /** Provides a button which can be clicked to close views quickly. */
-        QuickCloseView = 2
-    };
-    Q_DECLARE_FLAGS(Features, Feature)
-    /**
-     * Sets which additional features are enabled in this container.
-     * The default implementation does thing.  Sub-classes should re-implement this
-     * to hide or show the relevant parts of their UI
-     */
-    virtual void setFeatures(Features features);
-    /** Returns a bitwise-OR of enabled extra UI features.  See setFeatures() */
-    Features features() const;
-    /** Returns a bitwise-OR of supported extra UI features.  The default
-     * implementation returns 0 (no extra features) */
-    virtual Features supportedFeatures() const
-    {
-        return nullptr;
-    }
-
     /** Sets the menu to be shown when the new view button is clicked.
      * Only valid if the QuickNewView feature is enabled.
      * The default implementation does nothing. */
-    virtual void setNewViewMenu(QMenu *menu)
-    {
-        Q_UNUSED(menu);
-    }
+    // TODO: Reenable this later.
+    //    void setNewViewMenu(QMenu *menu);
+    void renameTab(int index);
+    ViewManager *connectedViewManager();
+    void currentTabChanged(int index);
+    void closeCurrentTab();
+    void wheelScrolled(int delta);
 
-Q_SIGNALS:
-    /** Emitted when the container is deleted */
-    void destroyed(ViewContainer *container);
+    void tabDoubleClicked(int index);
+    void openTabContextMenu(const QPoint &point);
 
+Q_SIGNALS:
     /** Emitted when the container has no more children */
-    void empty(ViewContainer *container);
+    void empty(TabbedViewContainer *container);
 
     /** Emitted when the user requests to open a new view */
     void newViewRequest();
 
     /** Requests creation of a new view, with the selected profile. */
     void newViewRequest(Profile::Ptr);
 
     /**
      * Emitted when the user requests to move a view from another container
      * into this container.  If 'success' is set to true by a connected slot
      * then the original view will be removed.
      *
      * @param index Index at which to insert the new view in the container or -1
      * to append it.  This index should be passed to addView() when the new view
      * has been created.
      * @param id The identifier of the view.
      * @param success The slot handling this signal should set this to true if the
      * new view was successfully created.
      * @param sourceContainer Initial move event Tabbed view container.
      */
     void moveViewRequest(int index, int id, bool &success, TabbedViewContainer *sourceContainer);
 
     /** Emitted when the active view changes */
     void activeViewChanged(QWidget *view);
 
     /** Emitted when a view is added to the container. */
     void viewAdded(QWidget *view, ViewProperties *properties);
 
     /** Emitted when a view is removed from the container. */
     void viewRemoved(QWidget *view);
 
-protected:
-    /**
-     * Performs the task of adding the view widget
-     * to the container widget.
-     */
-    virtual void addViewWidget(QWidget *view, int index) = 0;
-    /**
-     * Performs the task of removing the view widget
-     * from the container widget.
-     */
-    virtual void removeViewWidget(QWidget *view) = 0;
-
-    /**
-     * Called when the navigation display mode changes.
-     * See setNavigationVisibility
-     */
-    virtual void navigationVisibilityChanged(NavigationVisibility)
-    {
-    }
-
-    /**
-     * Called when the navigation tab width expanding option changes.
-     * See setNavigationTabWidthExpanding
-     */
-    virtual void navigationTabWidthExpandingChanged(bool)
-    {
-    }
-
-    /**
-     * Called when the navigation position changes to re-layout
-     * the container and place the navigation widget in the
-     * specified position.
-     */
-    virtual void navigationPositionChanged(NavigationPosition)
-    {
-    }
-
-    virtual void navigationTextModeChanged(bool)
-    {
-    }
+    /** detach the specific tab */
+    void detachTab(TabbedViewContainer *self, QWidget *activeView);
 
+protected:
     /** Returns the widgets which are associated with a particular navigation item */
     QList<QWidget *> widgetsForItem(ViewProperties *item) const;
 
     /**
      * Rearranges the order of widgets in the container.
      *
      * @param fromIndex Current index of the widget to move
      * @param toIndex New index for the widget
      */
-    virtual void moveViewWidget(int fromIndex, int toIndex);
+    void moveViewWidget(int fromIndex, int toIndex);
+
+    // close tabs and unregister
+    void closeTerminalTab(int index);
 
 private Q_SLOTS:
     void viewDestroyed(QObject *view);
-    void searchBarDestroyed();
+    void konsoleConfigChanged();
 
 private:
-    Q_DISABLE_COPY(ViewContainer)
-
     void forgetView(QWidget *view);
 
-    NavigationVisibility _navigationVisibility;
-    NavigationPosition _navigationPosition;
-    QList<QWidget *> _views;
     QHash<QWidget *, ViewProperties *> _navigation;
-    Features _features;
-    IncrementalSearchBar *_searchBar;
-};
-Q_DECLARE_OPERATORS_FOR_FLAGS(ViewContainer::Features)
-
-class ViewContainerTabBar;
-class ViewManager;
-
-/**
- * An alternative tabbed view container which uses a QTabBar and QStackedWidget
- * combination for navigation instead of QTabWidget
- */
-class TabbedViewContainer : public ViewContainer
-{
-    Q_OBJECT
-
-public:
-    /**
-     * Constructs a new tabbed view container.  Supported positions
-     * are NavigationPositionTop and NavigationPositionBottom.
-     */
-    TabbedViewContainer(NavigationPosition position, ViewManager *connectedViewManager,
-                        QObject *parent);
-    ~TabbedViewContainer() Q_DECL_OVERRIDE;
-
-    QWidget *containerWidget() const Q_DECL_OVERRIDE;
-    QWidget *activeView() const Q_DECL_OVERRIDE;
-    void setActiveView(QWidget *view) Q_DECL_OVERRIDE;
-    QList<NavigationPosition> supportedNavigationPositions() const Q_DECL_OVERRIDE;
-    void setFeatures(Features features) Q_DECL_OVERRIDE;
-    Features supportedFeatures() const Q_DECL_OVERRIDE;
-    void setNewViewMenu(QMenu *menu) Q_DECL_OVERRIDE;
-    void setStyleSheet(const QString &styleSheet) Q_DECL_OVERRIDE;
-    void setTabBarVisible(bool visible);
-
-    // return associated view manager
-    ViewManager *connectedViewManager();
-
-protected:
-    void addViewWidget(QWidget *view, int index) Q_DECL_OVERRIDE;
-    void removeViewWidget(QWidget *view) Q_DECL_OVERRIDE;
-    void navigationVisibilityChanged(NavigationVisibility mode) Q_DECL_OVERRIDE;
-    void navigationPositionChanged(NavigationPosition position) Q_DECL_OVERRIDE;
-    void navigationTabWidthExpandingChanged(bool expand) Q_DECL_OVERRIDE;
-    void navigationTextModeChanged(bool useTextWidth) Q_DECL_OVERRIDE;
-    void moveViewWidget(int fromIndex, int toIndex) Q_DECL_OVERRIDE;
-
-private Q_SLOTS:
-    void updateTitle(ViewProperties *item);
-    void updateIcon(ViewProperties *item);
-    void updateActivity(ViewProperties *item);
-    void currentTabChanged(int index);
-    void closeCurrentTab();
-    void wheelScrolled(int delta);
-
-    void tabDoubleClicked(int index);
-    void openTabContextMenu(const QPoint &point);
-    void tabContextMenuCloseTab();
-    void tabContextMenuRenameTab();
-    void tabContextMenuDetachTab();
-    void startTabDrag(int index);
-    void querySourceIndex(const QDropEvent *event, int &sourceIndex);
-    void onMoveViewRequest(int index, const QDropEvent *event, bool &success,
-                           TabbedViewContainer *sourceTabbedContainer);
-
-Q_SIGNALS:
-    void detachTab(ViewContainer *self, QWidget *activeView);
-    void closeTab(ViewContainer *self, QWidget *activeView);
-
-private:
-    Q_DISABLE_COPY(TabbedViewContainer)
-
-    void dynamicTabBarVisibility();
-    void setTabActivity(int index, bool activity);
-    void renameTab(int index);
-    void updateVisibilityOfQuickButtons();
-    void widgetRemoved(int index);
-
-    ViewContainerTabBar *_tabBar;
-    QPointer<QStackedWidget> _stackWidget;
-    QPointer<QWidget> _containerWidget;
     ViewManager *_connectedViewManager;
-    QVBoxLayout *_layout;
-    QHBoxLayout *_tabBarLayout;
+    QMenu *_contextPopupMenu;
     QToolButton *_newTabButton;
-    QToolButton *_closeTabButton;
     int _contextMenuTabIndex;
-    QMenu *_contextPopupMenu;
 };
 
+
 }
 #endif //VIEWCONTAINER_H
diff --git a/src/ViewContainerTabBar.cpp b/src/ViewContainerTabBar.cpp
deleted file mode 100644
index 29eae084..00000000
--- a/src/ViewContainerTabBar.cpp
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
-    This file is part of the Konsole Terminal.
-
-    Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-    02110-1301  USA.
-*/
-
-// Own
-#include "ViewContainerTabBar.h"
-#include "ViewContainer.h"
-
-// Qt
-#include <QMimeData>
-#include <QLabel>
-#include <QPainter>
-#include <QDragMoveEvent>
-#include <QIcon>
-#include <QTabBar>
-#include <QApplication>
-
-// KDE
-#include <KLocalizedString>
-
-using Konsole::ViewContainerTabBar;
-using Konsole::TabbedViewContainer;
-
-ViewContainerTabBar::ViewContainerTabBar(QWidget *parent, TabbedViewContainer *container) :
-    QTabBar(parent),
-    _dropIndicator(nullptr),
-    _dropIndicatorIndex(-1),
-    _drawIndicatorDisabled(false),
-    _supportedMimeType(QString()),
-    _connectedContainer(container),
-    _dragStart(QPoint()),
-    _mousePressTimer(nullptr)
-{
-    setDrawBase(true);
-    setDocumentMode(true);
-    setFocusPolicy(Qt::NoFocus);
-    setSelectionBehaviorOnRemove(QTabBar::SelectPreviousTab);
-    setElideMode(Qt::ElideLeft);
-
-    setAcceptDrops(true);
-    setMouseTracking(true);
-
-    _mousePressTimer = new QElapsedTimer();
-
-    setWhatsThis(xi18nc("@info:whatsthis",
-                        "<title>Tab Bar</title>"
-                        "<para>The tab bar allows you to switch and move tabs. You can double-click a tab to change its name.</para>"));
-}
-
-ViewContainerTabBar::~ViewContainerTabBar()
-{
-    delete _mousePressTimer;
-}
-
-void ViewContainerTabBar::mousePressEvent(QMouseEvent *event)
-{
-    _mousePressTimer->start();
-
-    if (event->buttons() == Qt::LeftButton) {
-        _dragStart = event->pos();
-    }
-    QTabBar::mousePressEvent(event);
-}
-
-void ViewContainerTabBar::mouseMoveEvent(QMouseEvent *event)
-{
-    if (event->buttons() == Qt::LeftButton) {
-        QPoint dragPos = _dragStart - event->pos();
-        if (dragPos.manhattanLength() > QApplication::startDragDistance()) {
-            int tab = tabAt(_dragStart);
-            if (tab != -1) {
-                emit initiateDrag(tab);
-            }
-        }
-    }
-    QTabBar::mouseMoveEvent(event);
-}
-
-void ViewContainerTabBar::dragEnterEvent(QDragEnterEvent *event)
-{
-    if (event->mimeData()->hasFormat(_supportedMimeType)
-        && event->source() != nullptr) {
-        event->acceptProposedAction();
-    }
-}
-
-void ViewContainerTabBar::dragLeaveEvent(QDragLeaveEvent *)
-{
-    setDropIndicator(-1);
-}
-
-void ViewContainerTabBar::dragMoveEvent(QDragMoveEvent *event)
-{
-    if (event->mimeData()->hasFormat(_supportedMimeType)
-        && event->source() != nullptr) {
-        int index = dropIndex(event->pos());
-        if (index == -1) {
-            index = count();
-        }
-
-        setDropIndicator(index, proposedDropIsSameTab(event));
-
-        event->acceptProposedAction();
-    }
-}
-
-void ViewContainerTabBar::dropEvent(QDropEvent *event)
-{
-    setDropIndicator(-1);
-
-    if (!event->mimeData()->hasFormat(_supportedMimeType)) {
-        event->ignore();
-        return;
-    }
-
-    if (proposedDropIsSameTab(event)) {
-        event->setDropAction(Qt::IgnoreAction);
-        event->accept();
-        return;
-    }
-
-    const int index = dropIndex(event->pos());
-    bool success = false;
-
-    ViewContainerTabBar *sourceContainerTabBar
-        = qobject_cast<ViewContainerTabBar *>(event->source());
-
-    // check if the moved tab is the last of source view.
-    if (sourceContainerTabBar->count() == 1) {
-        TabbedViewContainer *sourceTabbedContainer
-            = sourceContainerTabBar->connectedTabbedViewContainer();
-        emit moveViewRequest(index, event, success, sourceTabbedContainer);
-    } else {
-        emit moveViewRequest(index, event, success, nullptr);
-    }
-
-    if (success) {
-        event->accept();
-    } else {
-        event->ignore();
-    }
-}
-
-TabbedViewContainer *ViewContainerTabBar::connectedTabbedViewContainer()
-{
-    return _connectedContainer;
-}
-
-void ViewContainerTabBar::setDropIndicator(int index, bool drawDisabled)
-{
-    if ((parentWidget() == nullptr) || _dropIndicatorIndex == index) {
-        return;
-    }
-
-    _dropIndicatorIndex = index;
-    const int ARROW_SIZE = 32;
-    const bool north = shape() == QTabBar::RoundedNorth || shape() == QTabBar::TriangularNorth;
-
-    if ((_dropIndicator == nullptr) || _drawIndicatorDisabled != drawDisabled) {
-        if (_dropIndicator == nullptr) {
-            _dropIndicator = new QLabel(parentWidget());
-            _dropIndicator->resize(ARROW_SIZE, ARROW_SIZE);
-        }
-
-        QIcon::Mode drawMode = drawDisabled ? QIcon::Disabled : QIcon::Normal;
-        const QString iconName = north ? QStringLiteral("arrow-up") : QStringLiteral("arrow-down");
-        _dropIndicator->setPixmap(QIcon::fromTheme(iconName).pixmap(ARROW_SIZE, ARROW_SIZE,
-                                                                    drawMode));
-        _drawIndicatorDisabled = drawDisabled;
-    }
-
-    if (index < 0) {
-        _dropIndicator->hide();
-        return;
-    }
-
-    const QRect rect = tabRect(index < count() ? index : index - 1);
-
-    QPoint pos;
-    if (index < count()) {
-        pos = rect.topLeft();
-    } else {
-        pos = rect.topRight();
-    }
-
-    if (north) {
-        pos.ry() += ARROW_SIZE;
-    } else {
-        pos.ry() -= ARROW_SIZE;
-    }
-
-    pos.rx() -= ARROW_SIZE / 2;
-
-    _dropIndicator->move(mapTo(parentWidget(), pos));
-    _dropIndicator->show();
-}
-
-void ViewContainerTabBar::setSupportedMimeType(const QString &mimeType)
-{
-    _supportedMimeType = mimeType;
-}
-
-int ViewContainerTabBar::dropIndex(const QPoint &pos) const
-{
-    int tab = tabAt(pos);
-    if (tab < 0) {
-        return tab;
-    }
-
-    // pick the closest tab boundary
-    QRect rect = tabRect(tab);
-    if ((pos.x() - rect.left()) > (rect.width() / 2)) {
-        tab++;
-    }
-
-    if (tab == count()) {
-        return -1;
-    }
-
-    return tab;
-}
-
-bool ViewContainerTabBar::proposedDropIsSameTab(const QDropEvent *event) const
-{
-    const bool sameTabBar = event->source() == this;
-    if (!sameTabBar) {
-        return false;
-    }
-
-    const int index = dropIndex(event->pos());
-    int sourceIndex = -1;
-    emit querySourceIndex(event, sourceIndex);
-
-    const bool sourceAndDropAreLast = sourceIndex == count() - 1 && index == -1;
-    return sourceIndex == index || sourceIndex == index - 1 || sourceAndDropAreLast;
-}
-
-QPixmap ViewContainerTabBar::dragDropPixmap(int tab)
-{
-    Q_ASSERT(tab >= 0 && tab < count());
-
-    // QWidget::grab() (depreciated QPixmap::grabWidget())
-    // does not show right and bottom edges on certain themes
-    // (curved corners) so increase size of rectangle.
-    const QRect rect = tabRect(tab);
-    const int borderWidth = 1;
-
-    QPixmap tabPixmap(rect.width() + borderWidth,
-                      rect.height() + borderWidth);
-    QPainter painter(&tabPixmap);
-    painter.drawPixmap(0, 0, grab(rect));
-    QPen borderPen;
-    borderPen.setBrush(palette().dark());
-    borderPen.setWidth(borderWidth);
-    painter.setPen(borderPen);
-    painter.drawRect(0, 0, rect.width(), rect.height());
-    painter.end();
-
-    return tabPixmap;
-}
diff --git a/src/ViewContainerTabBar.h b/src/ViewContainerTabBar.h
deleted file mode 100644
index 81663660..00000000
--- a/src/ViewContainerTabBar.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-    This file is part of the Konsole Terminal.
-
-    Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-    02110-1301  USA.
-*/
-
-#ifndef VIEWCONTAINERTABBAR_H
-#define VIEWCONTAINERTABBAR_H
-
-#include <QElapsedTimer>
-#include <QTabBar>
-
-class QLabel;
-
-namespace Konsole {
-class TabbedViewContainer;
-
-class ViewContainerTabBar : public QTabBar
-{
-    Q_OBJECT
-
-public:
-    ViewContainerTabBar(QWidget *parent, TabbedViewContainer *container);
-    ~ViewContainerTabBar() Q_DECL_OVERRIDE;
-
-    // returns a pixmap image of a tab for use with QDrag
-    QPixmap dragDropPixmap(int tab);
-
-    // set the mimetype of which the tabbar support d&d
-    void setSupportedMimeType(const QString &mimeType);
-
-    // return associated tabbed container
-    TabbedViewContainer *connectedTabbedViewContainer();
-
-Q_SIGNALS:
-    void initiateDrag(int index);
-    void querySourceIndex(const QDropEvent *event, int &sourceIndex) const;
-    void moveViewRequest(int index, const QDropEvent *event, bool &success,
-                         TabbedViewContainer *sourceTabbedContainer);
-
-protected:
-    void mousePressEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
-    void mouseMoveEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
-    void dragEnterEvent(QDragEnterEvent *event) Q_DECL_OVERRIDE;
-    void dragLeaveEvent(QDragLeaveEvent *event) Q_DECL_OVERRIDE;
-    void dragMoveEvent(QDragMoveEvent *event) Q_DECL_OVERRIDE;
-    void dropEvent(QDropEvent *event) Q_DECL_OVERRIDE;
-
-private:
-    Q_DISABLE_COPY(ViewContainerTabBar)
-
-    // show the indicator arrow which shows where a dropped tab will
-    // be inserted at 'index'
-    void setDropIndicator(int index, bool drawDisabled = false);
-
-    // returns the index at which a tab will be inserted if the mouse
-    // in a drag-drop operation is released at 'pos'
-    int dropIndex(const QPoint &pos) const;
-
-    // returns true if the tab to be dropped in a drag-drop operation
-    // is the same as the tab at the drop location
-    bool proposedDropIsSameTab(const QDropEvent *event) const;
-
-    QLabel *_dropIndicator;
-    int _dropIndicatorIndex;
-    bool _drawIndicatorDisabled;
-    QString _supportedMimeType;
-    TabbedViewContainer *_connectedContainer;
-    QPoint _dragStart;
-    QElapsedTimer *_mousePressTimer;
-};
-}
-
-#endif  // VIEWCONTAINERTABBAR_H
diff --git a/src/ViewManager.cpp b/src/ViewManager.cpp
index 2871afbe..e99b5181 100644
--- a/src/ViewManager.cpp
+++ b/src/ViewManager.cpp
@@ -1,1234 +1,1097 @@
 /*
     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "ViewManager.h"
 
 #include <config-konsole.h>
 
 // Qt
 #include <QStringList>
 #include <QAction>
 
 // KDE
 #include <KAcceleratorManager>
 #include <KLocalizedString>
 #include <KActionCollection>
 #include <KConfigGroup>
 
 // Konsole
 #include <windowadaptor.h>
 
 #include "ColorScheme.h"
 #include "ColorSchemeManager.h"
 #include "Session.h"
 #include "TerminalDisplay.h"
 #include "SessionController.h"
 #include "SessionManager.h"
 #include "ProfileManager.h"
 #include "ViewSplitter.h"
 #include "Enumeration.h"
+#include "ViewContainer.h"
 
 using namespace Konsole;
 
 int ViewManager::lastManagerId = 0;
 
 ViewManager::ViewManager(QObject *parent, KActionCollection *collection) :
     QObject(parent),
     _viewSplitter(nullptr),
     _pluggedController(nullptr),
     _sessionMap(QHash<TerminalDisplay *, Session *>()),
     _actionCollection(collection),
-    _navigationMethod(TabbedNavigation),
-    _navigationVisibility(ViewContainer::AlwaysShowNavigation),
-    _navigationPosition(ViewContainer::NavigationPositionTop),
-    _showQuickButtons(false),
-    _navigationTabWidthExpanding(true),
-    _newTabBehavior(PutNewTabAtTheEnd),
-    _navigationStyleSheet(QString()),
     _managerId(0)
 {
     // create main view area
     _viewSplitter = new ViewSplitter(nullptr);
     KAcceleratorManager::setNoAccel(_viewSplitter);
 
     // the ViewSplitter class supports both recursive and non-recursive splitting,
     // in non-recursive mode, all containers are inserted into the same top-level splitter
     // widget, and all the divider lines between the containers have the same orientation
     //
     // the ViewManager class is not currently able to handle a ViewSplitter in recursive-splitting
     // mode
     _viewSplitter->setRecursiveSplitting(false);
     _viewSplitter->setFocusPolicy(Qt::NoFocus);
 
     // setup actions which are related to the views
     setupActions();
 
     // emit a signal when all of the views held by this view manager are destroyed
     connect(_viewSplitter.data(), &Konsole::ViewSplitter::allContainersEmpty,
             this, &Konsole::ViewManager::empty);
     connect(_viewSplitter.data(), &Konsole::ViewSplitter::empty, this,
             &Konsole::ViewManager::empty);
 
     // listen for profile changes
     connect(ProfileManager::instance(), &Konsole::ProfileManager::profileChanged,
             this, &Konsole::ViewManager::profileChanged);
     connect(SessionManager::instance(), &Konsole::SessionManager::sessionUpdated,
             this, &Konsole::ViewManager::updateViewsForSession);
 
     //prepare DBus communication
     new WindowAdaptor(this);
 
     _managerId = ++lastManagerId;
     QDBusConnection::sessionBus().registerObject(QLatin1String("/Windows/")
                                                  + QString::number(_managerId), this);
 }
 
 ViewManager::~ViewManager() = default;
 
 int ViewManager::managerId() const
 {
     return _managerId;
 }
 
 QWidget *ViewManager::activeView() const
 {
-    ViewContainer *container = _viewSplitter->activeContainer();
+    TabbedViewContainer *container = _viewSplitter->activeContainer();
     if (container != nullptr) {
-        return container->activeView();
+        return container->currentWidget();
     } else {
         return nullptr;
     }
 }
 
 QWidget *ViewManager::widget() const
 {
     return _viewSplitter;
 }
 
 void ViewManager::setupActions()
 {
     Q_ASSERT(_actionCollection);
     if (_actionCollection == nullptr) {
         return;
     }
 
     KActionCollection *collection = _actionCollection;
 
     QAction *nextViewAction = new QAction(i18nc("@action Shortcut entry", "Next Tab"), this);
     QAction *previousViewAction = new QAction(i18nc("@action Shortcut entry", "Previous Tab"), this);
     QAction *lastViewAction = new QAction(i18nc("@action Shortcut entry",
                                                 "Switch to Last Tab"), this);
     QAction *nextContainerAction = new QAction(i18nc("@action Shortcut entry",
                                                      "Next View Container"), this);
 
     QAction *moveViewLeftAction = new QAction(i18nc("@action Shortcut entry", "Move Tab Left"), this);
     QAction *moveViewRightAction = new QAction(i18nc("@action Shortcut entry",
                                                      "Move Tab Right"), this);
 
     // list of actions that should only be enabled when there are multiple view
     // containers open
     QList<QAction *> multiViewOnlyActions;
     multiViewOnlyActions << nextContainerAction;
 
     QAction *splitLeftRightAction = new QAction(QIcon::fromTheme(QStringLiteral("view-split-left-right")),
                                                 i18nc("@action:inmenu", "Split View Left/Right"),
                                                 this);
     collection->setDefaultShortcut(splitLeftRightAction, Konsole::ACCEL + Qt::Key_ParenLeft);
     collection->addAction(QStringLiteral("split-view-left-right"), splitLeftRightAction);
     connect(splitLeftRightAction, &QAction::triggered, this, &Konsole::ViewManager::splitLeftRight);
 
     QAction *splitTopBottomAction = new QAction(QIcon::fromTheme(QStringLiteral("view-split-top-bottom")),
                                                 i18nc("@action:inmenu",
                                                 "Split View Top/Bottom"), this);
     collection->setDefaultShortcut(splitTopBottomAction, Konsole::ACCEL + Qt::Key_ParenRight);
     collection->addAction(QStringLiteral("split-view-top-bottom"), splitTopBottomAction);
     connect(splitTopBottomAction, &QAction::triggered, this, &Konsole::ViewManager::splitTopBottom);
 
     QAction *closeActiveAction = new QAction(i18nc("@action:inmenu Close Active View", "Close Active"), this);
     closeActiveAction->setIcon(QIcon::fromTheme(QStringLiteral("view-close")));
     collection->setDefaultShortcut(closeActiveAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_X);
     closeActiveAction->setEnabled(false);
     collection->addAction(QStringLiteral("close-active-view"), closeActiveAction);
     connect(closeActiveAction, &QAction::triggered, this,
             &Konsole::ViewManager::closeActiveContainer);
 
     multiViewOnlyActions << closeActiveAction;
 
     QAction *closeOtherAction = new QAction(i18nc("@action:inmenu Close Other Views",
                                                   "Close Others"), this);
     collection->setDefaultShortcut(closeOtherAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_O);
     closeOtherAction->setEnabled(false);
     collection->addAction(QStringLiteral("close-other-views"), closeOtherAction);
     connect(closeOtherAction, &QAction::triggered, this,
             &Konsole::ViewManager::closeOtherContainers);
 
     multiViewOnlyActions << closeOtherAction;
 
     // Expand & Shrink Active View
     QAction *expandActiveAction = new QAction(i18nc("@action:inmenu", "Expand View"), this);
     collection->setDefaultShortcut(expandActiveAction,
                                    Konsole::ACCEL + Qt::SHIFT + Qt::Key_BracketRight);
     expandActiveAction->setEnabled(false);
     collection->addAction(QStringLiteral("expand-active-view"), expandActiveAction);
     connect(expandActiveAction, &QAction::triggered, this,
             &Konsole::ViewManager::expandActiveContainer);
 
     multiViewOnlyActions << expandActiveAction;
 
     QAction *shrinkActiveAction = new QAction(i18nc("@action:inmenu", "Shrink View"), this);
     collection->setDefaultShortcut(shrinkActiveAction,
                                    Konsole::ACCEL + Qt::SHIFT + Qt::Key_BracketLeft);
     shrinkActiveAction->setEnabled(false);
     collection->addAction(QStringLiteral("shrink-active-view"), shrinkActiveAction);
     connect(shrinkActiveAction, &QAction::triggered, this,
             &Konsole::ViewManager::shrinkActiveContainer);
 
     multiViewOnlyActions << shrinkActiveAction;
 
-#if defined(ENABLE_DETACHING)
     QAction *detachViewAction = collection->addAction(QStringLiteral("detach-view"));
+    // Crashes on Mac.
+    detachViewAction->setEnabled(QOperatingSystemVersion::currentType() != QOperatingSystemVersion::MacOS);
     detachViewAction->setIcon(QIcon::fromTheme(QStringLiteral("tab-detach")));
     detachViewAction->setText(i18nc("@action:inmenu", "D&etach Current Tab"));
     // Ctrl+Shift+D is not used as a shortcut by default because it is too close
     // to Ctrl+D - which will terminate the session in many cases
     collection->setDefaultShortcut(detachViewAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_H);
 
     connect(this, &Konsole::ViewManager::splitViewToggle, this,
             &Konsole::ViewManager::updateDetachViewState);
     connect(detachViewAction, &QAction::triggered, this, &Konsole::ViewManager::detachActiveView);
-#endif
 
     // Next / Previous View , Next Container
     collection->addAction(QStringLiteral("next-view"), nextViewAction);
     collection->addAction(QStringLiteral("previous-view"), previousViewAction);
     collection->addAction(QStringLiteral("last-tab"), lastViewAction);
     collection->addAction(QStringLiteral("next-container"), nextContainerAction);
     collection->addAction(QStringLiteral("move-view-left"), moveViewLeftAction);
     collection->addAction(QStringLiteral("move-view-right"), moveViewRightAction);
 
     // Switch to tab N shortcuts
     const int SWITCH_TO_TAB_COUNT = 19;
     for (int i = 0; i < SWITCH_TO_TAB_COUNT; i++) {
         QAction *switchToTabAction = new QAction(i18nc("@action Shortcut entry", "Switch to Tab %1", i + 1), this);
 
         connect(switchToTabAction, &QAction::triggered, this,
            [this, i]() {
                switchToView(i);
            });
         collection->addAction(QStringLiteral("switch-to-tab-%1").arg(i), switchToTabAction);
     }
 
     foreach (QAction *action, multiViewOnlyActions) {
         connect(this, &Konsole::ViewManager::splitViewToggle, action, &QAction::setEnabled);
     }
 
     // keyboard shortcut only actions
     const QList<QKeySequence> nextViewActionKeys{Qt::SHIFT + Qt::Key_Right, Qt::CTRL + Qt::Key_PageDown};
     collection->setDefaultShortcuts(nextViewAction, nextViewActionKeys);
     connect(nextViewAction, &QAction::triggered, this, &Konsole::ViewManager::nextView);
     _viewSplitter->addAction(nextViewAction);
 
     const QList<QKeySequence> previousViewActionKeys{Qt::SHIFT + Qt::Key_Left, Qt::CTRL + Qt::Key_PageUp};
     collection->setDefaultShortcuts(previousViewAction, previousViewActionKeys);
     connect(previousViewAction, &QAction::triggered, this, &Konsole::ViewManager::previousView);
     _viewSplitter->addAction(previousViewAction);
 
     collection->setDefaultShortcut(nextContainerAction, Qt::SHIFT + Qt::Key_Tab);
     connect(nextContainerAction, &QAction::triggered, this, &Konsole::ViewManager::nextContainer);
     _viewSplitter->addAction(nextContainerAction);
 
 #ifdef Q_OS_MACOS
     collection->setDefaultShortcut(moveViewLeftAction,
                                    Konsole::ACCEL + Qt::SHIFT + Qt::Key_BracketLeft);
 #else
     collection->setDefaultShortcut(moveViewLeftAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_Left);
 #endif
     connect(moveViewLeftAction, &QAction::triggered, this,
             &Konsole::ViewManager::moveActiveViewLeft);
     _viewSplitter->addAction(moveViewLeftAction);
 
 #ifdef Q_OS_MACOS
     collection->setDefaultShortcut(moveViewRightAction,
                                    Konsole::ACCEL + Qt::SHIFT + Qt::Key_BracketRight);
 #else
     collection->setDefaultShortcut(moveViewRightAction, Konsole::ACCEL + Qt::SHIFT + Qt::Key_Right);
 #endif
     connect(moveViewRightAction, &QAction::triggered, this,
             &Konsole::ViewManager::moveActiveViewRight);
     _viewSplitter->addAction(moveViewRightAction);
 
     connect(lastViewAction, &QAction::triggered, this, &Konsole::ViewManager::lastView);
     _viewSplitter->addAction(lastViewAction);
 }
 
 void ViewManager::switchToView(int index)
 {
-    Q_ASSERT(index >= 0);
-    ViewContainer *container = _viewSplitter->activeContainer();
-    Q_ASSERT(container);
-    QList<QWidget *> containerViews = container->views();
-    if (index >= containerViews.count()) {
-        return;
-    }
-    container->setActiveView(containerViews.at(index));
+    _viewSplitter->activeContainer()->setCurrentIndex(index);
 }
 
 void ViewManager::updateDetachViewState()
 {
     Q_ASSERT(_actionCollection);
     if (_actionCollection == nullptr) {
         return;
     }
 
     const bool splitView = _viewSplitter->containers().count() >= 2;
     auto activeContainer = _viewSplitter->activeContainer();
     const bool shouldEnable = splitView
                               || ((activeContainer != nullptr)
-                                  && activeContainer->views().count() >= 2);
+                                  && activeContainer->count() >= 2);
 
     QAction *detachAction = _actionCollection->action(QStringLiteral("detach-view"));
 
     if ((detachAction != nullptr) && shouldEnable != detachAction->isEnabled()) {
         detachAction->setEnabled(shouldEnable);
     }
 }
 
 void ViewManager::moveActiveViewLeft()
 {
-    ViewContainer *container = _viewSplitter->activeContainer();
+    TabbedViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
-    container->moveActiveView(ViewContainer::MoveViewLeft);
+    container->moveActiveView(TabbedViewContainer::MoveViewLeft);
 }
 
 void ViewManager::moveActiveViewRight()
 {
-    ViewContainer *container = _viewSplitter->activeContainer();
+    TabbedViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
-    container->moveActiveView(ViewContainer::MoveViewRight);
+    container->moveActiveView(TabbedViewContainer::MoveViewRight);
 }
 
 void ViewManager::nextContainer()
 {
     _viewSplitter->activateNextContainer();
 }
 
 void ViewManager::nextView()
 {
-    ViewContainer *container = _viewSplitter->activeContainer();
-
+    TabbedViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
-
     container->activateNextView();
 }
 
 void ViewManager::previousView()
 {
-    ViewContainer *container = _viewSplitter->activeContainer();
-
+    TabbedViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
-
     container->activatePreviousView();
 }
 
 void ViewManager::lastView()
 {
-    ViewContainer *container = _viewSplitter->activeContainer();
-
+    TabbedViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
-
     container->activateLastView();
 }
 
 void ViewManager::detachActiveView()
 {
     // find the currently active view and remove it from its container
-    ViewContainer *container = _viewSplitter->activeContainer();
-
-    detachView(container, container->activeView());
+    TabbedViewContainer *container = _viewSplitter->activeContainer();
+    detachView(container, container->currentWidget());
 }
 
-void ViewManager::detachView(ViewContainer *container, QWidget *view)
+void ViewManager::detachView(TabbedViewContainer *container, QWidget *view)
 {
-#if !defined(ENABLE_DETACHING)
-    return;
-#endif
-
     TerminalDisplay *viewToDetach = qobject_cast<TerminalDisplay *>(view);
 
     if (viewToDetach == nullptr) {
         return;
     }
 
     // BR390736 - some instances are sending invalid session to viewDetached()
     Session *sessionToDetach = _sessionMap[viewToDetach];
     if (sessionToDetach == nullptr) {
         return;
     }
     emit viewDetached(sessionToDetach);
 
     _sessionMap.remove(viewToDetach);
 
     // remove the view from this window
     container->removeView(viewToDetach);
     viewToDetach->deleteLater();
 
     // if the container from which the view was removed is now empty then it can be deleted,
     // unless it is the only container in the window, in which case it is left empty
     // so that there is always an active container
     if (_viewSplitter->containers().count() > 1
-        && container->views().count() == 0) {
+        && container->count() == 0) {
         removeContainer(container);
     }
 }
 
 void ViewManager::sessionFinished()
 {
     // if this slot is called after the view manager's main widget
     // has been destroyed, do nothing
     if (_viewSplitter.isNull()) {
         return;
     }
 
     Session *session = qobject_cast<Session *>(sender());
     Q_ASSERT(session);
 
     // close attached views
     QList<TerminalDisplay *> children = _viewSplitter->findChildren<TerminalDisplay *>();
 
     foreach (TerminalDisplay *view, children) {
         if (_sessionMap[view] == session) {
             _sessionMap.remove(view);
             view->deleteLater();
         }
     }
 
     // Only remove the controller from factory() if it's actually controlling
     // the session from the sender.
     // This fixes BUG: 348478 - messed up menus after a detached tab is closed
     if ((!_pluggedController.isNull()) && (_pluggedController->session() == session)) {
         // This is needed to remove this controller from factory() in
         // order to prevent BUG: 185466 - disappearing menu popup
         emit unplugController(_pluggedController);
     }
 }
 
 void ViewManager::viewActivated(QWidget *view)
 {
     Q_ASSERT(view != nullptr);
 
     // focus the activated view, this will cause the SessionController
     // to notify the world that the view has been focused and the appropriate UI
     // actions will be plugged in.
     view->setFocus(Qt::OtherFocusReason);
 }
 
 void ViewManager::splitLeftRight()
 {
     splitView(Qt::Horizontal);
 }
 
 void ViewManager::splitTopBottom()
 {
     splitView(Qt::Vertical);
 }
 
 void ViewManager::splitView(Qt::Orientation orientation)
 {
-    ViewContainer *container = createContainer();
+    TabbedViewContainer *container = createContainer();
 
     // iterate over each session which has a view in the current active
     // container and create a new view for that session in a new container
-    foreach (QWidget *view, _viewSplitter->activeContainer()->views()) {
+    for(int i = 0, end = _viewSplitter->activeContainer()->count(); i < end; i++) {
+        auto view = _viewSplitter->activeContainer()->widget(i);
         Session *session = _sessionMap[qobject_cast<TerminalDisplay *>(view)];
         TerminalDisplay *display = createTerminalDisplay(session);
         const Profile::Ptr profile = SessionManager::instance()->sessionProfile(session);
         applyProfileToView(display, profile);
         ViewProperties *properties = createController(session, display);
 
         _sessionMap[display] = session;
 
         container->addView(display, properties);
         session->addView(display);
     }
 
     _viewSplitter->addContainer(container, orientation);
     emit splitViewToggle(_viewSplitter->containers().count() > 0);
 
     // focus the new container
-    container->containerWidget()->setFocus();
+    container->currentWidget()->setFocus();
 
     // ensure that the active view is focused after the split / unsplit
-    ViewContainer *activeContainer = _viewSplitter->activeContainer();
-    QWidget *activeView = activeContainer != nullptr ? activeContainer->activeView() : nullptr;
+    TabbedViewContainer *activeContainer = _viewSplitter->activeContainer();
+    QWidget *activeView = activeContainer != nullptr ? activeContainer->currentWidget() : nullptr;
 
     if (activeView != nullptr) {
         activeView->setFocus(Qt::OtherFocusReason);
     }
 }
 
-void ViewManager::removeContainer(ViewContainer *container)
+void ViewManager::removeContainer(TabbedViewContainer *container)
 {
     // remove session map entries for views in this container
-    foreach (QWidget *view, container->views()) {
+    for(int i = 0, end = container->count(); i < end; i++) {
+        auto view = container->widget(i);
         TerminalDisplay *display = qobject_cast<TerminalDisplay *>(view);
         Q_ASSERT(display);
         _sessionMap.remove(display);
     }
 
     _viewSplitter->removeContainer(container);
     container->deleteLater();
 
     emit splitViewToggle(_viewSplitter->containers().count() > 1);
 }
 
 void ViewManager::expandActiveContainer()
 {
     _viewSplitter->adjustContainerSize(_viewSplitter->activeContainer(), 10);
 }
 
 void ViewManager::shrinkActiveContainer()
 {
     _viewSplitter->adjustContainerSize(_viewSplitter->activeContainer(), -10);
 }
 
 void ViewManager::closeActiveContainer()
 {
     // only do something if there is more than one container active
     if (_viewSplitter->containers().count() > 1) {
-        ViewContainer *container = _viewSplitter->activeContainer();
+        TabbedViewContainer *container = _viewSplitter->activeContainer();
 
         removeContainer(container);
 
         // focus next container so that user can continue typing
         // without having to manually focus it themselves
         nextContainer();
     }
 }
 
 void ViewManager::closeOtherContainers()
 {
-    ViewContainer *active = _viewSplitter->activeContainer();
+    TabbedViewContainer *active = _viewSplitter->activeContainer();
 
-    foreach (ViewContainer *container, _viewSplitter->containers()) {
+    foreach (TabbedViewContainer *container, _viewSplitter->containers()) {
         if (container != active) {
             removeContainer(container);
         }
     }
 }
 
 SessionController *ViewManager::createController(Session *session, TerminalDisplay *view)
 {
     // create a new controller for the session, and ensure that this view manager
     // is notified when the view gains the focus
     auto controller = new SessionController(session, view, this);
     connect(controller, &Konsole::SessionController::focused, this,
             &Konsole::ViewManager::controllerChanged);
     connect(session, &Konsole::Session::destroyed, controller,
             &Konsole::SessionController::deleteLater);
     connect(session, &Konsole::Session::primaryScreenInUse, controller,
             &Konsole::SessionController::setupPrimaryScreenSpecificActions);
     connect(session, &Konsole::Session::selectionChanged, controller,
             &Konsole::SessionController::selectionChanged);
     connect(view, &Konsole::TerminalDisplay::destroyed, controller,
             &Konsole::SessionController::deleteLater);
 
     // if this is the first controller created then set it as the active controller
     if (_pluggedController.isNull()) {
         controllerChanged(controller);
     }
 
     return controller;
 }
 
 void ViewManager::controllerChanged(SessionController *controller)
 {
     if (controller == _pluggedController) {
         return;
     }
 
     _viewSplitter->setFocusProxy(controller->view());
 
     _pluggedController = controller;
     emit activeViewChanged(controller);
 }
 
 SessionController *ViewManager::activeViewController() const
 {
     return _pluggedController;
 }
 
-IncrementalSearchBar *ViewManager::searchBar() const
-{
-    return _viewSplitter->activeSplitter()->activeContainer()->searchBar();
-}
-
-void ViewManager::createView(Session *session, ViewContainer *container, int index)
+void ViewManager::createView(Session *session, TabbedViewContainer *container, int index)
 {
     // notify this view manager when the session finishes so that its view
     // can be deleted
     //
     // Use Qt::UniqueConnection to avoid duplicate connection
     connect(session, &Konsole::Session::finished, this, &Konsole::ViewManager::sessionFinished,
             Qt::UniqueConnection);
 
     TerminalDisplay *display = createTerminalDisplay(session);
     const Profile::Ptr profile = SessionManager::instance()->sessionProfile(session);
     applyProfileToView(display, profile);
 
     // set initial size
     const QSize &preferredSize = session->preferredSize();
-    // FIXME: +1 is needed here for getting the expected rows
-    // Note that the display shouldn't need to take into account the tabbar.
-    // However, it appears that taking into account the tabbar is needed.
-    // If tabbar is not visible, no +1 is needed here; however, depending on
-    // settings/tabbar style, +2 might be needed.
-    // 1st attempt at fixing the above:
-    // Guess if tabbar will NOT be visible; ignore ShowNavigationAsNeeded
-    int heightAdjustment = 0;
-    if (_navigationVisibility != ViewContainer::AlwaysHideNavigation) {
-        heightAdjustment = 2;
-    }
 
-    display->setSize(preferredSize.width(), preferredSize.height() + heightAdjustment);
+    display->setSize(preferredSize.width(), preferredSize.height());
     ViewProperties *properties = createController(session, display);
 
     _sessionMap[display] = session;
     container->addView(display, properties, index);
     session->addView(display);
 
     // tell the session whether it has a light or dark background
     session->setDarkBackground(colorSchemeForProfile(profile)->hasDarkBackground());
 
     if (container == _viewSplitter->activeContainer()) {
-        container->setActiveView(display);
+        container->setCurrentWidget(display);
         display->setFocus(Qt::OtherFocusReason);
     }
 
     updateDetachViewState();
 }
 
 void ViewManager::createView(Session *session)
 {
     // create the default container
     if (_viewSplitter->containers().count() == 0) {
-        ViewContainer *container = createContainer();
+        TabbedViewContainer *container = createContainer();
         _viewSplitter->addContainer(container, Qt::Vertical);
         emit splitViewToggle(false);
     }
 
     // new tab will be put at the end by default.
     int index = -1;
 
-    if (_newTabBehavior == PutNewTabAfterCurrentTab) {
-        QWidget *view = activeView();
-        if (view != nullptr) {
-            QList<QWidget *> views = _viewSplitter->activeContainer()->views();
-            index = views.indexOf(view) + 1;
-        }
-    }
-
     // iterate over the view containers owned by this view manager
     // and create a new terminal display for the session in each of them, along with
     // a controller for the session/display pair
-    foreach (ViewContainer *container, _viewSplitter->containers()) {
+    foreach (TabbedViewContainer *container, _viewSplitter->containers()) {
         createView(session, container, index);
     }
 }
 
-ViewContainer *ViewManager::createContainer()
+TabbedViewContainer *ViewManager::createContainer()
 {
 
-    auto *container = new TabbedViewContainer(_navigationPosition, this, _viewSplitter);
-    if (_navigationMethod == TabbedNavigation) {
-        connect(container, &TabbedViewContainer::detachTab, this, &ViewManager::detachView);
-        connect(container, &TabbedViewContainer::closeTab, this,
-                &ViewManager::closeTabFromContainer);
-    }
-
-    // FIXME: these code feels duplicated
-    container->setNavigationVisibility(_navigationVisibility);
-    container->setNavigationPosition(_navigationPosition);
-    container->setNavigationTabWidthExpanding(_navigationTabWidthExpanding);
-    container->setStyleSheet(_navigationStyleSheet);
-    setContainerFeatures(container);
+    auto *container = new TabbedViewContainer(this, _viewSplitter);
+    //TODO: Fix Detaching.
+    connect(container, &TabbedViewContainer::detachTab, this, &ViewManager::detachView);
 
     // connect signals and slots
-    connect(container, &Konsole::ViewContainer::viewAdded, this,
+    connect(container, &Konsole::TabbedViewContainer::viewAdded, this,
            [this, container]() {
                containerViewsChanged(container);
            });
 
-    connect(container, &Konsole::ViewContainer::viewRemoved, this,
+    connect(container, &Konsole::TabbedViewContainer::viewRemoved, this,
            [this, container]() {
                containerViewsChanged(container);
            });
 
     connect(container,
-            static_cast<void (ViewContainer::*)()>(&Konsole::ViewContainer::newViewRequest), this,
+            static_cast<void (TabbedViewContainer::*)()>(&Konsole::TabbedViewContainer::newViewRequest), this,
             static_cast<void (ViewManager::*)()>(&Konsole::ViewManager::newViewRequest));
     connect(container,
-            static_cast<void (ViewContainer::*)(Profile::Ptr)>(&Konsole::ViewContainer::newViewRequest),
+            static_cast<void (TabbedViewContainer::*)(Profile::Ptr)>(&Konsole::TabbedViewContainer::newViewRequest),
             this,
             static_cast<void (ViewManager::*)(Profile::Ptr)>(&Konsole::ViewManager::newViewRequest));
-    connect(container, &Konsole::ViewContainer::moveViewRequest, this,
+    connect(container, &Konsole::TabbedViewContainer::moveViewRequest, this,
             &Konsole::ViewManager::containerMoveViewRequest);
-    connect(container, &Konsole::ViewContainer::viewRemoved, this,
+    connect(container, &Konsole::TabbedViewContainer::viewRemoved, this,
             &Konsole::ViewManager::viewDestroyed);
-    connect(container, &Konsole::ViewContainer::activeViewChanged, this,
+    connect(container, &Konsole::TabbedViewContainer::activeViewChanged, this,
             &Konsole::ViewManager::viewActivated);
 
-    if (_navigationMethod != TabbedNavigation) {
-        container->setTabBarVisible(false);
-    }
-
     return container;
 }
 
 void ViewManager::containerMoveViewRequest(int index, int id, bool &success,
                                            TabbedViewContainer *sourceTabbedContainer)
 {
-    ViewContainer *container = qobject_cast<ViewContainer *>(sender());
+    TabbedViewContainer *container = qobject_cast<TabbedViewContainer *>(sender());
     SessionController *controller = qobject_cast<SessionController *>(ViewProperties::propertiesById(id));
 
     if (controller == nullptr) {
         return;
     }
 
     // do not move the last tab in a split view.
     if (sourceTabbedContainer != nullptr) {
-        QPointer<ViewContainer> sourceContainer = qobject_cast<ViewContainer *>(sourceTabbedContainer);
+        QPointer<TabbedViewContainer> sourceContainer = qobject_cast<TabbedViewContainer *>(sourceTabbedContainer);
 
         if (_viewSplitter->containers().contains(sourceContainer)) {
             return;
         } else {
             ViewManager *sourceViewManager = sourceTabbedContainer->connectedViewManager();
 
             // do not remove the last tab on the window
             if (qobject_cast<ViewSplitter *>(sourceViewManager->widget())->containers().size() > 1) {
                 return;
             }
         }
     }
 
     createView(controller->session(), container, index);
     controller->session()->refresh();
     success = true;
 }
 
 void ViewManager::setNavigationMethod(NavigationMethod method)
 {
     Q_ASSERT(_actionCollection);
     if (_actionCollection == nullptr) {
         return;
     }
-    _navigationMethod = method;
-
     KActionCollection *collection = _actionCollection;
 
     // FIXME: The following disables certain actions for the KPart that it
     // doesn't actually have a use for, to avoid polluting the action/shortcut
     // namespace of an application using the KPart (otherwise, a shortcut may
     // be in use twice, and the user gets to see an "ambiguous shortcut over-
     // load" error dialog). However, this approach sucks - it's the inverse of
     // what it should be. Rather than disabling actions not used by the KPart,
     // a method should be devised to only enable those that are used, perhaps
     // by using a separate action collection.
 
-    const bool enable = (_navigationMethod != NoNavigation);
+    const bool enable = (method != NoNavigation);
 
     auto enableAction = [&enable, &collection](const QString& actionName) {
         auto *action = collection->action(actionName);
         if (action != nullptr) {
             action->setEnabled(enable);
         }
     };
 
     enableAction(QStringLiteral("next-view"));
     enableAction(QStringLiteral("previous-view"));
     enableAction(QStringLiteral("last-tab"));
     enableAction(QStringLiteral("split-view-left-right"));
     enableAction(QStringLiteral("split-view-top-bottom"));
     enableAction(QStringLiteral("rename-session"));
     enableAction(QStringLiteral("move-view-left"));
     enableAction(QStringLiteral("move-view-right"));
 }
 
 ViewManager::NavigationMethod ViewManager::navigationMethod() const
 {
     return _navigationMethod;
 }
 
-void ViewManager::containerViewsChanged(ViewContainer *container)
+void ViewManager::containerViewsChanged(TabbedViewContainer *container)
 {
     if ((!_viewSplitter.isNull()) && container == _viewSplitter->activeContainer()) {
         emit viewPropertiesChanged(viewProperties());
     }
 }
 
 void ViewManager::viewDestroyed(QWidget *view)
 {
     // Note: the received QWidget has already been destroyed, so
     // using dynamic_cast<> or qobject_cast<> does not work here
     // We only need the pointer address to look it up below
     TerminalDisplay *display = reinterpret_cast<TerminalDisplay *>(view);
 
     // 1. detach view from session
     // 2. if the session has no views left, close it
     Session *session = _sessionMap[ display ];
     _sessionMap.remove(display);
     if (session != nullptr) {
         if (session->views().count() == 0) {
             session->close();
         }
     }
     //we only update the focus if the splitter is still alive
     if (!_viewSplitter.isNull()) {
         updateDetachViewState();
     }
     // The below causes the menus  to be messed up
     // Only happens when using the tab bar close button
 //    if (_pluggedController)
 //        emit unplugController(_pluggedController);
 }
 
 TerminalDisplay *ViewManager::createTerminalDisplay(Session *session)
 {
     auto display = new TerminalDisplay(nullptr);
     display->setRandomSeed(session->sessionId() * 31);
 
     return display;
 }
 
 const ColorScheme *ViewManager::colorSchemeForProfile(const Profile::Ptr profile)
 {
     const ColorScheme *colorScheme = ColorSchemeManager::instance()->
                                      findColorScheme(profile->colorScheme());
     if (colorScheme == nullptr) {
         colorScheme = ColorSchemeManager::instance()->defaultColorScheme();
     }
     Q_ASSERT(colorScheme);
 
     return colorScheme;
 }
 
 bool ViewManager::profileHasBlurEnabled(const Profile::Ptr profile)
 {
     return colorSchemeForProfile(profile)->blur();
 }
 
 void ViewManager::applyProfileToView(TerminalDisplay *view, const Profile::Ptr profile)
 {
     Q_ASSERT(profile);
 
     emit updateWindowIcon();
 
     // load color scheme
     ColorEntry table[TABLE_COLORS];
     const ColorScheme *colorScheme = colorSchemeForProfile(profile);
     colorScheme->getColorTable(table, view->randomSeed());
     view->setColorTable(table);
     view->setOpacity(colorScheme->opacity());
     view->setWallpaper(colorScheme->wallpaper());
 
     emit blurSettingChanged(colorScheme->blur());
 
     // load font
     view->setAntialias(profile->antiAliasFonts());
     view->setBoldIntense(profile->boldIntense());
     view->setUseFontLineCharacters(profile->useFontLineCharacters());
     view->setVTFont(profile->font());
 
     // set scroll-bar position
     view->setScrollBarPosition(Enum::ScrollBarPositionEnum(profile->property<int>(Profile::ScrollBarPosition)));
     view->setScrollFullPage(profile->property<bool>(Profile::ScrollFullPage));
 
     // show hint about terminal size after resizing
     view->setShowTerminalSizeHint(profile->showTerminalSizeHint());
 
     // terminal features
     view->setBlinkingCursorEnabled(profile->blinkingCursorEnabled());
     view->setBlinkingTextEnabled(profile->blinkingTextEnabled());
     view->setTripleClickMode(Enum::TripleClickModeEnum(profile->property<int>(Profile::TripleClickMode)));
     view->setAutoCopySelectedText(profile->autoCopySelectedText());
     view->setControlDrag(profile->property<bool>(Profile::CtrlRequiredForDrag));
     view->setDropUrlsAsText(profile->property<bool>(Profile::DropUrlsAsText));
     view->setBidiEnabled(profile->bidiRenderingEnabled());
     view->setLineSpacing(profile->lineSpacing());
     view->setTrimLeadingSpaces(profile->property<bool>(Profile::TrimLeadingSpacesInSelectedText));
     view->setTrimTrailingSpaces(profile->property<bool>(Profile::TrimTrailingSpacesInSelectedText));
     view->setOpenLinksByDirectClick(profile->property<bool>(Profile::OpenLinksByDirectClickEnabled));
     view->setUrlHintsModifiers(profile->property<int>(Profile::UrlHintsModifiers));
     view->setMiddleClickPasteMode(Enum::MiddleClickPasteModeEnum(profile->property<int>(Profile::MiddleClickPasteMode)));
     view->setCopyTextAsHTML(profile->property<bool>(Profile::CopyTextAsHTML));
 
     // margin/center
     view->setMargin(profile->property<int>(Profile::TerminalMargin));
     view->setCenterContents(profile->property<bool>(Profile::TerminalCenter));
 
     // cursor shape
     view->setKeyboardCursorShape(Enum::CursorShapeEnum(profile->property<int>(Profile::CursorShape)));
 
     // cursor color
     // an invalid QColor is used to inform the view widget to
     // draw the cursor using the default color( matching the text)
     view->setKeyboardCursorColor(profile->useCustomCursorColor() ? profile->customCursorColor() : QColor());
 
     // word characters
     view->setWordCharacters(profile->wordCharacters());
 
     // bell mode
     view->setBellMode(profile->property<int>(Profile::BellMode));
 
     // mouse wheel zoom
     view->setMouseWheelZoom(profile->mouseWheelZoomEnabled());
     view->setAlternateScrolling(profile->property<bool>(Profile::AlternateScrolling));
 }
 
 void ViewManager::updateViewsForSession(Session *session)
 {
     const Profile::Ptr profile = SessionManager::instance()->sessionProfile(session);
 
     const QList<TerminalDisplay *> sessionMapKeys = _sessionMap.keys(session);
     foreach (TerminalDisplay *view, sessionMapKeys) {
         applyProfileToView(view, profile);
     }
 }
 
 void ViewManager::profileChanged(Profile::Ptr profile)
 {
     // update all views associated with this profile
     QHashIterator<TerminalDisplay *, Session *> iter(_sessionMap);
     while (iter.hasNext()) {
         iter.next();
 
         // if session uses this profile, update the display
         if (iter.key() != nullptr
             && iter.value() != nullptr
             && SessionManager::instance()->sessionProfile(iter.value()) == profile) {
             applyProfileToView(iter.key(), profile);
         }
     }
 }
 
 QList<ViewProperties *> ViewManager::viewProperties() const
 {
     QList<ViewProperties *> list;
 
-    ViewContainer *container = _viewSplitter->activeContainer();
+    TabbedViewContainer *container = _viewSplitter->activeContainer();
 
     Q_ASSERT(container);
+    list.reserve(container->count());
 
-    foreach (QWidget *view, container->views()) {
+    for(int i = 0, end = container->count(); i < end; i++) {
+        auto view = container->widget(i);
         ViewProperties *properties = container->viewProperties(view);
         Q_ASSERT(properties);
         list << properties;
     }
 
     return list;
 }
 
 void ViewManager::saveSessions(KConfigGroup &group)
 {
     // find all unique session restore IDs
     QList<int> ids;
     QSet<Session *> unique;
+    int tab = 1;
+
+    TabbedViewContainer *container = _viewSplitter->activeContainer();
+    ids.reserve(container->count());
 
     // first: sessions in the active container, preserving the order
-    ViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
     if (container == nullptr) {
         return;
     }
-    TerminalDisplay *activeview = qobject_cast<TerminalDisplay *>(container->activeView());
 
-    QListIterator<QWidget *> viewIter(container->views());
-    int tab = 1;
-    while (viewIter.hasNext()) {
-        TerminalDisplay *view = qobject_cast<TerminalDisplay *>(viewIter.next());
+    TerminalDisplay *activeview = qobject_cast<TerminalDisplay *>(container->currentWidget());
+    for (int i = 0, end = container->count(); i < end; i++) {
+        TerminalDisplay *view = qobject_cast<TerminalDisplay *>(container->widget(i));
         Q_ASSERT(view);
+
         Session *session = _sessionMap[view];
         ids << SessionManager::instance()->getRestoreId(session);
         unique.insert(session);
         if (view == activeview) {
             group.writeEntry("Active", tab);
         }
         tab++;
     }
 
     // second: all other sessions, in random order
     // we don't want to have sessions restored that are not connected
     foreach (Session *session, _sessionMap) {
         if (!unique.contains(session)) {
             ids << SessionManager::instance()->getRestoreId(session);
             unique.insert(session);
         }
     }
 
     group.writeEntry("Sessions", ids);
 }
 
 void ViewManager::restoreSessions(const KConfigGroup &group)
 {
     QList<int> ids = group.readEntry("Sessions", QList<int>());
     int activeTab = group.readEntry("Active", 0);
     TerminalDisplay *display = nullptr;
 
     int tab = 1;
     foreach (int id, ids) {
         Session *session = SessionManager::instance()->idToSession(id);
 
         if (session == nullptr) {
             qWarning() << "Unable to load session with id" << id;
             // Force a creation of a default session below
             ids.clear();
             break;
         }
 
         createView(session);
         if (!session->isRunning()) {
             session->run();
         }
         if (tab++ == activeTab) {
             display = qobject_cast<TerminalDisplay *>(activeView());
         }
     }
 
     if (display != nullptr) {
-        _viewSplitter->activeContainer()->setActiveView(display);
+        _viewSplitter->activeContainer()->setCurrentWidget(display);
         display->setFocus(Qt::OtherFocusReason);
     }
 
     if (ids.isEmpty()) { // Session file is unusable, start default Profile
         Profile::Ptr profile = ProfileManager::instance()->defaultProfile();
         Session *session = SessionManager::instance()->createSession(profile);
         createView(session);
         if (!session->isRunning()) {
             session->run();
         }
     }
 }
 
 int ViewManager::sessionCount()
 {
     return _sessionMap.size();
 }
 
 QStringList ViewManager::sessionList()
 {
     QStringList ids;
 
     QHash<TerminalDisplay *, Session *>::const_iterator i;
     for (i = _sessionMap.constBegin(); i != _sessionMap.constEnd(); ++i) {
         ids.append(QString::number(i.value()->sessionId()));
     }
 
     return ids;
 }
 
 int ViewManager::currentSession()
 {
     QHash<TerminalDisplay *, Session *>::const_iterator i;
     for (i = _sessionMap.constBegin(); i != _sessionMap.constEnd(); ++i) {
         if (i.key()->isVisible()) {
             return i.value()->sessionId();
         }
     }
     return -1;
 }
 
 void ViewManager::setCurrentSession(int sessionId)
 {
     QHash<TerminalDisplay *, Session *>::const_iterator i;
     for (i = _sessionMap.constBegin(); i != _sessionMap.constEnd(); ++i) {
         if (i.value()->sessionId() == sessionId) {
-            ViewContainer *container = _viewSplitter->activeContainer();
+            TabbedViewContainer *container = _viewSplitter->activeContainer();
             if (container != nullptr) {
-                container->setActiveView(i.key());
+                container->setCurrentWidget(i.key());
             }
         }
     }
 }
 
 int ViewManager::newSession()
 {
     Profile::Ptr profile = ProfileManager::instance()->defaultProfile();
     Session *session = SessionManager::instance()->createSession(profile);
 
     session->addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_WINDOW=/Windows/%1").arg(managerId()));
 
     createView(session);
     session->run();
 
     return session->sessionId();
 }
 
 int ViewManager::newSession(const QString &profile)
 {
     const QList<Profile::Ptr> profilelist = ProfileManager::instance()->allProfiles();
     Profile::Ptr profileptr = ProfileManager::instance()->defaultProfile();
 
     for (const auto &i : profilelist) {
         if (i->name() == profile) {
             profileptr = i;
             break;
         }
     }
 
     Session *session = SessionManager::instance()->createSession(profileptr);
 
     session->addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_WINDOW=/Windows/%1").arg(managerId()));
 
     createView(session);
     session->run();
 
     return session->sessionId();
 }
 
 int ViewManager::newSession(const QString &profile, const QString &directory)
 {
     const QList<Profile::Ptr> profilelist = ProfileManager::instance()->allProfiles();
     Profile::Ptr profileptr = ProfileManager::instance()->defaultProfile();
 
     for (const auto &i : profilelist) {
         if (i->name() == profile) {
             profileptr = i;
             break;
         }
     }
 
     Session *session = SessionManager::instance()->createSession(profileptr);
     session->setInitialWorkingDirectory(directory);
 
     session->addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_WINDOW=/Windows/%1").arg(managerId()));
 
     createView(session);
     session->run();
 
     return session->sessionId();
 }
 
 QString ViewManager::defaultProfile()
 {
     return ProfileManager::instance()->defaultProfile()->name();
 }
 
 QStringList ViewManager::profileList()
 {
     return ProfileManager::instance()->availableProfileNames();
 }
 
 void ViewManager::nextSession()
 {
     nextView();
 }
 
 void ViewManager::prevSession()
 {
     previousView();
 }
 
 void ViewManager::moveSessionLeft()
 {
     moveActiveViewLeft();
 }
 
 void ViewManager::moveSessionRight()
 {
     moveActiveViewRight();
 }
-
-void ViewManager::setTabWidthToText(bool useTextWidth)
-{
-    ViewContainer *container = _viewSplitter->activeContainer();
-    Q_ASSERT(container);
-    container->setNavigationTextMode(useTextWidth);
-}
-
-void ViewManager::closeTabFromContainer(ViewContainer *container, QWidget *tab)
-{
-    SessionController *controller = qobject_cast<SessionController *>(container->viewProperties(tab));
-    Q_ASSERT(controller);
-    if (controller != nullptr) {
-        controller->closeSession();
-    }
-}
-
-void ViewManager::setNavigationVisibility(int visibility)
-{
-    _navigationVisibility = static_cast<ViewContainer::NavigationVisibility>(visibility);
-
-    foreach (ViewContainer *container, _viewSplitter->containers()) {
-        container->setNavigationVisibility(_navigationVisibility);
-    }
-}
-
-void ViewManager::setNavigationPosition(int position)
-{
-    _navigationPosition = static_cast<ViewContainer::NavigationPosition>(position);
-
-    foreach (ViewContainer *container, _viewSplitter->containers()) {
-        Q_ASSERT(container->supportedNavigationPositions().contains(_navigationPosition));
-        container->setNavigationPosition(_navigationPosition);
-    }
-}
-
-void ViewManager::setNavigationTabWidthExpanding(bool expand)
-{
-    _navigationTabWidthExpanding = expand;
-
-    foreach (ViewContainer *container, _viewSplitter->containers()) {
-        container->setNavigationTabWidthExpanding(expand);
-    }
-}
-
-void ViewManager::setNavigationStyleSheet(const QString &styleSheet)
-{
-    _navigationStyleSheet = styleSheet;
-
-    foreach (ViewContainer *container, _viewSplitter->containers()) {
-        container->setStyleSheet(_navigationStyleSheet);
-    }
-}
-
-void ViewManager::setContainerFeatures(ViewContainer *container)
-{
-    if (_showQuickButtons) {
-        container->setFeatures(container->features()
-                               | ViewContainer::QuickNewView
-                               | ViewContainer::QuickCloseView);
-    } else {
-        container->setFeatures(container->features()
-                               & ~ViewContainer::QuickNewView
-                               & ~ViewContainer::QuickCloseView);
-    }
-}
-void ViewManager::setShowQuickButtons(bool show)
-{
-    _showQuickButtons = show;
-
-    for (auto *container : _viewSplitter->containers()) {
-        setContainerFeatures(container);
-    }
-}
-
-void ViewManager::setNavigationBehavior(int behavior)
-{
-    _newTabBehavior = static_cast<NewTabBehavior>(behavior);
-}
diff --git a/src/ViewManager.h b/src/ViewManager.h
index c9bb9570..170de032 100644
--- a/src/ViewManager.h
+++ b/src/ViewManager.h
@@ -1,424 +1,395 @@
 /*
     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.
 */
 
 #ifndef VIEWMANAGER_H
 #define VIEWMANAGER_H
 
 // Qt
 #include <QHash>
 #include <QObject>
 #include <QPointer>
 
 // Konsole
 #include "Profile.h"
-#include "ViewContainer.h"
 
 class KActionCollection;
 class KConfigGroup;
 
 namespace Konsole {
 class ColorScheme;
-class IncrementalSearchBar;
 class Session;
 class TerminalDisplay;
-
+class TabbedViewContainer;
 class SessionController;
 class ViewProperties;
 class ViewSplitter;
 
 /**
  * Manages the terminal display widgets in a Konsole window or part.
  *
  * When a view manager is created, it constructs a splitter widget ( accessed via
  * widget() ) to hold one or more view containers.  Each view container holds
  * one or more terminal displays and a navigation widget ( eg. tabs or a list )
  * to allow the user to navigate between the displays in that container.
  *
  * The view manager provides menu actions ( defined in the 'konsoleui.rc' XML file )
  * to manipulate the views and view containers - for example, actions to split the view
  * left/right or top/bottom, detach a view from the current window and navigate between
  * views and containers.  These actions are added to the collection specified in the
  * ViewManager's constructor.
  *
  * The view manager provides facilities to construct display widgets for a terminal
  * session and also to construct the SessionController which provides the menus and other
  * user interface elements specific to each display/session pair.
  *
  */
 class KONSOLEPRIVATE_EXPORT ViewManager : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.konsole.Window")
 
 public:
     /**
      * Constructs a new view manager with the specified @p parent.
      * View-related actions defined in 'konsoleui.rc' are created
      * and added to the specified @p collection.
      */
     ViewManager(QObject *parent, KActionCollection *collection);
     ~ViewManager() Q_DECL_OVERRIDE;
 
     /**
      * Creates a new view to display the output from and deliver input to @p session.
      * Constructs a new container to hold the views if no container has yet been created.
      */
     void createView(Session *session);
 
     /**
      * Applies the view-specific settings associated with specified @p profile
      * to the terminal display @p view.
      */
     void applyProfileToView(TerminalDisplay *view, const Profile::Ptr profile);
 
     /**
      * Return the main widget for the view manager which
      * holds all of the views managed by this ViewManager instance.
      */
     QWidget *widget() const;
 
     /**
      * Returns the view manager's active view.
      */
     QWidget *activeView() const;
 
     /**
      * Returns the list of view properties for views in the active container.
      * Each view widget is associated with a ViewProperties instance which
      * provides access to basic information about the session being
      * displayed in the view, such as title, current directory and
      * associated icon.
      */
     QList<ViewProperties *> viewProperties() const;
 
     /**
      * This enum describes the available types of navigation widget
      * which newly created containers can provide to allow navigation
      * between open sessions.
      */
     enum NavigationMethod {
         /**
          * Each container has a row of tabs (one per session) which the user
          * can click on to navigate between open sessions.
          */
         TabbedNavigation,
         /** The container has no navigation widget. */
         NoNavigation
     };
 
     /**
      * This enum describes where newly created tab should be placed.
      */
     enum NewTabBehavior {
         /** Put newly created tab at the end. */
         PutNewTabAtTheEnd = 0,
         /** Put newly created tab right after current tab. */
         PutNewTabAfterCurrentTab = 1
     };
 
     /**
      * Sets the type of widget provided to navigate between open sessions
      * in a container.  The changes will only apply to newly created containers.
      *
      * The default method is TabbedNavigation.  To disable navigation widgets, call
      * setNavigationMethod(ViewManager::NoNavigation) before creating any sessions.
      */
     void setNavigationMethod(NavigationMethod method);
 
     /**
      * Returns the type of navigation widget created in new containers.
      * See setNavigationMethod()
      */
     NavigationMethod navigationMethod() const;
 
     /**
      * Returns the controller for the active view.  activeViewChanged() is
      * emitted when this changes.
      */
     SessionController *activeViewController() const;
 
-    /**
-     * Returns the search bar.
-     */
-    IncrementalSearchBar *searchBar() const;
-
     /**
      * Session management
      */
     void saveSessions(KConfigGroup &group);
     void restoreSessions(const KConfigGroup &group);
 
-    void setNavigationVisibility(int visibility);
-    void setNavigationPosition(int position);
-    void setNavigationBehavior(int behavior);
-    void setNavigationTabWidthExpanding(bool expand);
-    void setNavigationStyleSheet(const QString &styleSheet);
-    void setShowQuickButtons(bool show);
-
     int managerId() const;
 
     /** Returns a list of sessions in this ViewManager */
     QList<Session *> sessions()
     {
         return _sessionMap.values();
     }
 
     /**
      * Returns whether the @p profile has the blur setting enabled
      */
     static bool profileHasBlurEnabled(const Profile::Ptr profile);
 
 Q_SIGNALS:
     /** Emitted when the last view is removed from the view manager */
     void empty();
 
     /** Emitted when a session is detached from a view owned by this ViewManager */
     void viewDetached(Session *session);
 
     /**
      * Emitted when the active view changes.
      * @param controller The controller associated with the active view
      */
     void activeViewChanged(SessionController *controller);
 
     /**
      * Emitted when the current session needs unplugged from factory().
      * @param controller The controller associated with the active view
      */
     void unplugController(SessionController *controller);
 
     /**
      * Emitted when the list of view properties ( as returned by viewProperties() ) changes.
      * This occurs when views are added to or removed from the active container, or
      * if the active container is changed.
      */
     void viewPropertiesChanged(const QList<ViewProperties *> &propertiesList);
 
     /**
      * Emitted when the number of views containers changes.  This is used to disable or
      * enable menu items which can only be used when there are one or multiple containers
      * visible.
      *
      * @param multipleViews True if there are multiple view containers open or false if there is
      * just a single view.
      */
     void splitViewToggle(bool multipleViews);
 
     /**
      * Emitted when menu bar visibility changes because a profile that requires so is
      * activated.
      */
     void setMenuBarVisibleRequest(bool);
     void updateWindowIcon();
 
     void blurSettingChanged(bool);
 
     /** Requests creation of a new view with the default profile. */
     void newViewRequest();
     /** Requests creation of a new view, with the selected profile. */
     void newViewRequest(Profile::Ptr);
 
 public Q_SLOTS:
     /** DBus slot that returns the number of sessions in the current view. */
     Q_SCRIPTABLE int sessionCount();
 
     /**
      * DBus slot that returns the unique ids of the sessions in the
      * current view.  The returned list is not sorted.
      * QList<int> is not printable by qdbus so we use QStringList
      */
     Q_SCRIPTABLE QStringList sessionList();
 
     /** DBus slot that returns the current (active) session window */
     Q_SCRIPTABLE int currentSession();
 
     /** DBus slot that sets the current (active) session window */
     Q_SCRIPTABLE void setCurrentSession(int sessionId);
 
     /** DBus slot that creates a new session in the current view.
      * @param profile the name of the profile to be used
      * started.
      */
     Q_SCRIPTABLE int newSession(const QString &profile);
 
     /** DBus slot that creates a new session in the current view.
      * @param profile the name of the profile to be used
      * @param directory the working directory where the session is
      * started.
      */
     Q_SCRIPTABLE int newSession(const QString &profile, const QString &directory);
 
     // TODO: its semantic is application-wide. Move it to more appropriate place
     // DBus slot that returns the name of default profile
     Q_SCRIPTABLE QString defaultProfile();
 
     // TODO: its semantic is application-wide. Move it to more appropriate place
     // DBus slot that returns a string list of defined (known) profiles
     Q_SCRIPTABLE QStringList profileList();
 
     /** DBus slot that creates a new session in the current view with the associated
       * default profile and the default working directory
       */
     Q_SCRIPTABLE int newSession();
 
     /** DBus slot that changes the view port to the next session */
     Q_SCRIPTABLE void nextSession();
 
     /** DBus slot that changes the view port to the previous session */
     Q_SCRIPTABLE void prevSession();
 
     /** DBus slot that switches the current session (as returned by
       * currentSession()) with the left (or previous) one in the
       * navigation tab.
       */
     Q_SCRIPTABLE void moveSessionLeft();
 
     /** DBus slot that Switches the current session (as returned by
       * currentSession()) with the right (or next) one in the navigation
       * tab.
       */
     Q_SCRIPTABLE void moveSessionRight();
 
-    /** DBus slot that sets ALL tabs' width to match their text */
-    Q_SCRIPTABLE void setTabWidthToText(bool);
-
 private Q_SLOTS:
     // called when the "Split View Left/Right" menu item is selected
     void splitLeftRight();
     void splitTopBottom();
     void closeActiveContainer();
     void closeOtherContainers();
     void expandActiveContainer();
     void shrinkActiveContainer();
 
     // called when the "Detach View" menu item is selected
     void detachActiveView();
     void updateDetachViewState();
 
     // called when a session terminates - the view manager will delete any
     // views associated with the session
     void sessionFinished();
     // called when one view has been destroyed
     void viewDestroyed(QWidget *view);
 
     // controller detects when an associated view is given the focus
     // and emits a signal.  ViewManager listens for that signal
     // and then plugs the action into the UI
     //void viewFocused( SessionController* controller );
 
     // called when the active view in a ViewContainer changes, so
     // that we can plug the appropriate actions into the UI
     void viewActivated(QWidget *view);
 
     // called when "Next View" shortcut is activated
     void nextView();
 
     // called when "Previous View" shortcut is activated
     void previousView();
 
     // called when "Switch to last tab" shortcut is activated
     void lastView();
 
     // called when "Next View Container" shortcut is activated
     void nextContainer();
 
     // called when the views in a container owned by this view manager
     // changes
-    void containerViewsChanged(ViewContainer *container);
+    void containerViewsChanged(TabbedViewContainer *container);
 
     // called when a profile changes
     void profileChanged(Profile::Ptr profile);
 
     void updateViewsForSession(Session *session);
 
     // moves active view to the left
     void moveActiveViewLeft();
     // moves active view to the right
     void moveActiveViewRight();
     // switches to the view at visual position 'index'
     // in the current container
     void switchToView(int index);
 
     // called when a SessionController gains focus
     void controllerChanged(SessionController *controller);
 
     // called when a ViewContainer requests a view be
     // moved
     void containerMoveViewRequest(int index, int id, bool &success,
                                   TabbedViewContainer *sourceTabbedContainer);
 
-    void detachView(ViewContainer *container, QWidget *view);
-
-    void closeTabFromContainer(ViewContainer *container, QWidget *tab);
+    void detachView(TabbedViewContainer *container, QWidget *view);
 
 private:
     Q_DISABLE_COPY(ViewManager)
 
-    void createView(Session *session, ViewContainer *container, int index);
+    void createView(Session *session, TabbedViewContainer *container, int index);
     static const ColorScheme *colorSchemeForProfile(const Profile::Ptr profile);
 
     void setupActions();
 
     // takes a view from a view container owned by a different manager and places it in
     // newContainer owned by this manager
-    void takeView(ViewManager *otherManager, ViewContainer *otherContainer,
-                  ViewContainer *newContainer, TerminalDisplay *view);
+    void takeView(ViewManager *otherManager, TabbedViewContainer *otherContainer,
+                  TabbedViewContainer *newContainer, TerminalDisplay *view);
     void splitView(Qt::Orientation orientation);
 
     // creates a new container which can hold terminal displays
-    ViewContainer *createContainer();
+    TabbedViewContainer *createContainer();
     // removes a container and emits appropriate signals
-    void removeContainer(ViewContainer *container);
+    void removeContainer(TabbedViewContainer *container);
 
     // creates a new terminal display
     // the 'session' is used so that the terminal display's random seed
     // can be set to something which depends uniquely on that session
     TerminalDisplay *createTerminalDisplay(Session *session = nullptr);
 
     // creates a new controller for a session/display pair which provides the menu
     // actions associated with that view, and exposes basic information
     // about the session ( such as title and associated icon ) to the display.
     SessionController *createController(Session *session, TerminalDisplay *view);
 
-    // Sets the  possible features for a container.
-    void setContainerFeatures(ViewContainer* container);
-
 private:
     QPointer<ViewSplitter> _viewSplitter;
     QPointer<SessionController> _pluggedController;
 
     QHash<TerminalDisplay *, Session *> _sessionMap;
 
     KActionCollection *_actionCollection;
 
     NavigationMethod _navigationMethod;
-
-    ViewContainer::NavigationVisibility _navigationVisibility;
-    ViewContainer::NavigationPosition _navigationPosition;
-    bool _showQuickButtons;
-    bool _navigationTabWidthExpanding;
-    NewTabBehavior _newTabBehavior;
     QString _navigationStyleSheet;
-
     int _managerId;
     static int lastManagerId;
 };
 }
 
 #endif
diff --git a/src/ViewSplitter.cpp b/src/ViewSplitter.cpp
index d86cea7b..4d78d2be 100644
--- a/src/ViewSplitter.cpp
+++ b/src/ViewSplitter.cpp
@@ -1,279 +1,279 @@
 /*
     This file is part of the Konsole Terminal.
 
     Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "ViewSplitter.h"
 
 // Qt
 
 // Konsole
 #include "ViewContainer.h"
 
 using Konsole::ViewSplitter;
-using Konsole::ViewContainer;
+using Konsole::TabbedViewContainer;
 
 ViewSplitter::ViewSplitter(QWidget *parent) :
     QSplitter(parent),
-    _containers(QList<ViewContainer *>()),
+    _containers(QList<TabbedViewContainer *>()),
     _recursiveSplitting(true)
 {
 }
 
 void ViewSplitter::childEmpty(ViewSplitter *splitter)
 {
     delete splitter;
 
     if (count() == 0) {
         emit empty(this);
     }
 }
 
-void ViewSplitter::adjustContainerSize(ViewContainer *container, int percentage)
+void ViewSplitter::adjustContainerSize(TabbedViewContainer *container, int percentage)
 {
-    int containerIndex = indexOf(container->containerWidget());
+    int containerIndex = indexOf(container);
 
     Q_ASSERT(containerIndex != -1);
 
     QList<int> containerSizes = sizes();
 
     const int oldSize = containerSizes[containerIndex];
     const int newSize = static_cast<int>(oldSize * (1.0 + percentage / 100.0));
 
     const int perContainerDelta = (count() == 1) ? 0 : ((newSize - oldSize) / (count() - 1)) * (-1);
 
     for (int i = 0; i < containerSizes.count(); i++) {
         if (i == containerIndex) {
             containerSizes[i] = newSize;
         } else {
             containerSizes[i] = containerSizes[i] + perContainerDelta;
         }
     }
 
     setSizes(containerSizes);
 }
 
 ViewSplitter *ViewSplitter::activeSplitter()
 {
     QWidget *widget = focusWidget() != nullptr ? focusWidget() : this;
 
     ViewSplitter *splitter = nullptr;
 
     while ((splitter == nullptr) && (widget != nullptr)) {
         splitter = qobject_cast<ViewSplitter *>(widget);
         widget = widget->parentWidget();
     }
 
     Q_ASSERT(splitter);
     return splitter;
 }
 
-void ViewSplitter::registerContainer(ViewContainer *container)
+void ViewSplitter::registerContainer(TabbedViewContainer *container)
 {
     _containers << container;
     // Connecting to container::destroyed() using the new-style connection
     // syntax causes a crash at exit. I don't know why. Using the old-style
     // syntax works.
     //connect(container , static_cast<void(ViewContainer::*)(ViewContainer*)>(&Konsole::ViewContainer::destroyed) , this , &Konsole::ViewSplitter::containerDestroyed);
     //connect(container , &Konsole::ViewContainer::empty , this , &Konsole::ViewSplitter::containerEmpty);
-    connect(container, SIGNAL(destroyed(ViewContainer*)), this,
-            SLOT(containerDestroyed(ViewContainer*)));
-    connect(container, SIGNAL(empty(ViewContainer*)), this, SLOT(containerEmpty(ViewContainer*)));
+    connect(container, SIGNAL(destroyed(TabbedViewContainer*)), this,
+            SLOT(containerDestroyed(TabbedViewContainer*)));
+    connect(container, SIGNAL(empty(TabbedViewContainer*)), this, SLOT(containerEmpty(TabbedViewContainer*)));
 }
 
-void ViewSplitter::unregisterContainer(ViewContainer *container)
+void ViewSplitter::unregisterContainer(TabbedViewContainer *container)
 {
     _containers.removeAll(container);
     disconnect(container, nullptr, this, nullptr);
 }
 
 void ViewSplitter::updateSizes()
 {
     int space;
 
     if (orientation() == Qt::Horizontal) {
         space = width() / count();
     } else {
         space = height() / count();
     }
 
     QList<int> widgetSizes;
     const int widgetCount = count();
     widgetSizes.reserve(widgetCount);
     for (int i = 0; i < widgetCount; i++) {
         widgetSizes << space;
     }
 
     setSizes(widgetSizes);
 }
 
 void ViewSplitter::setRecursiveSplitting(bool recursive)
 {
     _recursiveSplitting = recursive;
 }
 
 bool ViewSplitter::recursiveSplitting() const
 {
     return _recursiveSplitting;
 }
 
-void ViewSplitter::removeContainer(ViewContainer *container)
+void ViewSplitter::removeContainer(TabbedViewContainer *container)
 {
     Q_ASSERT(containers().contains(container));
 
     unregisterContainer(container);
 }
 
-void ViewSplitter::addContainer(ViewContainer *container, Qt::Orientation containerOrientation)
+void ViewSplitter::addContainer(TabbedViewContainer *container, Qt::Orientation containerOrientation)
 {
     ViewSplitter *splitter = activeSplitter();
 
     if (splitter->count() < 2
         || containerOrientation == splitter->orientation()
         || !_recursiveSplitting) {
         splitter->registerContainer(container);
-        splitter->addWidget(container->containerWidget());
+        splitter->addWidget(container);
 
         if (splitter->orientation() != containerOrientation) {
             splitter->setOrientation(containerOrientation);
         }
 
         splitter->updateSizes();
     } else {
         auto newSplitter = new ViewSplitter(this);
         connect(newSplitter, &Konsole::ViewSplitter::empty, splitter,
                 &Konsole::ViewSplitter::childEmpty);
 
-        ViewContainer *oldContainer = splitter->activeContainer();
-        const int oldContainerIndex = splitter->indexOf(oldContainer->containerWidget());
+        TabbedViewContainer *oldContainer = splitter->activeContainer();
+        const int oldContainerIndex = splitter->indexOf(oldContainer);
 
         splitter->unregisterContainer(oldContainer);
 
         newSplitter->registerContainer(oldContainer);
         newSplitter->registerContainer(container);
 
-        newSplitter->addWidget(oldContainer->containerWidget());
-        newSplitter->addWidget(container->containerWidget());
+        newSplitter->addWidget(oldContainer);
+        newSplitter->addWidget(container);
         newSplitter->setOrientation(containerOrientation);
         newSplitter->updateSizes();
         newSplitter->show();
 
         splitter->insertWidget(oldContainerIndex, newSplitter);
     }
 }
 
-void ViewSplitter::containerEmpty(ViewContainer * /*container*/)
+void ViewSplitter::containerEmpty(TabbedViewContainer * /*container*/)
 {
     int children = 0;
-    foreach (ViewContainer *container, _containers) {
-        children += container->views().count();
+    foreach (TabbedViewContainer *container, _containers) {
+        children += container->count();
     }
 
     if (children == 0) {
         emit allContainersEmpty();
     }
 }
 
-void ViewSplitter::containerDestroyed(ViewContainer *container)
+void ViewSplitter::containerDestroyed(TabbedViewContainer *container)
 {
     Q_ASSERT(_containers.contains(container));
 
     _containers.removeAll(container);
 
     if (count() == 0) {
         emit empty(this);
     }
 }
 
 void ViewSplitter::activateNextContainer()
 {
-    ViewContainer *active = activeContainer();
+    TabbedViewContainer *active = activeContainer();
 
     int index = _containers.indexOf(active);
 
     if (index == -1) {
         return;
     }
 
     if (index == _containers.count() - 1) {
         index = 0;
     } else {
         index++;
     }
 
     setActiveContainer(_containers.at(index));
 }
 
 void ViewSplitter::activatePreviousContainer()
 {
-    ViewContainer *active = activeContainer();
+    TabbedViewContainer *active = activeContainer();
 
     int index = _containers.indexOf(active);
 
     if (index == 0) {
         index = _containers.count() - 1;
     } else {
         index--;
     }
 
     setActiveContainer(_containers.at(index));
 }
 
-void ViewSplitter::setActiveContainer(ViewContainer *container)
+void ViewSplitter::setActiveContainer(TabbedViewContainer *container)
 {
-    QWidget *activeView = container->activeView();
+    QWidget *activeView = container->currentWidget();
 
     if (activeView != nullptr) {
         activeView->setFocus(Qt::OtherFocusReason);
     }
 }
 
-ViewContainer *ViewSplitter::activeContainer() const
+TabbedViewContainer *ViewSplitter::activeContainer() const
 {
     if (QWidget *focusW = focusWidget()) {
-        ViewContainer *focusContainer = nullptr;
+        TabbedViewContainer *focusContainer = nullptr;
 
         while (focusW != nullptr) {
-            foreach (ViewContainer *container, _containers) {
-                if (container->containerWidget() == focusW) {
+            foreach (TabbedViewContainer *container, _containers) {
+                if (container == focusW) {
                     focusContainer = container;
                     break;
                 }
             }
             focusW = focusW->parentWidget();
         }
 
         if (focusContainer != nullptr) {
             return focusContainer;
         }
     }
 
     QList<ViewSplitter *> splitters = findChildren<ViewSplitter *>();
 
     if (splitters.count() > 0) {
         return splitters.last()->activeContainer();
     } else {
         if (_containers.count() > 0) {
             return _containers.last();
         } else {
             return nullptr;
         }
     }
 }
diff --git a/src/ViewSplitter.h b/src/ViewSplitter.h
index 123b3898..7d7e7edb 100644
--- a/src/ViewSplitter.h
+++ b/src/ViewSplitter.h
@@ -1,188 +1,188 @@
 /*
     This file is part of the Konsole Terminal.
 
     Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 #ifndef VIEWSPLITTER_H
 #define VIEWSPLITTER_H
 
 // Qt
 #include <QList>
 #include <QSplitter>
 
 class QFocusEvent;
 
 namespace Konsole {
-class ViewContainer;
+class TabbedViewContainer;
 
 /**
  * A splitter which holds a number of ViewContainer objects and allows
  * the user to control the size of each view container by dragging a splitter
  * bar between them.
  *
  * Each splitter can also contain child ViewSplitter widgets, allowing
  * for a hierarchy of view splitters and containers.
  *
  * The addContainer() method is used to split the existing view and
  * insert a new view container.
  * Containers can only be removed from the hierarchy by deleting them.
  */
 class ViewSplitter : public QSplitter
 {
     Q_OBJECT
 
 public:
     explicit ViewSplitter(QWidget *parent = nullptr);
 
     /**
      * Locates the child ViewSplitter widget which currently has the focus
      * and inserts the container into it.
      *
      * @param container The container to insert
      * @param orientation Specifies whether the view should be split
      *                    horizontally or vertically.  If the orientation
      *                    is the same as the ViewSplitter into which the
      *                    container is to be inserted, or if the splitter
      *                    has fewer than two child widgets then the container
      *                    will be added to that splitter.  If the orientation
      *                    is different, then a new child splitter
      *                    will be created, into which the container will
      *                    be inserted.
      */
-    void addContainer(ViewContainer *container, Qt::Orientation orientation);
+    void addContainer(TabbedViewContainer *container, Qt::Orientation orientation);
 
     /** Removes a container from the splitter.  The container is not deleted. */
-    void removeContainer(ViewContainer *container);
+    void removeContainer(TabbedViewContainer *container);
 
     /** Returns the child ViewSplitter widget which currently has the focus */
     ViewSplitter *activeSplitter();
 
     /**
      * Returns the container which currently has the focus or 0 if none
      * of the immediate child containers have the focus.  This does not
      * search through child splitters.  activeSplitter() can be used
      * to search recursively through child splitters for the splitter
      * which currently has the focus.
      *
      * To find the currently active container, use
      * mySplitter->activeSplitter()->activeContainer() where mySplitter
      * is the ViewSplitter widget at the top of the hierarchy.
      */
-    ViewContainer *activeContainer() const;
+    TabbedViewContainer *activeContainer() const;
 
     /**
      * Gives the focus to the active view in the specified container
      */
-    void setActiveContainer(ViewContainer *container);
+    void setActiveContainer(TabbedViewContainer *container);
 
     /**
      * Returns a list of the containers held by this splitter
      */
-    QList<ViewContainer *> containers() const
+    QList<TabbedViewContainer *> containers() const
     {
         return _containers;
     }
 
     /**
      * Gives the focus to the active view in the next container
      */
     void activateNextContainer();
 
     /**
      * Changes the size of the specified @p container by a given @p percentage.
      * @p percentage may be positive ( in which case the size of the container
      * is increased ) or negative ( in which case the size of the container
      * is decreased ).
      *
      * The sizes of the remaining containers are increased or decreased
      * uniformly to maintain the width of the splitter.
      */
-    void adjustContainerSize(ViewContainer *container, int percentage);
+    void adjustContainerSize(TabbedViewContainer *container, int percentage);
 
     /**
      * Gives the focus to the active view in the previous container
      */
     void activatePreviousContainer();
 
     /**
      * Specifies whether the view may be split recursively.
      *
      * If this is false, all containers will be placed into the same
      * top-level splitter.  Adding a container with an orientation
      * which is different to that specified when adding the previous
      * containers will change the orientation for all dividers
      * between containers.
      *
      * If this is true, adding a container to the view splitter with
      * an orientation different to the orientation of the previous
      * area will result in the previously active container being
      * replaced with a new splitter containing the active container
      * and the newly added container.
      */
     void setRecursiveSplitting(bool recursive);
 
     /**
      * Returns whether the view may be split recursively.
      * See setRecursiveSplitting()
      */
     bool recursiveSplitting() const;
 
 Q_SIGNALS:
     /** Signal emitted when the last child widget is removed from the splitter */
     void empty(ViewSplitter *splitter);
 
     /**
      * Signal emitted when the containers held by this splitter become empty, this
      * differs from the empty() signal which is only emitted when all of the containers
      * are deleted.  This signal is emitted even if there are still container widgets.
      *
      * TODO: This does not yet work recursively (ie. when splitters inside splitters have empty containers)
      */
     void allContainersEmpty();
 
 protected:
     //virtual void focusEvent(QFocusEvent* event);
 
 private:
     // Adds container to splitter's internal list and
     // connects signals and slots
-    void registerContainer(ViewContainer *container);
+    void registerContainer(TabbedViewContainer *container);
     // Removes container from splitter's internal list and
     // removes signals and slots
-    void unregisterContainer(ViewContainer *container);
+    void unregisterContainer(TabbedViewContainer *container);
 
     void updateSizes();
 
 private Q_SLOTS:
     // Called to indicate that a child ViewContainer has been deleted
-    void containerDestroyed(ViewContainer *container);
+    void containerDestroyed(TabbedViewContainer *container);
 
     // Called to indicate that a child ViewContainer is empty
-    void containerEmpty(ViewContainer *container);
+    void containerEmpty(TabbedViewContainer *container);
 
     // Called to indicate that a child ViewSplitter is empty
     // (ie. all child widgets have been deleted)
     void childEmpty(ViewSplitter *splitter);
 
 private:
-    QList<ViewContainer *> _containers;
+    QList<TabbedViewContainer *> _containers;
     bool _recursiveSplitting;
 };
 }
 #endif //VIEWSPLITTER_H