diff --git a/src/Application.cpp b/src/Application.cpp
--- a/src/Application.cpp
+++ b/src/Application.cpp
@@ -186,7 +186,7 @@
     MainWindow *window = newMainWindow();
     ViewManager *manager = window->viewManager();
 
-    manager->createView(manager->activeContainer(), session);
+    manager->createView(session);
 
     // Since user is dragging and dropping, move dnd window to where
     // the user has the cursor (correct multiple monitor setups).
diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
--- a/src/MainWindow.cpp
+++ b/src/MainWindow.cpp
@@ -467,6 +467,7 @@
 
 void MainWindow::newTab(TabbedViewContainer *tabWidget)
 {
+    qDebug() << "New Tab Triggered";
     Profile::Ptr defaultProfile = ProfileManager::instance()->defaultProfile();
     createSession(tabWidget, defaultProfile, activeSessionDir());
 }
@@ -504,8 +505,8 @@
     // doesn't suffer a change in terminal size right after the session
     // starts.  Some applications such as GNU Screen and Midnight Commander
     // don't like this happening
-    _viewManager->createView(tabWidget, session);
-
+    auto newView = _viewManager->createView(session);
+    _viewManager->activeContainer()->addView(newView);
     return session;
 }
 
@@ -534,8 +535,8 @@
     // doesn't suffer a change in terminal size right after the session
     // starts.  some applications such as GNU Screen and Midnight Commander
     // don't like this happening
-    _viewManager->createView(tabWidget, session);
-
+    auto newView = _viewManager->createView(session);
+    _viewManager->activeContainer()->addView(newView);
     return session;
 }
 
diff --git a/src/Part.cpp b/src/Part.cpp
--- a/src/Part.cpp
+++ b/src/Part.cpp
@@ -213,7 +213,8 @@
         session->setInitialWorkingDirectory(directory);
     }
 
-    _viewManager->createView(_viewManager->activeContainer(), session);
+    auto newView = _viewManager->createView(session);
+    _viewManager->activeContainer()->addView(newView);
 }
 
 void Part::activeViewChanged(SessionController *controller)
diff --git a/src/ViewContainer.h b/src/ViewContainer.h
--- a/src/ViewContainer.h
+++ b/src/ViewContainer.h
@@ -145,7 +145,7 @@
      * The only thing that this class holds are TerminalDisplays, so
      * this is the only thing that should be used to retrieve widgets.
      */
-    TerminalDisplay *terminalAt(int index);
+    ViewSplitter *viewSplitterAt(int index);
 Q_SIGNALS:
     /** Emitted when the container has no more children */
     void empty(TabbedViewContainer *container);
@@ -198,7 +198,7 @@
     void konsoleConfigChanged();
 
 private:
-    void forgetView(TerminalDisplay *view);
+    void forgetView(ViewSplitter *view);
     void updateTabHistory(TerminalDisplay *view, bool remove = false);
 
     QList<TerminalDisplay *> _tabHistory;
@@ -209,6 +209,7 @@
     int _contextMenuTabIndex;
     ViewManager::NavigationVisibility _navigationVisibility;
     int _tabHistoryIndex;
+    ViewSplitter *_viewSplitter;
 };
 
 
diff --git a/src/ViewContainer.cpp b/src/ViewContainer.cpp
--- a/src/ViewContainer.cpp
+++ b/src/ViewContainer.cpp
@@ -47,6 +47,7 @@
 #include "SessionController.h"
 #include "DetachableTabBar.h"
 #include "TerminalDisplay.h"
+#include "ViewSplitter.h"
 
 // TODO Perhaps move everything which is Konsole-specific into different files
 
@@ -86,9 +87,12 @@
         &Konsole::TabbedViewContainer::tabDoubleClicked);
     connect(tabBar(), &QTabBar::customContextMenuRequested, this,
         &Konsole::TabbedViewContainer::openTabContextMenu);
-    connect(tabBarWidget, &DetachableTabBar::detachTab, this, [this](int idx) {
-        emit detachTab(this, terminalAt(idx));
-    });
+
+    //TODO: Fix Detach.
+    // connect(tabBarWidget, &DetachableTabBar::detachTab, this, [this](int idx) {
+    //    emit detachTab(this, terminalAt(idx));
+    //});
+
     connect(this, &TabbedViewContainer::currentChanged, this, &TabbedViewContainer::currentTabChanged);
 
     // The context menu of tab bar
@@ -104,12 +108,14 @@
     });
 
 #if defined(ENABLE_DETACHING)
+    /* TODO FIX DETACH
     auto detachAction = _contextPopupMenu->addAction(
         QIcon::fromTheme(QStringLiteral("tab-detach")),
         i18nc("@action:inmenu", "&Detach Tab"), this,
         [this] { emit detachTab(this, terminalAt(_contextMenuTabIndex)); }
     );
     detachAction->setObjectName(QStringLiteral("tab-detach"));
+    */
 #endif
 
     auto editAction = _contextPopupMenu->addAction(
@@ -145,13 +151,15 @@
     }
 }
 
-TerminalDisplay *TabbedViewContainer::terminalAt(int index)
+ViewSplitter *TabbedViewContainer::viewSplitterAt(int index)
 {
-    return qobject_cast<TerminalDisplay*>(widget(index));
+    return qobject_cast<ViewSplitter*>(widget(index));
 }
 
 void TabbedViewContainer::moveTabToWindow(int index, QWidget *window)
 {
+    // TODO: Fix Detaching.
+    /*
     const int id = terminalAt(index)->sessionController()->identifier();
     // This one line here will be removed as soon as I finish my new split handling.
     // it's hacky but it works.
@@ -163,6 +171,7 @@
             removeView(terminalAt(index));
         }
     }
+    */
 }
 
 void TabbedViewContainer::konsoleConfigChanged()
@@ -232,28 +241,33 @@
     const int currentIndex = indexOf(currentWidget());
     int newIndex = direction  == MoveViewLeft ? qMax(currentIndex - 1, 0) : qMin(currentIndex + 1, count() - 1);
 
-    auto swappedWidget = terminalAt(newIndex);
-    auto currentWidget = terminalAt(currentIndex);
-    auto swappedContext = swappedWidget->sessionController();
-    auto currentContext = currentWidget->sessionController();
+    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, currentContext->icon(), currentContext->title());
-        insertTab(currentIndex, swappedWidget, swappedContext->icon(), swappedContext->title());
+        insertTab(newIndex, currentWidget, currentIcon, currentTitle);
+        insertTab(currentIndex, swappedWidget, swappedIcon, swappedTitle);
     } else {
-        insertTab(currentIndex, swappedWidget, swappedContext->icon(), swappedContext->title());
-        insertTab(newIndex, currentWidget, currentContext->icon(), currentContext->title());
+        insertTab(currentIndex, swappedWidget, swappedIcon, swappedTitle);
+        insertTab(newIndex, currentWidget, currentIcon, currentTitle);
     }
     setCurrentIndex(newIndex);
 }
 
 void TabbedViewContainer::addView(TerminalDisplay *view, int index)
 {
+    auto viewSplitter = new ViewSplitter();
+    viewSplitter->addTerminalDisplay(view, Qt::Horizontal);
     auto item = view->sessionController();
     if (index == -1) {
-        addTab(view, item->icon(), item->title());
+        addTab(viewSplitter, item->icon(), item->title());
     } else {
-        insertTab(index, view, item->icon(), item->title());
+        insertTab(index, viewSplitter, item->icon(), item->title());
     }
 
     _tabHistory.append(view);
@@ -263,24 +277,25 @@
             &Konsole::TabbedViewContainer::updateIcon);
     connect(item, &Konsole::ViewProperties::activity, this,
             &Konsole::TabbedViewContainer::updateActivity);
-    connect(view, &QWidget::destroyed, this,
-            &Konsole::TabbedViewContainer::viewDestroyed);
+
+    connect(viewSplitter, &ViewSplitter::destroyed, this, &TabbedViewContainer::viewDestroyed);
     emit viewAdded(view);
 }
 
 void TabbedViewContainer::viewDestroyed(QObject *view)
 {
-    auto widget = static_cast<TerminalDisplay*>(view);
+    auto widget = static_cast<ViewSplitter*>(view);
     const auto idx = indexOf(widget);
 
     removeTab(idx);
     forgetView(widget);
 }
 
-void TabbedViewContainer::forgetView(TerminalDisplay *view)
+void TabbedViewContainer::forgetView(ViewSplitter *view)
 {
-    updateTabHistory(view, true);
-    emit viewRemoved(view);
+    //TODO: Fix updateTabHistory
+    // updateTabHistory(view, true);
+    // emit viewRemoved(view);
     if (count() == 0) {
         emit empty(this);
     }
@@ -291,7 +306,7 @@
     const int idx = indexOf(view);
     disconnect(view, &QWidget::destroyed, this, &Konsole::TabbedViewContainer::viewDestroyed);
     removeTab(idx);
-    forgetView(view);
+  //  forgetView(view);
 }
 
 void TabbedViewContainer::activateNextView()
@@ -387,8 +402,12 @@
 
 void TabbedViewContainer::renameTab(int index)
 {
+    /* TODO: Fix renaming.
+        The problem with the renaming right now is that many Terminals can be at a tab.
+    */
+
     if (index != -1) {
-        terminalAt(index)->sessionController()->rename();
+//        terminalAt(index)->sessionController()->rename();
     }
 }
 
@@ -413,9 +432,13 @@
     }
 #endif
 
+    /* This needs to nove away fro the tab or to lock every thing inside of it.
+     * for now, disable.
+     * */
+    //
     // Add the read-only action
-    auto controller = terminalAt(_contextMenuTabIndex)->sessionController();
-    auto sessionController = qobject_cast<SessionController*>(controller);
+#if 0
+    auto sessionController = terminalAt(_contextMenuTabIndex)->sessionController();
 
     if (sessionController != nullptr) {
         auto collection = sessionController->actionCollection();
@@ -433,14 +456,14 @@
             }
         }
     }
-
+#endif
     _contextPopupMenu->exec(tabBar()->mapToGlobal(point));
 }
 
 void TabbedViewContainer::currentTabChanged(int index)
 {
     if (index != -1) {
-        auto *view = terminalAt(index);
+        auto view = widget(index)->findChild<TerminalDisplay*>();
         view->setFocus();
         updateTabHistory(view);
         emit activeViewChanged(view);
@@ -506,7 +529,10 @@
 }
 
 void TabbedViewContainer::closeTerminalTab(int idx) {
-    terminalAt(idx)->sessionController()->closeSession();
+    //TODO: This for should probably go to the ViewSplitter
+    for (auto terminal : viewSplitterAt(idx)->findChildren<TerminalDisplay*>()) {
+        terminal->sessionController()->closeSession();
+    }
 }
 
 ViewManager *TabbedViewContainer::connectedViewManager()
diff --git a/src/ViewManager.h b/src/ViewManager.h
--- a/src/ViewManager.h
+++ b/src/ViewManager.h
@@ -74,12 +74,6 @@
     ViewManager(QObject *parent, KActionCollection *collection);
     ~ViewManager() Q_DECL_OVERRIDE;
 
-    /**
-     * Creates a new view to display the output from and deliver input to @p session.
-     * Constructs a new container to hold the views if no container has yet been created.
-     */
-    void createView(TabbedViewContainer *tabWidget, Session *session);
-
     /**
      * Applies the view-specific settings associated with specified @p profile
      * to the terminal display @p view.
@@ -197,6 +191,7 @@
     /** returns the active tab from the view
     */
     TabbedViewContainer *activeContainer();
+    TerminalDisplay *createView(Session *session);
 
 Q_SIGNALS:
     /** Emitted when the last view is removed from the view manager */
@@ -387,7 +382,6 @@
 private:
     Q_DISABLE_COPY(ViewManager)
 
-    void createView(Session *session, TabbedViewContainer *container, int index);
     static const ColorScheme *colorSchemeForProfile(const Profile::Ptr profile);
 
     void setupActions();
@@ -414,7 +408,7 @@
     SessionController *createController(Session *session, TerminalDisplay *view);
 
 private:
-    QPointer<ViewSplitter> _viewSplitter;
+    QPointer<TabbedViewContainer> _viewContainer;
     QPointer<SessionController> _pluggedController;
 
     QHash<TerminalDisplay *, Session *> _sessionMap;
diff --git a/src/ViewManager.cpp b/src/ViewManager.cpp
--- a/src/ViewManager.cpp
+++ b/src/ViewManager.cpp
@@ -52,36 +52,24 @@
 
 ViewManager::ViewManager(QObject *parent, KActionCollection *collection) :
     QObject(parent),
-    _viewSplitter(nullptr),
+    _viewContainer(nullptr),
     _pluggedController(nullptr),
     _sessionMap(QHash<TerminalDisplay *, Session *>()),
     _actionCollection(collection),
     _navigationMethod(NoNavigation),
     _navigationVisibility(NavigationNotSet),
     _newTabBehavior(PutNewTabAtTheEnd),
     _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);
-
+    _viewContainer = createContainer();
     // setup actions which are related to the views
     setupActions();
 
+    /* TODO: Reconnect
     // emit a signal when all of the views held by this view manager are destroyed
-    connect(_viewSplitter.data(), &Konsole::ViewSplitter::allContainersEmpty,
+    */
+    connect(_viewContainer.data(), &Konsole::TabbedViewContainer::empty,
             this, &Konsole::ViewManager::empty);
-    connect(_viewSplitter.data(), &Konsole::ViewSplitter::empty, this,
-            &Konsole::ViewManager::empty);
 
     // listen for profile changes
     connect(ProfileManager::instance(), &Konsole::ProfileManager::profileChanged,
@@ -95,8 +83,6 @@
     _managerId = ++lastManagerId;
     QDBusConnection::sessionBus().registerObject(QLatin1String("/Windows/")
                                                  + QString::number(_managerId), this);
-
-    _viewSplitter->addContainer(createContainer(), Qt::Vertical);
 }
 
 ViewManager::~ViewManager() = default;
@@ -108,17 +94,12 @@
 
 QWidget *ViewManager::activeView() const
 {
-    TabbedViewContainer *container = _viewSplitter->activeContainer();
-    if (container != nullptr) {
-        return container->currentWidget();
-    } else {
-        return nullptr;
-    }
+    return _viewContainer->currentWidget();
 }
 
 QWidget *ViewManager::widget() const
 {
-    return _viewSplitter;
+    return _viewContainer;
 }
 
 void ViewManager::setupActions()
@@ -249,16 +230,16 @@
     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);
+   // _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);
+    // _viewSplitter->addAction(previousViewAction);
 
     collection->setDefaultShortcut(nextContainerAction, Qt::SHIFT + Qt::Key_Tab);
     connect(nextContainerAction, &QAction::triggered, this, &Konsole::ViewManager::nextContainer);
-    _viewSplitter->addAction(nextContainerAction);
+    // _viewSplitter->addAction(nextContainerAction);
 
 #ifdef Q_OS_MACOS
     collection->setDefaultShortcut(moveViewLeftAction,
@@ -268,7 +249,7 @@
 #endif
     connect(moveViewLeftAction, &QAction::triggered, this,
             &Konsole::ViewManager::moveActiveViewLeft);
-    _viewSplitter->addAction(moveViewLeftAction);
+    // _viewSplitter->addAction(moveViewLeftAction);
 
 #ifdef Q_OS_MACOS
     collection->setDefaultShortcut(moveViewRightAction,
@@ -278,23 +259,23 @@
 #endif
     connect(moveViewRightAction, &QAction::triggered, this,
             &Konsole::ViewManager::moveActiveViewRight);
-    _viewSplitter->addAction(moveViewRightAction);
+    // _viewSplitter->addAction(moveViewRightAction);
 
     connect(lastViewAction, &QAction::triggered, this, &Konsole::ViewManager::lastView);
-    _viewSplitter->addAction(lastViewAction);
+    // _viewSplitter->addAction(lastViewAction);
 
     collection->setDefaultShortcut(lastUsedViewAction, Qt::CTRL + Qt::Key_Tab);
     connect(lastUsedViewAction, &QAction::triggered, this, &Konsole::ViewManager::lastUsedView);
-    _viewSplitter->addAction(lastUsedViewAction);
+    // _viewSplitter->addAction(lastUsedViewAction);
 
     collection->setDefaultShortcut(lastUsedViewReverseAction, Qt::CTRL + Qt::SHIFT + Qt::Key_Tab);
     connect(lastUsedViewReverseAction, &QAction::triggered, this, &Konsole::ViewManager::lastUsedViewReverse);
-    _viewSplitter->addAction(lastUsedViewReverseAction);
+    // _viewSplitter->addAction(lastUsedViewReverseAction);
 }
 
 void ViewManager::switchToView(int index)
 {
-    _viewSplitter->activeContainer()->setCurrentIndex(index);
+    _viewContainer->setCurrentIndex(index);
 }
 
 void ViewManager::updateDetachViewState()
@@ -304,6 +285,7 @@
         return;
     }
 
+#if 0
     const bool splitView = _viewSplitter->containers().count() >= 2;
     auto activeContainer = _viewSplitter->activeContainer();
     const bool shouldEnable = splitView
@@ -315,67 +297,57 @@
     if ((detachAction != nullptr) && shouldEnable != detachAction->isEnabled()) {
         detachAction->setEnabled(shouldEnable);
     }
+#endif
 }
 
 void ViewManager::moveActiveViewLeft()
 {
-    TabbedViewContainer *container = _viewSplitter->activeContainer();
-    Q_ASSERT(container);
-    container->moveActiveView(TabbedViewContainer::MoveViewLeft);
+    _viewContainer->moveActiveView(TabbedViewContainer::MoveViewLeft);
 }
 
 void ViewManager::moveActiveViewRight()
 {
-    TabbedViewContainer *container = _viewSplitter->activeContainer();
-    Q_ASSERT(container);
-    container->moveActiveView(TabbedViewContainer::MoveViewRight);
+    _viewContainer->moveActiveView(TabbedViewContainer::MoveViewRight);
 }
 
 void ViewManager::nextContainer()
 {
-    _viewSplitter->activateNextContainer();
+    //_viewSplitter->activateNextContainer();
 }
 
 void ViewManager::nextView()
 {
-    TabbedViewContainer *container = _viewSplitter->activeContainer();
-    Q_ASSERT(container);
-    container->activateNextView();
+    _viewContainer->activateNextView();
 }
 
 void ViewManager::previousView()
 {
-    TabbedViewContainer *container = _viewSplitter->activeContainer();
-    Q_ASSERT(container);
-    container->activatePreviousView();
+    _viewContainer->activatePreviousView();
 }
 
 void ViewManager::lastView()
 {
-    TabbedViewContainer *container = _viewSplitter->activeContainer();
-    Q_ASSERT(container);
-    container->activateLastView();
+    _viewContainer->activateLastView();
 }
 
 void ViewManager::lastUsedView()
 {
-    TabbedViewContainer *container = _viewSplitter->activeContainer();
-    Q_ASSERT(container);
-    container->activateLastUsedView(false);
+    _viewContainer->activateLastUsedView(false);
 }
 
 void ViewManager::lastUsedViewReverse()
 {
-    TabbedViewContainer *container = _viewSplitter->activeContainer();
-    Q_ASSERT(container);
-    container->activateLastUsedView(true);
+    _viewContainer->activateLastUsedView(true);
 }
 
 void ViewManager::detachActiveView()
 {
+    //TODO: Disable Detach temporarely.
+#if 0
     // find the currently active view and remove it from its container
     TabbedViewContainer *container = _viewSplitter->activeContainer();
     detachView(container, container->currentWidget());
+#endif
 }
 
 void ViewManager::detachView(TabbedViewContainer *container, QWidget *view)
@@ -406,25 +378,28 @@
     // 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
+//TODO: Verify if this is correct.
+#if 0
     if (_viewSplitter->containers().count() > 1
         && container->count() == 0) {
         removeContainer(container);
     }
+#endif
 }
 
 void ViewManager::sessionFinished()
 {
     // if this slot is called after the view manager's main widget
     // has been destroyed, do nothing
-    if (_viewSplitter.isNull()) {
+    if (_viewContainer.isNull()) {
         return;
     }
 
     auto *session = qobject_cast<Session *>(sender());
     Q_ASSERT(session);
 
     // close attached views
-    QList<TerminalDisplay *> children = _viewSplitter->findChildren<TerminalDisplay *>();
+    QList<TerminalDisplay *> children = _viewContainer->findChildren<TerminalDisplay *>();
 
     foreach (TerminalDisplay *view, children) {
         if (_sessionMap[view] == session) {
@@ -465,38 +440,28 @@
 
 void ViewManager::splitView(Qt::Orientation orientation)
 {
-    TabbedViewContainer *container = createContainer();
+    auto viewSplitter = qobject_cast<ViewSplitter*>(_viewContainer->currentWidget());
 
-    if (_viewSplitter->activeContainer()->count()) {
-        // get the currently applied profile and use it to create the new tab.
-        auto *activeContainer= _viewSplitter->activeContainer();
-        auto *currentDisplay = qobject_cast<TerminalDisplay*>(activeContainer->currentWidget());
-        auto profile = SessionManager::instance()->sessionProfile(_sessionMap[currentDisplay]);
+    // get the currently applied profile and use it to create the new tab.
+    auto *currentDisplay = viewSplitter->findChild<TerminalDisplay*>();
+    auto profile = SessionManager::instance()->sessionProfile(_sessionMap[currentDisplay]);
 
-        // Create a new session with the selected profile.
-        auto *session = SessionManager::instance()->createSession(profile);
-        session->addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_WINDOW=/Windows/%1").arg(managerId()));
+    // Create a new session with the selected profile.
+    auto *session = SessionManager::instance()->createSession(profile);
+    session->addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_WINDOW=/Windows/%1").arg(managerId()));
 
-        createView(session, container, 0);
-    }
+    auto terminalDisplay = createView(session);
 
-    _viewSplitter->addContainer(container, orientation);
-    emit splitViewToggle(_viewSplitter->containers().count() > 0);
+    viewSplitter->addTerminalDisplay(terminalDisplay, orientation);
+    emit splitViewToggle(viewSplitter->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);
-    }
+    terminalDisplay->setFocus();
 }
 
 void ViewManager::removeContainer(TabbedViewContainer *container)
 {
+#if 0
     // remove session map entries for views in this container
     for(int i = 0, end = container->count(); i < end; i++) {
         auto view = container->widget(i);
@@ -509,20 +474,26 @@
     container->deleteLater();
 
     emit splitViewToggle(_viewSplitter->containers().count() > 1);
+#endif
 }
 
 void ViewManager::expandActiveContainer()
 {
+#if 0
     _viewSplitter->adjustContainerSize(_viewSplitter->activeContainer(), 10);
+#endif
 }
 
 void ViewManager::shrinkActiveContainer()
 {
+#if 0
     _viewSplitter->adjustContainerSize(_viewSplitter->activeContainer(), -10);
+#endif
 }
 
 void ViewManager::closeActiveContainer()
 {
+#if 0
     // only do something if there is more than one container active
     if (_viewSplitter->containers().count() > 1) {
         TabbedViewContainer *container = _viewSplitter->activeContainer();
@@ -533,17 +504,20 @@
         // without having to manually focus it themselves
         nextContainer();
     }
+#endif
 }
 
 void ViewManager::closeOtherContainers()
 {
+#if 0
     TabbedViewContainer *active = _viewSplitter->activeContainer();
 
     foreach (TabbedViewContainer *container, _viewSplitter->containers()) {
         if (container != active) {
             removeContainer(container);
         }
     }
+#endif
 }
 
 SessionController *ViewManager::createController(Session *session, TerminalDisplay *view)
@@ -576,7 +550,8 @@
         return;
     }
 
-    _viewSplitter->setFocusProxy(controller->view());
+    //TODO: Verify This.
+    // _viewSplitter->setFocusProxy(controller->view());
 
     _pluggedController = controller;
     emit activeViewChanged(controller);
@@ -587,7 +562,7 @@
     return _pluggedController;
 }
 
-void ViewManager::createView(Session *session, TabbedViewContainer *container, int index)
+TerminalDisplay *ViewManager::createView(Session *session)
 {
     // notify this view manager when the session finishes so that its view
     // can be deleted
@@ -607,29 +582,18 @@
     createController(session, display);
 
     _sessionMap[display] = session;
-    container->addView(display, index);
     session->addView(display);
 
     // tell the session whether it has a light or dark background
     session->setDarkBackground(colorSchemeForProfile(profile)->hasDarkBackground());
-    container->setCurrentWidget(display);
     display->setFocus(Qt::OtherFocusReason);
-
     updateDetachViewState();
-}
-
-void ViewManager::createView(TabbedViewContainer *tabWidget, Session *session)
-{
-    const int index = _newTabBehavior == PutNewTabAfterCurrentTab ?
-                _viewSplitter->activeContainer()->currentIndex() + 1 : -1;
-
-    createView(session, tabWidget, index);
+    return display;
 }
 
 TabbedViewContainer *ViewManager::createContainer()
 {
-
-    auto *container = new TabbedViewContainer(this, _viewSplitter);
+    auto *container = new TabbedViewContainer(this, nullptr);
     container->setNavigationVisibility(_navigationVisibility);
     //TODO: Fix Detaching.
     connect(container, &TabbedViewContainer::detachTab, this, &ViewManager::detachView);
@@ -661,12 +625,14 @@
 
 void ViewManager::containerMoveViewRequest(int index, int id)
 {
+    Q_UNUSED(index);
+
     auto *container = qobject_cast<TabbedViewContainer *>(sender());
     auto *controller = qobject_cast<SessionController *>(ViewProperties::propertiesById(id));
     Q_ASSERT(container);
     Q_ASSERT(controller);
 
-    createView(controller->session(), container, index);
+    createView(controller->session());
     controller->session()->refresh();
     container->currentWidget()->setFocus();
 }
@@ -718,9 +684,8 @@
 
 void ViewManager::containerViewsChanged(TabbedViewContainer *container)
 {
-    if ((!_viewSplitter.isNull()) && container == _viewSplitter->activeContainer()) {
-        emit viewPropertiesChanged(viewProperties());
-    }
+    // TODO: Verify that this is right.
+    emit viewPropertiesChanged(viewProperties());
 }
 
 void ViewManager::viewDestroyed(QWidget *view)
@@ -740,9 +705,12 @@
         }
     }
     //we only update the focus if the splitter is still alive
+    // TODO: Verify.
+#if 0
     if (!_viewSplitter.isNull()) {
         updateDetachViewState();
     }
+#endif
     // The below causes the menus  to be messed up
     // Only happens when using the tab bar close button
 //    if (_pluggedController)
@@ -874,18 +842,16 @@
 {
     QList<ViewProperties *> list;
 
-    TabbedViewContainer *container = _viewSplitter->activeContainer();
+    TabbedViewContainer *container = _viewContainer;
     if (container == nullptr) {
         return {};
     }
 
-    list.reserve(container->count());
+    auto terminalContainers = _viewContainer->findChildren<TerminalDisplay*>();
+    list.reserve(terminalContainers.size());
 
-    for(int i = 0, end = container->count(); i < end; i++) {
-        auto view = container->terminalAt(i);
-        ViewProperties *properties = view->sessionController();
-        Q_ASSERT(properties);
-        list << properties;
+    for(auto terminalDisplay : _viewContainer->findChildren<TerminalDisplay*>()) {
+        list.append(terminalDisplay->sessionController());
     }
 
     return list;
@@ -898,7 +864,7 @@
     QSet<Session *> unique;
     int tab = 1;
 
-    TabbedViewContainer *container = _viewSplitter->activeContainer();
+    TabbedViewContainer *container = _viewContainer;
 
     // first: sessions in the active container, preserving the order
     Q_ASSERT(container);
@@ -935,7 +901,7 @@
 
 TabbedViewContainer *ViewManager::activeContainer()
 {
-    return _viewSplitter->activeContainer();
+    return _viewContainer;
 }
 
 void ViewManager::restoreSessions(const KConfigGroup &group)
@@ -955,7 +921,7 @@
             break;
         }
 
-        createView(activeContainer(), session);
+        createView(session);
         if (!session->isRunning()) {
             session->run();
         }
@@ -965,14 +931,14 @@
     }
 
     if (display != nullptr) {
-        _viewSplitter->activeContainer()->setCurrentWidget(display);
+        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(activeContainer(), session);
+        createView(session);
         if (!session->isRunning()) {
             session->run();
         }
@@ -1012,7 +978,7 @@
     QHash<TerminalDisplay *, Session *>::const_iterator i;
     for (i = _sessionMap.constBegin(); i != _sessionMap.constEnd(); ++i) {
         if (i.value()->sessionId() == sessionId) {
-            TabbedViewContainer *container = _viewSplitter->activeContainer();
+            TabbedViewContainer *container = activeContainer();
             if (container != nullptr) {
                 container->setCurrentWidget(i.key());
             }
@@ -1027,7 +993,7 @@
 
     session->addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_WINDOW=/Windows/%1").arg(managerId()));
 
-    createView(activeContainer(), session);
+    createView(session);
     session->run();
 
     return session->sessionId();
@@ -1049,7 +1015,7 @@
 
     session->addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_WINDOW=/Windows/%1").arg(managerId()));
 
-    createView(activeContainer(), session);
+    createView(session);
     session->run();
 
     return session->sessionId();
@@ -1072,7 +1038,7 @@
 
     session->addEnvironmentEntry(QStringLiteral("KONSOLE_DBUS_WINDOW=/Windows/%1").arg(managerId()));
 
-    createView(activeContainer(), session);
+    createView(session);
     session->run();
 
     return session->sessionId();
@@ -1110,18 +1076,14 @@
 
 void ViewManager::setTabWidthToText(bool setTabWidthToText)
 {
-    for(auto container : _viewSplitter->containers()) {
-        container->tabBar()->setExpanding(!setTabWidthToText);
-        container->tabBar()->update();
-    }
+    _viewContainer->tabBar()->setExpanding(!setTabWidthToText);
+    _viewContainer->tabBar()->update();
 }
 
 void ViewManager::setNavigationVisibility(NavigationVisibility navigationVisibility) {
     if (_navigationVisibility != navigationVisibility) {
         _navigationVisibility = navigationVisibility;
-        for(auto *container : _viewSplitter->containers()) {
-            container->setNavigationVisibility(navigationVisibility);
-        }
+        _viewContainer->setNavigationVisibility(navigationVisibility);
     }
 }
 
diff --git a/src/ViewSplitter.h b/src/ViewSplitter.h
--- a/src/ViewSplitter.h
+++ b/src/ViewSplitter.h
@@ -29,7 +29,7 @@
 class QFocusEvent;
 
 namespace Konsole {
-class TabbedViewContainer;
+class TerminalDisplay;
 
 /**
  * A splitter which holds a number of ViewContainer objects and allows
@@ -65,10 +65,10 @@
      *                    will be created, into which the container will
      *                    be inserted.
      */
-    void addContainer(TabbedViewContainer *container, Qt::Orientation orientation);
+    void addTerminalDisplay(TerminalDisplay *terminalDisplay, Qt::Orientation orientation);
 
     /** Removes a container from the splitter.  The container is not deleted. */
-    void removeContainer(TabbedViewContainer *container);
+    void removeTerminalDisplay(TerminalDisplay *terminalDisplay);
 
     /** Returns the child ViewSplitter widget which currently has the focus */
     ViewSplitter *activeSplitter();
@@ -84,25 +84,17 @@
      * mySplitter->activeSplitter()->activeContainer() where mySplitter
      * is the ViewSplitter widget at the top of the hierarchy.
      */
-    TabbedViewContainer *activeContainer() const;
+    TerminalDisplay *activeTerminalDisplay() const;
 
     /**
      * Gives the focus to the active view in the specified container
      */
-    void setActiveContainer(TabbedViewContainer *container);
-
-    /**
-     * Returns a list of the containers held by this splitter
-     */
-    QList<TabbedViewContainer *> containers() const
-    {
-        return _containers;
-    }
+    void setActiveTerminalDisplay(TerminalDisplay *container);
 
     /**
      * Gives the focus to the active view in the next container
      */
-    void activateNextContainer();
+    void activateNextTerminalDisplay();
 
     /**
      * Changes the size of the specified @p container by a given @p percentage.
@@ -113,73 +105,20 @@
      * The sizes of the remaining containers are increased or decreased
      * uniformly to maintain the width of the splitter.
      */
-    void adjustContainerSize(TabbedViewContainer *container, int percentage);
+    void adjustTerminalDisplaySize(TerminalDisplay *container, int percentage);
 
     /**
      * Gives the focus to the active view in the previous container
      */
-    void activatePreviousContainer();
-
-    /**
-     * Specifies whether the view may be split recursively.
-     *
-     * If this is false, all containers will be placed into the same
-     * top-level splitter.  Adding a container with an orientation
-     * which is different to that specified when adding the previous
-     * containers will change the orientation for all dividers
-     * between containers.
-     *
-     * If this is true, adding a container to the view splitter with
-     * an orientation different to the orientation of the previous
-     * area will result in the previously active container being
-     * replaced with a new splitter containing the active container
-     * and the newly added container.
-     */
-    void setRecursiveSplitting(bool recursive);
-
-    /**
-     * Returns whether the view may be split recursively.
-     * See setRecursiveSplitting()
-     */
-    bool recursiveSplitting() const;
+    void activatePreviousTerminalDisplay();
 
 Q_SIGNALS:
     /** Signal emitted when the last child widget is removed from the splitter */
     void empty(ViewSplitter *splitter);
 
-    /**
-     * Signal emitted when the containers held by this splitter become empty, this
-     * differs from the empty() signal which is only emitted when all of the containers
-     * are deleted.  This signal is emitted even if there are still container widgets.
-     *
-     * TODO: This does not yet work recursively (ie. when splitters inside splitters have empty containers)
-     */
-    void allContainersEmpty();
-
-protected:
-    //virtual void focusEvent(QFocusEvent* event);
-
 private:
-    // Adds container to splitter's internal list and
-    // connects signals and slots
-    void registerContainer(TabbedViewContainer *container);
-    // Removes container from splitter's internal list and
-    // removes signals and slots
-    void unregisterContainer(TabbedViewContainer *container);
-
     void updateSizes();
-
-private Q_SLOTS:
-    // Called to indicate that a child ViewContainer is empty
-    void containerEmpty(TabbedViewContainer *container);
-
-    // Called to indicate that a child ViewSplitter is empty
-    // (ie. all child widgets have been deleted)
-    void childEmpty(ViewSplitter *splitter);
-
-private:
-    QList<TabbedViewContainer *> _containers;
-    bool _recursiveSplitting;
+    void childDestroyed(QObject *terminalDisplay);
 };
 }
 #endif //VIEWSPLITTER_H
diff --git a/src/ViewSplitter.cpp b/src/ViewSplitter.cpp
--- a/src/ViewSplitter.cpp
+++ b/src/ViewSplitter.cpp
@@ -27,27 +27,19 @@
 
 // Konsole
 #include "ViewContainer.h"
+#include "TerminalDisplay.h"
 
 using Konsole::ViewSplitter;
-using Konsole::TabbedViewContainer;
+using Konsole::TerminalDisplay;
+
+//TODO: Connect the TerminalDisplay destroyed signal here.
 
 ViewSplitter::ViewSplitter(QWidget *parent) :
-    QSplitter(parent),
-    _containers(QList<TabbedViewContainer *>()),
-    _recursiveSplitting(true)
+    QSplitter(parent)
 {
 }
 
-void ViewSplitter::childEmpty(ViewSplitter *splitter)
-{
-    delete splitter;
-
-    if (count() == 0) {
-        emit empty(this);
-    }
-}
-
-void ViewSplitter::adjustContainerSize(TabbedViewContainer *container, int percentage)
+void ViewSplitter::adjustTerminalDisplaySize(TerminalDisplay *container, int percentage)
 {
     int containerIndex = indexOf(container);
 
@@ -86,18 +78,6 @@
     return splitter;
 }
 
-void ViewSplitter::registerContainer(TabbedViewContainer *container)
-{
-    _containers << container;
-    connect(container, SIGNAL(empty(TabbedViewContainer*)), this, SLOT(containerEmpty(TabbedViewContainer*)));
-}
-
-void ViewSplitter::unregisterContainer(TabbedViewContainer *container)
-{
-    _containers.removeAll(container);
-    disconnect(container, nullptr, this, nullptr);
-}
-
 void ViewSplitter::updateSizes()
 {
     int space;
@@ -118,62 +98,51 @@
     setSizes(widgetSizes);
 }
 
-void ViewSplitter::setRecursiveSplitting(bool recursive)
-{
-    _recursiveSplitting = recursive;
-}
-
-bool ViewSplitter::recursiveSplitting() const
-{
-    return _recursiveSplitting;
-}
-
-void ViewSplitter::removeContainer(TabbedViewContainer *container)
-{
-    Q_ASSERT(containers().contains(container));
-
-    unregisterContainer(container);
-}
-
-void ViewSplitter::addContainer(TabbedViewContainer *container, Qt::Orientation containerOrientation)
+void ViewSplitter::addTerminalDisplay(TerminalDisplay *terminalDisplay, Qt::Orientation containerOrientation)
 {
     ViewSplitter *splitter = activeSplitter();
 
     if (splitter->count() < 2
-        || containerOrientation == splitter->orientation()
-        || !_recursiveSplitting) {
-        splitter->registerContainer(container);
-        splitter->addWidget(container);
+        || containerOrientation == splitter->orientation()) {
+        splitter->addWidget(terminalDisplay);
 
         if (splitter->orientation() != containerOrientation) {
             splitter->setOrientation(containerOrientation);
         }
-
+        connect(terminalDisplay, &QObject::destroyed, this, &ViewSplitter::childDestroyed);
         splitter->updateSizes();
     } else {
-        auto newSplitter = new ViewSplitter(this);
-        connect(newSplitter, &Konsole::ViewSplitter::empty, splitter,
-                &Konsole::ViewSplitter::childEmpty);
+        auto newSplitter = new ViewSplitter();
+        connect(newSplitter, &QObject::destroyed, this, &ViewSplitter::childDestroyed);
+        connect(terminalDisplay, &QObject::destroyed, newSplitter, &ViewSplitter::childDestroyed);
 
-        TabbedViewContainer *oldContainer = splitter->activeContainer();
-        const int oldContainerIndex = splitter->indexOf(oldContainer);
+        TerminalDisplay *oldTerminalDisplay = splitter->activeTerminalDisplay();
+        disconnect(oldTerminalDisplay, &QObject::destroyed, nullptr, nullptr);
+        connect(oldTerminalDisplay, &QObject::destroyed, newSplitter, &ViewSplitter::childDestroyed);
 
-        splitter->unregisterContainer(oldContainer);
-
-        newSplitter->registerContainer(oldContainer);
-        newSplitter->registerContainer(container);
-
-        newSplitter->addWidget(oldContainer);
-        newSplitter->addWidget(container);
+        const int oldContainerIndex = splitter->indexOf(oldTerminalDisplay);
+        newSplitter->addWidget(oldTerminalDisplay);
+        newSplitter->addWidget(terminalDisplay);
         newSplitter->setOrientation(containerOrientation);
         newSplitter->updateSizes();
         newSplitter->show();
 
         splitter->insertWidget(oldContainerIndex, newSplitter);
     }
 }
 
-void ViewSplitter::containerEmpty(TabbedViewContainer * myContainer)
+void ViewSplitter::childDestroyed(QObject *childWidget)
+{
+    // remove the parent so count() has the correct value.
+    childWidget->setParent(nullptr);
+    if (count() == 0) {
+        deleteLater();
+    }
+}
+
+//TODO: Maybe move this to the TabbedViewContainer ?
+#if 0
+void ViewSplitter::containerEmpty(TerminalDisplay * myContainer)
 {
     _containers.removeAll(myContainer);
     if (count() == 0) {
@@ -195,85 +164,47 @@
         currentSplitter = qobject_cast<ViewSplitter*>(currentSplitter->parent());
     }
 
-    for(auto tabWidget : currentSplitter->findChildren<TabbedViewContainer*>()) {
+    for(auto tabWidget : currentSplitter->findChildren<TerminalDisplay*>()) {
         if (tabWidget != myContainer && tabWidget->count()) {
             tabWidget->setCurrentIndex(0);
         }
     }
 }
+#endif
 
-void ViewSplitter::activateNextContainer()
+void ViewSplitter::activateNextTerminalDisplay()
 {
-    TabbedViewContainer *active = activeContainer();
+    TerminalDisplay *active = activeTerminalDisplay();
 
-    int index = _containers.indexOf(active);
+    int index = indexOf(active);
 
     if (index == -1) {
         return;
     }
 
-    if (index == _containers.count() - 1) {
+    if (index == count() - 1) {
         index = 0;
     } else {
         index++;
     }
-
-    setActiveContainer(_containers.at(index));
+    widget(index)->setFocus(Qt::OtherFocusReason);
 }
 
-void ViewSplitter::activatePreviousContainer()
+void ViewSplitter::activatePreviousTerminalDisplay()
 {
-    TabbedViewContainer *active = activeContainer();
+    TerminalDisplay *active = activeTerminalDisplay();
 
-    int index = _containers.indexOf(active);
+    int index = indexOf(active);
 
     if (index == 0) {
-        index = _containers.count() - 1;
+        index = count() - 1;
     } else {
         index--;
     }
-
-    setActiveContainer(_containers.at(index));
-}
-
-void ViewSplitter::setActiveContainer(TabbedViewContainer *container)
-{
-    QWidget *activeView = container->currentWidget();
-
-    if (activeView != nullptr) {
-        activeView->setFocus(Qt::OtherFocusReason);
-    }
+    widget(index)->setFocus(Qt::OtherFocusReason);
 }
 
-TabbedViewContainer *ViewSplitter::activeContainer() const
+TerminalDisplay *ViewSplitter::activeTerminalDisplay() const
 {
-    if (QWidget *focusW = focusWidget()) {
-        TabbedViewContainer *focusContainer = nullptr;
-
-        while (focusW != nullptr) {
-            foreach (TabbedViewContainer *container, _containers) {
-                if (container == focusW) {
-                    focusContainer = container;
-                    break;
-                }
-            }
-            focusW = focusW->parentWidget();
-        }
-
-        if (focusContainer != nullptr) {
-            return focusContainer;
-        }
-    }
-
-    QList<ViewSplitter *> splitters = findChildren<ViewSplitter *>();
-
-    if (!splitters.isEmpty()) {
-        return splitters.last()->activeContainer();
-    } else {
-        if (!_containers.isEmpty()) {
-            return _containers.last();
-        } else {
-            return nullptr;
-        }
-    }
+    return qobject_cast<TerminalDisplay*>(focusWidget());
 }