diff --git a/src/ViewContainer.cpp b/src/ViewContainer.cpp
index 21281268..5972eae6 100644
--- a/src/ViewContainer.cpp
+++ b/src/ViewContainer.cpp
@@ -1,600 +1,599 @@
 /*
     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 <QMouseEvent>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QDrag>
 
 // KDE
 #include <KColorScheme>
 #include <KColorUtils>
 #include <KLocalizedString>
 #include <KActionCollection>
 
 // Konsole
 #include "IncrementalSearchBar.h"
 #include "ViewProperties.h"
 #include "ProfileList.h"
 #include "ViewManager.h"
 #include "KonsoleSettings.h"
 #include "SessionController.h"
 #include "DetachableTabBar.h"
 #include "TerminalDisplay.h"
 #include "ViewSplitter.h"
 #include "MainWindow.h"
 #include "Session.h"
 
 // TODO Perhaps move everything which is Konsole-specific into different files
 
 using namespace Konsole;
 
 
 TabbedViewContainer::TabbedViewContainer(ViewManager *connectedViewManager, QWidget *parent) :
     QTabWidget(parent),
     _connectedViewManager(connectedViewManager),
     _newTabButton(new QToolButton(this)),
     _closeTabButton(new QToolButton(this)),
     _contextMenuTabIndex(-1),
     _navigationVisibility(ViewManager::NavigationVisibility::NavigationNotSet),
     _newTabBehavior(PutNewTabAtTheEnd)
 {
     setAcceptDrops(true);
 
     auto tabBarWidget = new DetachableTabBar();
     setTabBar(tabBarWidget);
     setDocumentMode(true);
     setMovable(true);
     connect(tabBarWidget, &DetachableTabBar::moveTabToWindow, this, &TabbedViewContainer::moveTabToWindow);
     tabBar()->setContextMenuPolicy(Qt::CustomContextMenu);
     _newTabButton->setIcon(QIcon::fromTheme(QStringLiteral("tab-new")));
     _newTabButton->setAutoRaise(true);
     connect(_newTabButton, &QToolButton::clicked, this, &TabbedViewContainer::newViewRequest);
 
     _closeTabButton->setIcon(QIcon::fromTheme(QStringLiteral("tab-close")));
     _closeTabButton->setAutoRaise(true);
     connect(_closeTabButton, &QToolButton::clicked, this, [this]{
        closeCurrentTab();
     });
 
     connect(tabBar(), &QTabBar::tabBarDoubleClicked, this,
         &Konsole::TabbedViewContainer::tabDoubleClicked);
     connect(tabBar(), &QTabBar::customContextMenuRequested, this,
         &Konsole::TabbedViewContainer::openTabContextMenu);
     connect(tabBarWidget, &DetachableTabBar::detachTab, this, [this](int idx) {
         emit detachTab(idx);
     });
     connect(tabBarWidget, &DetachableTabBar::closeTab,
         this, &TabbedViewContainer::closeTerminalTab);
     connect(tabBarWidget, &DetachableTabBar::newTabRequest,
         this, [this]{ emit newViewRequest(); });
     connect(this, &TabbedViewContainer::currentChanged, this, &TabbedViewContainer::currentTabChanged);
 
     // The context menu of tab bar
     _contextPopupMenu = new QMenu(tabBar());
     connect(_contextPopupMenu, &QMenu::aboutToHide, this, [this]() {
         // Remove the read-only action when the popup closes
         for (auto &action : _contextPopupMenu->actions()) {
             if (action->objectName() == QStringLiteral("view-readonly")) {
                 _contextPopupMenu->removeAction(action);
                 break;
             }
         }
     });
 
     connect(tabBar(), &QTabBar::tabCloseRequested, this, &TabbedViewContainer::closeTerminalTab);
 
     auto detachAction = _contextPopupMenu->addAction(
         QIcon::fromTheme(QStringLiteral("tab-detach")),
         i18nc("@action:inmenu", "&Detach Tab"), this,
         [this] { emit detachTab(_contextMenuTabIndex); }
     );
     detachAction->setObjectName(QStringLiteral("tab-detach"));
 
     auto editAction = _contextPopupMenu->addAction(
         QIcon::fromTheme(QStringLiteral("edit-rename")),
         i18nc("@action:inmenu", "&Rename Tab..."), this,
         [this]{ renameTab(_contextMenuTabIndex); }
     );
     editAction->setObjectName(QStringLiteral("edit-rename"));
 
     auto closeAction = _contextPopupMenu->addAction(
         QIcon::fromTheme(QStringLiteral("tab-close")),
         i18nc("@action:inmenu", "Close Tab"), this,
         [this] { closeTerminalTab(_contextMenuTabIndex); }
     );
     closeAction->setObjectName(QStringLiteral("tab-close"));
 
     auto profileMenu = new QMenu(this);
     auto profileList = new ProfileList(false, profileMenu);
     profileList->syncWidgetActions(profileMenu, true);
     connect(profileList, &Konsole::ProfileList::profileSelected, this, &TabbedViewContainer::newViewWithProfileRequest);
     _newTabButton->setMenu(profileMenu);
 
     konsoleConfigChanged();
     connect(KonsoleSettings::self(), &KonsoleSettings::configChanged, this, &TabbedViewContainer::konsoleConfigChanged);
 }
 
 TabbedViewContainer::~TabbedViewContainer()
 {
     for(int i = 0, end = count(); i < end; i++) {
         auto view = widget(i);
         disconnect(view, &QWidget::destroyed, this, &Konsole::TabbedViewContainer::viewDestroyed);
     }
 }
 
 ViewSplitter *TabbedViewContainer::activeViewSplitter()
 {
     return viewSplitterAt(currentIndex());
 }
 
 ViewSplitter *TabbedViewContainer::viewSplitterAt(int index)
 {
     return qobject_cast<ViewSplitter*>(widget(index));
 }
 
 void TabbedViewContainer::moveTabToWindow(int index, QWidget *window)
 {
     auto splitter = viewSplitterAt(index);
     auto manager = window->findChild<ViewManager*>();
 
     QHash<TerminalDisplay*, Session*> sessionsMap = _connectedViewManager->forgetAll(splitter);
 
     foreach(TerminalDisplay* terminal, splitter->findChildren<TerminalDisplay*>()) {
         manager->attachView(terminal, sessionsMap[terminal]);
     }
     auto container = manager->activeContainer();
     container->addSplitter(splitter);
 
     auto controller = splitter->activeTerminalDisplay()->sessionController();
     container->currentSessionControllerChanged(controller);
 
     forgetView(splitter);
 }
 
 void TabbedViewContainer::konsoleConfigChanged()
 {
     // don't show tabs if we are in KParts mode.
     // This is a hack, and this needs to be rewritten.
     // The container should not be part of the KParts, perhaps just the
     // TerminalDisplay should.
 
     // ASAN issue if using sessionController->isKonsolePart(), just
     // duplicate code for now
     if (qApp->applicationName() != QLatin1String("konsole")) {
         tabBar()->setVisible(false);
     } else {
         // if we start with --show-tabbar or --hide-tabbar we ignore the preferences.
         setTabBarAutoHide(KonsoleSettings::tabBarVisibility() == KonsoleSettings::EnumTabBarVisibility::ShowTabBarWhenNeeded);
         if (KonsoleSettings::tabBarVisibility() == KonsoleSettings::EnumTabBarVisibility::AlwaysShowTabBar) {
             tabBar()->setVisible(true);
         } else if (KonsoleSettings::tabBarVisibility() == KonsoleSettings::EnumTabBarVisibility::AlwaysHideTabBar) {
             tabBar()->setVisible(false);
         }
     }
 
     setTabPosition((QTabWidget::TabPosition) KonsoleSettings::tabBarPosition());
 
     setCornerWidget(KonsoleSettings::newTabButton() ? _newTabButton : nullptr, Qt::TopLeftCorner);
     _newTabButton->setVisible(KonsoleSettings::newTabButton());
 
     setCornerWidget(KonsoleSettings::closeTabButton() == 1 ? _closeTabButton : nullptr, Qt::TopRightCorner);
     _closeTabButton->setVisible(KonsoleSettings::closeTabButton() == 1);
 
     tabBar()->setTabsClosable(KonsoleSettings::closeTabButton() == 0);
 
     tabBar()->setExpanding(KonsoleSettings::expandTabWidth());
     tabBar()->update();
 
     if (KonsoleSettings::tabBarUseUserStyleSheet()) {
         setCssFromFile(KonsoleSettings::tabBarUserStyleSheetFile());
     } else {
         setCss();
     }
 }
 
 void TabbedViewContainer::setCss(const QString& styleSheet)
 {
     static const QString defaultCss = QStringLiteral("QTabWidget::tab-bar, QTabWidget::pane { margin: 0; }\n");
     setStyleSheet(defaultCss + styleSheet);
 }
 
 void TabbedViewContainer::setCssFromFile(const QUrl &url)
 {
     // Let's only deal w/ local files for now
     if (!url.isLocalFile()) {
         setStyleSheet(KonsoleSettings::tabBarStyleSheet());
     }
 
     QFile file(url.toLocalFile());
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         setStyleSheet(KonsoleSettings::tabBarStyleSheet());
     }
 
     QTextStream in(&file);
     setCss(in.readAll());
 }
 
 void TabbedViewContainer::moveActiveView(MoveDirection direction)
 {
     if (count() < 2) { // return if only one view
         return;
     }
     const int currentIndex = indexOf(currentWidget());
     int newIndex = direction  == MoveViewLeft ? qMax(currentIndex - 1, 0) : qMin(currentIndex + 1, count() - 1);
 
     auto swappedWidget = viewSplitterAt(newIndex);
     auto swappedTitle = tabBar()->tabText(newIndex);
     auto swappedIcon = tabBar()->tabIcon(newIndex);
 
     auto currentWidget = viewSplitterAt(currentIndex);
     auto currentTitle = tabBar()->tabText(currentIndex);
     auto currentIcon = tabBar()->tabIcon(currentIndex);
 
     if (newIndex < currentIndex) {
         insertTab(newIndex, currentWidget, currentIcon, currentTitle);
         insertTab(currentIndex, swappedWidget, swappedIcon, swappedTitle);
     } else {
         insertTab(currentIndex, swappedWidget, swappedIcon, swappedTitle);
         insertTab(newIndex, currentWidget, currentIcon, currentTitle);
     }
     setCurrentIndex(newIndex);
 }
 
 void TabbedViewContainer::terminalDisplayDropped(TerminalDisplay *terminalDisplay) {
-    qDebug() << "Dropping the terminal";
     Session* terminalSession = terminalDisplay->sessionController()->session();
     terminalDisplay->sessionController()->deleteLater();
     connectedViewManager()->attachView(terminalDisplay, terminalSession);
 }
 
 void TabbedViewContainer::addSplitter(ViewSplitter *viewSplitter, int index) {
     if (index == -1) {
        index = addTab(viewSplitter, QString());
     } else {
         insertTab(index, viewSplitter, QString());
     }
     connect(viewSplitter, &ViewSplitter::destroyed, this, &TabbedViewContainer::viewDestroyed);
 
     disconnect(viewSplitter, &ViewSplitter::terminalDisplayDropped, nullptr, nullptr);
     connect(viewSplitter, &ViewSplitter::terminalDisplayDropped, this, &TabbedViewContainer::terminalDisplayDropped);
 
     auto terminalDisplays = viewSplitter->findChildren<TerminalDisplay*>();
     foreach(TerminalDisplay* terminal, terminalDisplays) {
         connectTerminalDisplay(terminal);
     }
     if (terminalDisplays.count() > 0) {
         updateTitle(qobject_cast<ViewProperties*>(terminalDisplays.at(0)->sessionController()));
     }
     setCurrentIndex(index);
 }
 
 void TabbedViewContainer::addView(TerminalDisplay *view)
 {
     auto viewSplitter = new ViewSplitter();
     viewSplitter->addTerminalDisplay(view, Qt::Horizontal);
     auto item = view->sessionController();
     int index = _newTabBehavior == PutNewTabAfterCurrentTab ? currentIndex() + 1 : -1;
     if (index == -1) {
        index = addTab(viewSplitter, item->icon(), item->title());
     } else {
         insertTab(index, viewSplitter, item->icon(), item->title());
     }
 
     connectTerminalDisplay(view);
     connect(viewSplitter, &ViewSplitter::destroyed, this, &TabbedViewContainer::viewDestroyed);
     connect(viewSplitter, &ViewSplitter::terminalDisplayDropped, this, &TabbedViewContainer::terminalDisplayDropped);
 
     setCurrentIndex(index);
     emit viewAdded(view);
 }
 
 void TabbedViewContainer::splitView(TerminalDisplay *view, Qt::Orientation orientation)
 {
     auto viewSplitter = qobject_cast<ViewSplitter*>(currentWidget());
     viewSplitter->addTerminalDisplay(view, orientation);
     connectTerminalDisplay(view);
 }
 
 void TabbedViewContainer::connectTerminalDisplay(TerminalDisplay *display)
 {
     auto item = display->sessionController();
     connect(item, &Konsole::SessionController::focused, this,
         &Konsole::TabbedViewContainer::currentSessionControllerChanged);
 
     connect(item, &Konsole::ViewProperties::titleChanged, this,
             &Konsole::TabbedViewContainer::updateTitle);
 
     connect(item, &Konsole::ViewProperties::iconChanged, this,
             &Konsole::TabbedViewContainer::updateIcon);
 
     connect(item, &Konsole::ViewProperties::activity, this,
             &Konsole::TabbedViewContainer::updateActivity);
 }
 
 void TabbedViewContainer::disconnectTerminalDisplay(TerminalDisplay *display)
 {
     auto item = display->sessionController();
     disconnect(item, &Konsole::SessionController::focused, this,
         &Konsole::TabbedViewContainer::currentSessionControllerChanged);
 
     disconnect(item, &Konsole::ViewProperties::titleChanged, this,
             &Konsole::TabbedViewContainer::updateTitle);
 
     disconnect(item, &Konsole::ViewProperties::iconChanged, this,
             &Konsole::TabbedViewContainer::updateIcon);
 
     disconnect(item, &Konsole::ViewProperties::activity, this,
             &Konsole::TabbedViewContainer::updateActivity);
 }
 
 void TabbedViewContainer::viewDestroyed(QObject *view)
 {
     auto widget = static_cast<ViewSplitter*>(view);
     const auto idx = indexOf(widget);
 
     removeTab(idx);
     forgetView(widget);
 }
 
 void TabbedViewContainer::forgetView(ViewSplitter *view)
 {
     Q_UNUSED(view);
     if (count() == 0) {
         emit empty(this);
     }
 }
 
 void TabbedViewContainer::activateNextView()
 {
     QWidget *active = currentWidget();
     int index = indexOf(active);
     setCurrentIndex(index == count() - 1 ? 0 : index + 1);
 }
 
 void TabbedViewContainer::activateLastView()
 {
     setCurrentIndex(count() - 1);
 }
 
 void TabbedViewContainer::activatePreviousView()
 {
     QWidget *active = currentWidget();
     int index = indexOf(active);
     setCurrentIndex(index == 0 ? count() - 1 : index - 1);
 }
 
 void TabbedViewContainer::keyReleaseEvent(QKeyEvent* event)
 {
     if (event->modifiers() == Qt::NoModifier) {
         _connectedViewManager->updateTerminalDisplayHistory();
     }
 }
 
 void TabbedViewContainer::closeCurrentTab()
 {
     if (currentIndex() != -1) {
         closeTerminalTab(currentIndex());
     }
 }
 
 void TabbedViewContainer::tabDoubleClicked(int index)
 {
     if (index >= 0) {
         renameTab(index);
     } else {
         emit newViewRequest();
     }
 }
 
 void TabbedViewContainer::renameTab(int index)
 {
     if (index != -1) {
         setCurrentIndex(index);
         viewSplitterAt(index)
             -> activeTerminalDisplay()
             -> sessionController()
             -> rename();
     }
 }
 
 void TabbedViewContainer::openTabContextMenu(const QPoint &point)
 {
     if (point.isNull()) {
         return;
     }
 
     _contextMenuTabIndex = tabBar()->tabAt(point);
     if (_contextMenuTabIndex < 0) {
         return;
     }
 
     //TODO: add a countChanged signal so we can remove this for.
     // Detaching in mac causes crashes.
     for(auto action : _contextPopupMenu->actions()) {
         if (action->objectName() == QStringLiteral("tab-detach")) {
             action->setEnabled(count() > 1);
         }
     }
 
     /* This needs to nove away fro the tab or to lock every thing inside of it.
      * for now, disable.
      * */
     //
     // Add the read-only action
 #if 0
     auto sessionController = terminalAt(_contextMenuTabIndex)->sessionController();
 
     if (sessionController != nullptr) {
         auto collection = sessionController->actionCollection();
         auto readonlyAction = collection->action(QStringLiteral("view-readonly"));
         if (readonlyAction != nullptr) {
             const auto readonlyActions = _contextPopupMenu->actions();
             _contextPopupMenu->insertAction(readonlyActions.last(), readonlyAction);
         }
 
         // Disable tab rename
         for (auto &action : _contextPopupMenu->actions()) {
             if (action->objectName() == QStringLiteral("edit-rename")) {
                 action->setEnabled(!sessionController->isReadOnly());
                 break;
             }
         }
     }
 #endif
     _contextPopupMenu->exec(tabBar()->mapToGlobal(point));
 }
 
 void TabbedViewContainer::currentTabChanged(int index)
 {
     if (index != -1) {
         auto splitview = qobject_cast<ViewSplitter*>(widget(index));
         auto view = splitview->activeTerminalDisplay();
         emit activeViewChanged(view);
         setTabActivity(index, false);
     } else {
         deleteLater();
     }
 }
 
 void TabbedViewContainer::wheelScrolled(int delta)
 {
     if (delta < 0) {
         activateNextView();
     } else {
         activatePreviousView();
     }
 }
 
 void TabbedViewContainer::setTabActivity(int index, bool activity)
 {
     const QPalette &palette = tabBar()->palette();
     KColorScheme colorScheme(palette.currentColorGroup());
     const QColor colorSchemeActive = colorScheme.foreground(KColorScheme::ActiveText).color();
 
     const QColor normalColor = palette.text().color();
     const QColor activityColor = KColorUtils::mix(normalColor, colorSchemeActive);
 
     QColor color = activity ? activityColor : QColor();
 
     if (color != tabBar()->tabTextColor(index)) {
         tabBar()->setTabTextColor(index, color);
     }
 }
 
 void TabbedViewContainer::updateActivity(ViewProperties *item)
 {
     auto controller = qobject_cast<SessionController*>(item);
     auto index = indexOf(controller->view());
     if (index != currentIndex()) {
         setTabActivity(index, true);
     }
 }
 
 void TabbedViewContainer::currentSessionControllerChanged(SessionController *controller)
 {
     updateTitle(qobject_cast<ViewProperties*>(controller));
 }
 
 void TabbedViewContainer::updateTitle(ViewProperties *item)
 {
     auto controller = qobject_cast<SessionController*>(item);
     auto topLevelSplitter = qobject_cast<ViewSplitter*>(controller->view()->parentWidget())->getToplevelSplitter();
 
     const int index = indexOf(topLevelSplitter);
     QString tabText = item->title();
 
     setTabToolTip(index, tabText);
 
     // To avoid having & replaced with _ (shortcut indicator)
     tabText.replace(QLatin1Char('&'), QLatin1String("&&"));
     setTabText(index, tabText);
 }
 
 void TabbedViewContainer::updateIcon(ViewProperties *item)
 {
     auto controller = qobject_cast<SessionController*>(item);
     const int index = indexOf(controller->view());
     setTabIcon(index, item->icon());
 }
 
 void TabbedViewContainer::closeTerminalTab(int idx) {
     //TODO: This for should probably go to the ViewSplitter
     for (auto terminal : viewSplitterAt(idx)->findChildren<TerminalDisplay*>()) {
         terminal->sessionController()->closeSession();
     }
 }
 
 ViewManager *TabbedViewContainer::connectedViewManager()
 {
     return _connectedViewManager;
 }
 
 void TabbedViewContainer::setNavigationVisibility(ViewManager::NavigationVisibility navigationVisibility) {
     if (navigationVisibility == ViewManager::NavigationNotSet) {
         return;
     }
 
     setTabBarAutoHide(navigationVisibility == ViewManager::ShowNavigationAsNeeded);
     if (navigationVisibility == ViewManager::AlwaysShowNavigation) {
         tabBar()->setVisible(true);
     } else if (navigationVisibility == ViewManager::AlwaysHideNavigation) {
         tabBar()->setVisible(false);
     }
 }
 
 void TabbedViewContainer::toggleMaximizeCurrentTerminal()
 {
     if (auto *terminal = qobject_cast<TerminalDisplay*>(sender())) {
         terminal->setFocus(Qt::FocusReason::OtherFocusReason);
     }
 
     activeViewSplitter()->toggleMaximizeCurrentTerminal();
 }
 
 void TabbedViewContainer::moveTabLeft()
 {
     if (currentIndex() == 0) {
         return;
     }
     tabBar()->moveTab(currentIndex(), currentIndex() -1);
 }
 
 void TabbedViewContainer::moveTabRight()
 {
     if (currentIndex() == count() -1) {
         return;
     }
     tabBar()->moveTab(currentIndex(), currentIndex() + 1);
 }
 
 void TabbedViewContainer::setNavigationBehavior(int behavior)
 {
     _newTabBehavior = static_cast<NewTabBehavior>(behavior);
 }
diff --git a/src/ViewSplitter.cpp b/src/ViewSplitter.cpp
index 077a619b..881f6c2e 100644
--- a/src/ViewSplitter.cpp
+++ b/src/ViewSplitter.cpp
@@ -1,351 +1,350 @@
 /*
     This file is part of the Konsole Terminal.
 
     Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301  USA.
 */
 
 // Own
 #include "ViewSplitter.h"
 
 // Qt
 #include <QDebug>
 #include <QChildEvent>
 #include <QScrollBar>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QDragMoveEvent>
 #include <QMimeType>
 #include <QMimeData>
 #include <QApplication>
 #include <memory>
 
 
 // Konsole
 #include "ViewContainer.h"
 #include "TerminalDisplay.h"
 
 using Konsole::ViewSplitter;
 using Konsole::TerminalDisplay;
 
 //TODO: Connect the TerminalDisplay destroyed signal here.
 
 ViewSplitter::ViewSplitter(QWidget *parent) :
     QSplitter(parent)
 {
     setAcceptDrops(true);
 }
 
 /* This function is called on the toplevel splitter, we need to look at the actual ViewSplitter inside it */
 void ViewSplitter::adjustActiveTerminalDisplaySize(int percentage)
 {
     auto focusedTerminalDisplay = activeTerminalDisplay();
     Q_ASSERT(focusedTerminalDisplay);
 
     auto parentSplitter = qobject_cast<ViewSplitter*>(focusedTerminalDisplay->parent());
     const int containerIndex = parentSplitter->indexOf(activeTerminalDisplay());
     Q_ASSERT(containerIndex != -1);
 
     QList<int> containerSizes = parentSplitter->sizes();
 
     const int oldSize = containerSizes[containerIndex];
     const int newSize = static_cast<int>(oldSize * (1.0 + percentage / 100.0));
     const int perContainerDelta = (count() == 1) ? 0 : ((newSize - oldSize) / (count() - 1)) * (-1);
 
     for (int& size : containerSizes) {
         size += perContainerDelta;
     }
     containerSizes[containerIndex] = newSize;
 
     parentSplitter->setSizes(containerSizes);
 }
 
 // Get the first splitter that's a parent of the current focused widget.
 ViewSplitter *ViewSplitter::activeSplitter()
 {
     QWidget *widget = focusWidget() != nullptr ? focusWidget() : this;
 
     ViewSplitter *splitter = nullptr;
 
     while ((splitter == nullptr) && (widget != nullptr)) {
         splitter = qobject_cast<ViewSplitter *>(widget);
         widget = widget->parentWidget();
     }
 
     Q_ASSERT(splitter);
     return splitter;
 }
 
 void ViewSplitter::updateSizes()
 {
     const int space = (orientation() == Qt::Horizontal ? width() : height()) / count();
     setSizes(QVector<int>(count(), space).toList());
 }
 
 void ViewSplitter::addTerminalDisplay(TerminalDisplay *terminalDisplay, Qt::Orientation containerOrientation, AddBehavior behavior)
 {
     ViewSplitter *splitter = activeSplitter();
     const int currentIndex = !splitter->activeTerminalDisplay() ? splitter->count()
                             : splitter->indexOf(splitter->activeTerminalDisplay());
 
     if (splitter->count() < 2) {
         splitter->insertWidget(behavior == AddBehavior::AddBefore ? currentIndex : currentIndex + 1, terminalDisplay);
         splitter->setOrientation(containerOrientation);
-        qDebug() << "Adding < 2" << (behavior == AddBehavior::AddBefore ? "Before" : "After") << "Display";
     } else if (containerOrientation == splitter->orientation()) {
         splitter->insertWidget(currentIndex, terminalDisplay);
     } else {
         auto newSplitter = new ViewSplitter();
         TerminalDisplay *oldTerminalDisplay = splitter->activeTerminalDisplay();
         const int oldContainerIndex = splitter->indexOf(oldTerminalDisplay);
         newSplitter->addWidget(behavior == AddBehavior::AddBefore ? terminalDisplay : oldTerminalDisplay);
         newSplitter->addWidget(behavior == AddBehavior::AddBefore ? oldTerminalDisplay : terminalDisplay);
         newSplitter->setOrientation(containerOrientation);
         newSplitter->updateSizes();
         newSplitter->show();
         splitter->insertWidget(oldContainerIndex, newSplitter);
     }
     splitter->updateSizes();
 }
 
 void ViewSplitter::childEvent(QChildEvent *event)
 {
     QSplitter::childEvent(event);
 
     if (event->removed()) {
         if (count() == 0) {
             deleteLater();
         }
         if (!findChild<TerminalDisplay*>()) {
             deleteLater();
         }
     }
 
     auto terminals = getToplevelSplitter()->findChildren<TerminalDisplay*>();
     if (terminals.size() == 1) {
         terminals.at(0)->headerBar()->setVisible(false);
     } else {
         for(auto terminal : terminals) {
             terminal->headerBar()->setVisible(true);
         }
     }
 }
 
 void ViewSplitter::handleFocusDirection(Qt::Orientation orientation, int direction)
 {
     auto terminalDisplay = activeTerminalDisplay();
     auto parentSplitter = qobject_cast<ViewSplitter*>(terminalDisplay->parentWidget());
     auto topSplitter = parentSplitter->getToplevelSplitter();
 
     const auto handleWidth = parentSplitter->handleWidth() <= 1 ? 4 : parentSplitter->handleWidth();
 
     const auto start = QPoint(terminalDisplay->x(), terminalDisplay->y());
     const auto startMapped = parentSplitter->mapTo(topSplitter, start);
 
     const int newX = orientation != Qt::Horizontal ? startMapped.x() + handleWidth
              : direction == 1 ? startMapped.x() + terminalDisplay->width() + handleWidth
              : startMapped.x() - handleWidth;
 
     const int newY = orientation != Qt::Vertical ? startMapped.y() + handleWidth
                     : direction == 1 ? startMapped.y() + terminalDisplay->height() + handleWidth
                     : startMapped.y() - handleWidth;
 
     const auto newPoint = QPoint(newX, newY);
     auto child = topSplitter->childAt(newPoint);
 
     if (TerminalDisplay* terminal = qobject_cast<TerminalDisplay*>(child)) {
         terminal->setFocus(Qt::OtherFocusReason);
     } else if (qobject_cast<QSplitterHandle*>(child)) {
         auto targetSplitter = qobject_cast<QSplitter*>(child->parent());
         auto splitterTerminal = qobject_cast<TerminalDisplay*>(targetSplitter->widget(0));
         splitterTerminal->setFocus(Qt::OtherFocusReason);
     } else if (qobject_cast<QWidget*>(child)) {
         TerminalDisplay *terminalParent = nullptr;
         while(!terminalParent) {
             terminalParent = qobject_cast<TerminalDisplay*>(child->parentWidget());
             child = child->parentWidget();
         }
         terminalParent->setFocus(Qt::OtherFocusReason);
     }
 }
 
 void ViewSplitter::focusUp()
 {
     handleFocusDirection(Qt::Vertical, -1);
 }
 
 void ViewSplitter::focusDown()
 {
     handleFocusDirection(Qt::Vertical, +1);
 }
 
 void ViewSplitter::focusLeft()
 {
     handleFocusDirection(Qt::Horizontal, -1);
 }
 
 void ViewSplitter::focusRight()
 {
     handleFocusDirection(Qt::Horizontal, +1);
 }
 
 TerminalDisplay *ViewSplitter::activeTerminalDisplay() const
 {
     auto focusedWidget = qobject_cast<TerminalDisplay*>(focusWidget());
     return focusedWidget ? focusedWidget : findChild<TerminalDisplay*>();
 }
 
 void ViewSplitter::toggleMaximizeCurrentTerminal()
 {
     m_terminalMaximized = !m_terminalMaximized;
     handleMinimizeMaximize(m_terminalMaximized);
 }
 
 namespace {
     void restoreAll(QList<TerminalDisplay*>&& terminalDisplays, QList<ViewSplitter*>&& splitters) {
         for (auto splitter : splitters) {
             splitter->setVisible(true);
         }
         for (auto terminalDisplay : terminalDisplays) {
             terminalDisplay->setVisible(true);
         }
     }
 }
 
 bool ViewSplitter::hideRecurse(TerminalDisplay *currentTerminalDisplay) {
     bool allHidden = true;
 
     for(int i = 0, end = count(); i < end; i++) {
         if (auto *maybeSplitter = qobject_cast<ViewSplitter*>(widget(i))) {
             allHidden = maybeSplitter->hideRecurse(currentTerminalDisplay) && allHidden;
             continue;
         }
         if (auto maybeTerminalDisplay = qobject_cast<TerminalDisplay*>(widget(i))) {
             if (maybeTerminalDisplay == currentTerminalDisplay) {
                 allHidden = false;
             } else {
                 maybeTerminalDisplay->setVisible(false);
             }
         }
     }
 
     if (allHidden) {
         setVisible(false);
     }
     return allHidden;
 }
 
 void ViewSplitter::handleMinimizeMaximize(bool maximize)
 {
     auto topLevelSplitter = getToplevelSplitter();
     auto currentTerminalDisplay = topLevelSplitter->activeTerminalDisplay();
     if (maximize) {
         for (int i = 0, end = topLevelSplitter->count(); i < end; i++) {
             auto widgetAt = topLevelSplitter->widget(i);
             if (auto *maybeSplitter = qobject_cast<ViewSplitter*>(widgetAt)) {
                 maybeSplitter->hideRecurse(currentTerminalDisplay);
             }
             if (auto maybeTerminalDisplay = qobject_cast<TerminalDisplay*>(widgetAt)) {
                 if (maybeTerminalDisplay != currentTerminalDisplay) {
                     maybeTerminalDisplay->setVisible(false);
                 }
             }
         }
     } else {
         restoreAll(topLevelSplitter->findChildren<TerminalDisplay*>(),
                    topLevelSplitter->findChildren<ViewSplitter*>());
     }
 }
 
 ViewSplitter *ViewSplitter::getToplevelSplitter()
 {
     ViewSplitter *current = this;
     while(qobject_cast<ViewSplitter*>(current->parentWidget())) {
         current = qobject_cast<ViewSplitter*>(current->parentWidget());
     }
     return current;
 }
 
 namespace {
     TerminalDisplay *currentDragTarget = nullptr;
 }
 
 void Konsole::ViewSplitter::dragEnterEvent(QDragEnterEvent* ev)
 {
     const auto dragId = QStringLiteral("konsole/terminal_display");
     if (ev->mimeData()->hasFormat(dragId)) {
         auto other_pid = ev->mimeData()->data(dragId).toInt();
         // don't accept the drop if it's another instance of konsole
         if (qApp->applicationPid() != other_pid)
             return;
         if (getToplevelSplitter()->terminalMaximized()) {
             return;
         }
         ev->accept();
     }
 }
 
 void Konsole::ViewSplitter::dragMoveEvent(QDragMoveEvent* ev)
 {
     auto currentWidget = childAt(ev->pos());
     if (auto terminal = qobject_cast<TerminalDisplay*>(currentWidget)) {
         if (currentDragTarget && currentDragTarget != terminal) {
             currentDragTarget->hideDragTarget();
         }
         if (terminal == ev->source()) {
             return;
         }
         currentDragTarget = terminal;
         currentDragTarget->showDragTarget();
     }
 }
 
 void Konsole::ViewSplitter::dragLeaveEvent(QDragLeaveEvent* event)
 {
     if (currentDragTarget)
         currentDragTarget->hideDragTarget();
 }
 
 void Konsole::ViewSplitter::dropEvent(QDropEvent* ev)
 {
     if (ev->mimeData()->hasFormat(QStringLiteral("konsole/terminal_display"))) {
         if (getToplevelSplitter()->terminalMaximized()) {
             return;
         }
         if (currentDragTarget) {
             currentDragTarget->hideDragTarget();
             auto source = qobject_cast<TerminalDisplay*>(ev->source());
             source->setVisible(false);
             source->setParent(nullptr);
 
             currentDragTarget->setFocus(Qt::OtherFocusReason);
 
             AddBehavior behavior = currentDragTarget->droppedEdge() == Qt::LeftEdge || currentDragTarget->droppedEdge() == Qt::TopEdge
                 ? AddBehavior::AddBefore : AddBehavior::AddAfter;
             Qt::Orientation orientation = currentDragTarget->droppedEdge() == Qt::LeftEdge || currentDragTarget->droppedEdge() == Qt::RightEdge
                 ? Qt::Horizontal : Qt::Vertical;
 
             // topLevel is the splitter that's connected with the ViewManager
             // that in turn can call the SessionController.
             getToplevelSplitter()->terminalDisplayDropped(source);
             addTerminalDisplay(source, orientation, behavior);
             source->setVisible(true);
         }
     }
 }