diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index feb4f5a2..b6a02438 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,210 +1,218 @@
 # cmake-options : -DCMAKE_DISABLE_FIND_PACKAGE_LibKonq=TRUE or FALSE; default is FALSE
 
 add_definitions(-DTRANSLATION_DOMAIN=\"konsole\")
 
+# When Qt5.9+ is required, consider using QOperatingSystemVersion
+### Too many crashes/issues with detaching on MacOSX
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+  set(ENABLE_DETACHING 0)
+else()
+  set(ENABLE_DETACHING 1)
+endif()
+
 ### Handle DragonFlyBSD here instead of using __DragonFly__
 IF(${CMAKE_SYSTEM_NAME} MATCHES "DragonFly")
   set(HAVE_OS_DRAGONFLYBSD 1)
 else()
   set(HAVE_OS_DRAGONFLYBSD 0)
 endif()
 
 include(CheckIncludeFiles)
 include(ECMAddAppIcon)
 
 configure_file(config-konsole.h.cmake
               ${CMAKE_CURRENT_BINARY_DIR}/config-konsole.h)
 
 ### Tests
 if(BUILD_TESTING)
   find_package(Qt5Test ${QT_MIN_VERSION} CONFIG REQUIRED)
   add_subdirectory(autotests)
   add_subdirectory(tests)
 endif()
 
 ### Security concerns about sendText and runCommand dbus methods being public
 option(REMOVE_SENDTEXT_RUNCOMMAND_DBUS_METHODS "Konsole: remove sendText and runCommand dbus methods" OFF)
 
 ### 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
                         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/ViewContainer.cpp b/src/ViewContainer.cpp
index d23cddb0..942c2f71 100644
--- a/src/ViewContainer.cpp
+++ b/src/ViewContainer.cpp
@@ -1,425 +1,427 @@
 /*
     This file is part of the Konsole Terminal.
 
     Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "ViewContainer.h"
 #include <config-konsole.h>
 
 // Qt
 #include <QTabBar>
 #include <QMenu>
 #include <QFile>
-#include <QOperatingSystemVersion>
 #include <QMouseEvent>
 
 // KDE
 #include <KColorScheme>
 #include <KColorUtils>
 #include <KLocalizedString>
 #include <KActionCollection>
 
 // Konsole
 #include "IncrementalSearchBar.h"
 #include "ViewProperties.h"
 #include "ProfileList.h"
 #include "ViewManager.h"
 #include "KonsoleSettings.h"
 #include "SessionController.h"
 #include "DetachableTabBar.h"
 
 // TODO Perhaps move everything which is Konsole-specific into different files
 
 using namespace Konsole;
 
 
 TabbedViewContainer::TabbedViewContainer(ViewManager *connectedViewManager, QWidget *parent) :
     QTabWidget(parent),
     _connectedViewManager(connectedViewManager),
     _newTabButton(new QToolButton()),
     _closeTabButton(new QToolButton()),
     _contextMenuTabIndex(-1)
 {
     auto tabBarWidget = new DetachableTabBar();
     setTabBar(tabBarWidget);
     setDocumentMode(true);
     setMovable(true);
 
     tabBar()->setContextMenuPolicy(Qt::CustomContextMenu);
 
     _newTabButton->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
     _newTabButton->setAutoRaise(true);
     connect(_newTabButton, &QToolButton::clicked, this, [this]{
         emit newViewRequest();
     });
 
     _closeTabButton->setIcon(QIcon::fromTheme(QStringLiteral("tab-close")));
     _closeTabButton->setAutoRaise(true);
     connect(_closeTabButton, &QToolButton::clicked, this, [this]{
        closeCurrentTab();
     });
 
     connect(tabBar(), &QTabBar::tabBarDoubleClicked, this,
         &Konsole::TabbedViewContainer::tabDoubleClicked);
     connect(tabBar(), &QTabBar::customContextMenuRequested, this,
         &Konsole::TabbedViewContainer::openTabContextMenu);
     connect(tabBarWidget, &DetachableTabBar::detachTab, this, [this](int idx) {
         emit detachTab(this, widget(idx));
     });
     connect(this, &TabbedViewContainer::currentChanged, this, [this](int index) {
         if (index != -1) {
             widget(index)->setFocus();
         }
     });
 
     // 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)
     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"));
+#endif
 
     auto editAction = _contextPopupMenu->addAction(
         QIcon::fromTheme(QStringLiteral("edit-rename")),
         i18nc("@action:inmenu", "&Rename Tab..."), this,
         [this]{ renameTab(_contextMenuTabIndex); }
     );
     editAction->setObjectName(QStringLiteral("edit-rename"));
 
     auto closeAction = _contextPopupMenu->addAction(
         QIcon::fromTheme(QStringLiteral("tab-close")),
         i18nc("@action:inmenu", "Close Tab"), this,
         [this] { closeTerminalTab(_contextMenuTabIndex); }
     );
     closeAction->setObjectName(QStringLiteral("tab-close"));
 
     auto profileMenu = new QMenu();
     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));
     _newTabButton->setMenu(profileMenu);
 
     konsoleConfigChanged();
     connect(KonsoleSettings::self(), &KonsoleSettings::configChanged, this, &TabbedViewContainer::konsoleConfigChanged);
 }
 
 TabbedViewContainer::~TabbedViewContainer()
 {
     for(int i = 0, end = count(); i < end; i++) {
         auto view = widget(i);
         disconnect(view, &QWidget::destroyed, this, &Konsole::TabbedViewContainer::viewDestroyed);
     }
 
     emit destroyed(this);
 }
 
 void TabbedViewContainer::konsoleConfigChanged()
 {
     setTabBarAutoHide((bool) KonsoleSettings::tabBarVisibility());
     setTabPosition((QTabWidget::TabPosition) KonsoleSettings::tabBarPosition());
 
     setCornerWidget( KonsoleSettings::showQuickButtons() ? _newTabButton : nullptr, Qt::TopLeftCorner);
     setCornerWidget( KonsoleSettings::showQuickButtons() ? _closeTabButton : nullptr, Qt::TopRightCorner);
 
     if (isVisible() && KonsoleSettings::showQuickButtons()) {
         _newTabButton->setVisible(true);
         _closeTabButton->setVisible(true);
     }
 
     if (KonsoleSettings::tabBarUseUserStyleSheet()) {
         setCssFromFile(KonsoleSettings::tabBarUserStyleSheetFile());
     }
 }
 
 void TabbedViewContainer::setCssFromFile(const QUrl &url)
 {
     // Let's only deal w/ local files for now
     if (!url.isLocalFile()) {
         setStyleSheet(KonsoleSettings::tabBarStyleSheet());
     }
 
     QFile file(url.toLocalFile());
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         setStyleSheet(KonsoleSettings::tabBarStyleSheet());
     }
 
     QString styleSheetText;
     QTextStream in(&file);
     while (!in.atEnd()) {
         styleSheetText.append(in.readLine());
     }
     setStyleSheet(styleSheetText);
 }
 
 void TabbedViewContainer::moveActiveView(MoveDirection direction)
 {
     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 TabbedViewContainer::addView(QWidget *view, ViewProperties *item, int index)
 {
     if (index == -1) {
         addTab(view, item->icon(), item->title());
     } else {
         insertTab(index, view, item->icon(), item->title());
     }
 
     _navigation[view] = item;
     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 TabbedViewContainer::viewDestroyed(QObject *view)
 {
     auto widget = static_cast<QWidget*>(view);
     const auto idx = indexOf(widget);
 
     removeTab(idx);
     forgetView(widget);
 }
 
 void TabbedViewContainer::forgetView(QWidget *view)
 {
     _navigation.remove(view);
     emit viewRemoved(view);
     if (count() == 0) {
         emit empty(this);
     }
 }
 
 void TabbedViewContainer::removeView(QWidget *view)
 {
     const int idx = indexOf(view);
     disconnect(view, &QWidget::destroyed, this, &Konsole::TabbedViewContainer::viewDestroyed);
     removeTab(idx);
     forgetView(view);
 }
 
 void TabbedViewContainer::activateNextView()
 {
     QWidget *active = currentWidget();
     int index = indexOf(active);
     setCurrentIndex(index == count() - 1 ? 0 : index + 1);
 }
 
 void TabbedViewContainer::activateLastView()
 {
     setCurrentIndex(count() - 1);
 }
 
 void TabbedViewContainer::activatePreviousView()
 {
     QWidget *active = currentWidget();
     int index = indexOf(active);
     setCurrentIndex(index == 0 ? count() - 1 : index - 1);
 }
 
 ViewProperties *TabbedViewContainer::viewProperties(QWidget *view) const
 {
     Q_ASSERT(_navigation.contains(view));
     return _navigation[view];
 }
 
 QList<QWidget *> TabbedViewContainer::widgetsForItem(ViewProperties *item) const
 {
     return _navigation.keys(item);
 }
 
 void TabbedViewContainer::closeCurrentTab()
 {
     if (currentIndex() != -1) {
         closeTerminalTab(currentIndex());
     }
 }
 
 void TabbedViewContainer::tabDoubleClicked(int index)
 {
     if (index >= 0) {
         renameTab(index);
     } else {
         emit newViewRequest();
     }
 }
 
 void TabbedViewContainer::renameTab(int index)
 {
     if (index != -1) {
         _navigation[widget(index)]->rename();
     }
 }
 
 void TabbedViewContainer::openTabContextMenu(const QPoint &point)
 {
     if (point.isNull()) {
         return;
     }
 
     _contextMenuTabIndex = tabBar()->tabAt(point);
     if (_contextMenuTabIndex < 0) {
         return;
     }
 
     //TODO: add a countChanged signal so we can remove this for.
     // Detaching in mac causes crashes.
-    const auto isDarwin = QOperatingSystemVersion::currentType() == QOperatingSystemVersion::MacOS;
+#if defined(ENABLE_DETACHING)
     for(auto action : _contextPopupMenu->actions()) {
         if (action->objectName() == QStringLiteral("tab-detach")) {
-            action->setEnabled( !isDarwin && count() > 1);
+            action->setEnabled(count() > 1);
         }
     }
+#endif
 
     // Add the read-only action
     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::currentTabChanged(int 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();
     }
 }
 
 void TabbedViewContainer::setTabActivity(int index, bool activity)
 {
     const QPalette &palette = tabBar()->palette();
     KColorScheme colorScheme(palette.currentColorGroup());
     const QColor colorSchemeActive = colorScheme.foreground(KColorScheme::ActiveText).color();
 
     const QColor normalColor = palette.text().color();
     const QColor activityColor = KColorUtils::mix(normalColor, colorSchemeActive);
 
     QColor color = activity ? activityColor : QColor();
 
     if (color != tabBar()->tabTextColor(index)) {
         tabBar()->setTabTextColor(index, color);
     }
 }
 
 void TabbedViewContainer::updateActivity(ViewProperties *item)
 {
     foreach (QWidget *widget, widgetsForItem(item)) {
         const int index = indexOf(widget);
 
         if (index != currentIndex()) {
             setTabActivity(index, true);
         }
     }
 }
 
 void TabbedViewContainer::updateTitle(ViewProperties *item)
 {
     foreach (QWidget *widget, widgetsForItem(item)) {
         const int index = indexOf(widget);
         QString tabText = item->title();
 
         setTabToolTip(index, tabText);
 
         // To avoid having & replaced with _ (shortcut indicator)
         tabText.replace(QLatin1Char('&'), QLatin1String("&&"));
         setTabText(index, tabText);
     }
 }
 
 void TabbedViewContainer::updateIcon(ViewProperties *item)
 {
     foreach (QWidget *widget, widgetsForItem(item)) {
         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/ViewManager.cpp b/src/ViewManager.cpp
index e99b5181..e79a1339 100644
--- a/src/ViewManager.cpp
+++ b/src/ViewManager.cpp
@@ -1,1097 +1,1103 @@
 /*
     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),
     _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
 {
     TabbedViewContainer *container = _viewSplitter->activeContainer();
     if (container != nullptr) {
         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;
 
-    QAction *detachViewAction = collection->addAction(QStringLiteral("detach-view"));
     // Crashes on Mac.
-    detachViewAction->setEnabled(QOperatingSystemVersion::currentType() != QOperatingSystemVersion::MacOS);
+#if defined(ENABLE_DETACHING)
+    QAction *detachViewAction = collection->addAction(QStringLiteral("detach-view"));
+    detachViewAction->setEnabled(true);
     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)
 {
     _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->count() >= 2);
 
     QAction *detachAction = _actionCollection->action(QStringLiteral("detach-view"));
 
     if ((detachAction != nullptr) && shouldEnable != detachAction->isEnabled()) {
         detachAction->setEnabled(shouldEnable);
     }
 }
 
 void ViewManager::moveActiveViewLeft()
 {
     TabbedViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
     container->moveActiveView(TabbedViewContainer::MoveViewLeft);
 }
 
 void ViewManager::moveActiveViewRight()
 {
     TabbedViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
     container->moveActiveView(TabbedViewContainer::MoveViewRight);
 }
 
 void ViewManager::nextContainer()
 {
     _viewSplitter->activateNextContainer();
 }
 
 void ViewManager::nextView()
 {
     TabbedViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
     container->activateNextView();
 }
 
 void ViewManager::previousView()
 {
     TabbedViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
     container->activatePreviousView();
 }
 
 void ViewManager::lastView()
 {
     TabbedViewContainer *container = _viewSplitter->activeContainer();
     Q_ASSERT(container);
     container->activateLastView();
 }
 
 void ViewManager::detachActiveView()
 {
     // find the currently active view and remove it from its container
     TabbedViewContainer *container = _viewSplitter->activeContainer();
     detachView(container, container->currentWidget());
 }
 
 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->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)
 {
     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
     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->currentWidget()->setFocus();
 
     // ensure that the active view is focused after the split / unsplit
     TabbedViewContainer *activeContainer = _viewSplitter->activeContainer();
     QWidget *activeView = activeContainer != nullptr ? activeContainer->currentWidget() : nullptr;
 
     if (activeView != nullptr) {
         activeView->setFocus(Qt::OtherFocusReason);
     }
 }
 
 void ViewManager::removeContainer(TabbedViewContainer *container)
 {
     // remove session map entries for views in this container
     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) {
         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()
 {
     TabbedViewContainer *active = _viewSplitter->activeContainer();
 
     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;
 }
 
 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();
 
     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->setCurrentWidget(display);
         display->setFocus(Qt::OtherFocusReason);
     }
 
     updateDetachViewState();
 }
 
 void ViewManager::createView(Session *session)
 {
     // create the default container
     if (_viewSplitter->containers().count() == 0) {
         TabbedViewContainer *container = createContainer();
         _viewSplitter->addContainer(container, Qt::Vertical);
         emit splitViewToggle(false);
     }
 
     // new tab will be put at the end by default.
     int index = -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 (TabbedViewContainer *container, _viewSplitter->containers()) {
         createView(session, container, index);
     }
 }
 
 TabbedViewContainer *ViewManager::createContainer()
 {
 
     auto *container = new TabbedViewContainer(this, _viewSplitter);
     //TODO: Fix Detaching.
     connect(container, &TabbedViewContainer::detachTab, this, &ViewManager::detachView);
 
     // connect signals and slots
     connect(container, &Konsole::TabbedViewContainer::viewAdded, this,
            [this, container]() {
                containerViewsChanged(container);
            });
 
     connect(container, &Konsole::TabbedViewContainer::viewRemoved, this,
            [this, container]() {
                containerViewsChanged(container);
            });
 
     connect(container,
             static_cast<void (TabbedViewContainer::*)()>(&Konsole::TabbedViewContainer::newViewRequest), this,
             static_cast<void (ViewManager::*)()>(&Konsole::ViewManager::newViewRequest));
     connect(container,
             static_cast<void (TabbedViewContainer::*)(Profile::Ptr)>(&Konsole::TabbedViewContainer::newViewRequest),
             this,
             static_cast<void (ViewManager::*)(Profile::Ptr)>(&Konsole::ViewManager::newViewRequest));
     connect(container, &Konsole::TabbedViewContainer::moveViewRequest, this,
             &Konsole::ViewManager::containerMoveViewRequest);
     connect(container, &Konsole::TabbedViewContainer::viewRemoved, this,
             &Konsole::ViewManager::viewDestroyed);
     connect(container, &Konsole::TabbedViewContainer::activeViewChanged, this,
             &Konsole::ViewManager::viewActivated);
 
     return container;
 }
 
 void ViewManager::containerMoveViewRequest(int index, int id, bool &success,
                                            TabbedViewContainer *sourceTabbedContainer)
 {
     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<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;
     }
     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 = (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(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;
 
     TabbedViewContainer *container = _viewSplitter->activeContainer();
 
     Q_ASSERT(container);
     list.reserve(container->count());
 
     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
     Q_ASSERT(container);
     if (container == nullptr) {
         return;
     }
 
     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()->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) {
             TabbedViewContainer *container = _viewSplitter->activeContainer();
             if (container != nullptr) {
                 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();
 }