Merge lp:~dandrader/qtmir/miral-surfacemanager into lp:~unity-team/qtmir/miral-qt-integration

[Daniel d'Andrada]

Move TopLevelWindowModel out of qtmir. Export a SurfaceManager instead

Dramatically improves the interface between qtmir and unity8

Needs:
https://code.launchpad.net/~dandrader/unity-api/miral-surfacemanager/+merge/310910

[Gerry Boland (gerboland)]

Smaller API is cleaner.

review: Approve

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2016-11-03 20:17:46 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2016-11-15 17:55:38 +0000
@@ -45,14 +45,13 @@
     session.cpp
     sessionmanager.cpp
     sharedwakelock.cpp
+    surfacemanager.cpp
     upstart/applicationinfo.cpp
     upstart/taskcontroller.cpp
     timer.cpp
     timesource.cpp
-    toplevelwindowmodel.cpp
     tracepoints.c
     settings.cpp
-    window.cpp
     windowmodel.cpp
 # We need to run moc on these headers
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
@@ -61,8 +60,7 @@
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceItemInterface.h
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceListInterface.h
-    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/TopLevelWindowModelInterface.h
-    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/WindowInterface.h
+    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/SurfaceManagerInterface.h
 # Feed the automoc monster
     session_interface.h
     applicationinfo.h

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2016-11-03 20:17:46 +0000
+++ src/modules/Unity/Application/application.h	2016-11-15 17:55:38 +0000
@@ -103,6 +103,7 @@
     unity::shell::application::MirSurfaceListInterface* surfaceList() const override;
     unity::shell::application::MirSurfaceListInterface* promptSurfaceList() const override;
     int surfaceCount() const override { return surfaceList()->count(); }
+    void close() override;
 
     ProcessState processState() const { return m_processState; }
     void setProcessState(ProcessState value);
@@ -119,8 +120,6 @@
 
     pid_t pid() const;
 
-    void close();
-
     // internal as in "not exposed in unity-api", so qtmir-internal.
     InternalState internalState() const { return m_state; }
 

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2016-11-03 20:17:46 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2016-11-15 17:55:38 +0000
@@ -577,6 +577,17 @@
     authorized = true;
 }
 
+
+unityapi::ApplicationInfoInterface *ApplicationManager::findApplicationWithSurface(unityapi::MirSurfaceInterface* surface)
+{
+    if (!surface)
+        return nullptr;
+
+    auto qtmirSurface = static_cast<qtmir::MirSurfaceInterface*>(surface);
+
+    return findApplicationWithPid(miral::pid_of(qtmirSurface->session()->session()));
+}
+
 Application* ApplicationManager::findApplicationWithSession(const std::shared_ptr<ms::Session> &session)
 {
     if (!session)

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2016-11-03 20:17:46 +0000
+++ src/modules/Unity/Application/application_manager.h	2016-11-15 17:55:38 +0000
@@ -26,9 +26,11 @@
 
 // local
 #include "application.h"
-#include "applicationmanagerinterface.h"
 #include "taskcontroller.h"
 
+// Unity API
+#include <unity/shell/application/ApplicationManagerInterface.h>
+
 namespace mir {
     namespace scene {
         class Session;
@@ -53,7 +55,7 @@
 class SharedWakelock;
 class SettingsInterface;
 
-class ApplicationManager : public ApplicationManagerInterface
+class ApplicationManager : public unity::shell::application::ApplicationManagerInterface
 {
     Q_OBJECT
 
@@ -81,13 +83,11 @@
     QString focusedApplicationId() const override;
     Q_INVOKABLE qtmir::Application* get(int index) const override;
     Q_INVOKABLE qtmir::Application* findApplication(const QString &appId) const override;
+    unity::shell::application::ApplicationInfoInterface *findApplicationWithSurface(unity::shell::application::MirSurfaceInterface* surface) override;
     Q_INVOKABLE bool requestFocusApplication(const QString &appId) override;
     Q_INVOKABLE qtmir::Application* startApplication(const QString &appId, const QStringList &arguments = QStringList()) override;
     Q_INVOKABLE bool stopApplication(const QString &appId) override;
 
-    // qtmir::ApplicationManagerInterface
-    Application* findApplicationWithSession(const std::shared_ptr<mir::scene::Session> &session) override;
-
     // QAbstractListModel
     int rowCount(const QModelIndex & parent = QModelIndex()) const override;
     QVariant data(const QModelIndex & index, int role) const override;
@@ -119,6 +119,7 @@
     void onApplicationClosing(Application *application);
 
 private:
+    Application* findApplicationWithSession(const std::shared_ptr<mir::scene::Session> &session);
     void setFocused(Application *application);
     void add(Application *application);
     void remove(Application* application);

=== removed file 'src/modules/Unity/Application/applicationmanagerinterface.h'
--- src/modules/Unity/Application/applicationmanagerinterface.h	2016-11-03 20:17:46 +0000
+++ src/modules/Unity/Application/applicationmanagerinterface.h	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef QTMIR_APPLICATION_MANAGER_INTERFACE_H
-#define QTMIR_APPLICATION_MANAGER_INTERFACE_H
-
-// Unity API
-#include <unity/shell/application/ApplicationManagerInterface.h>
-
-namespace qtmir {
-
-class ApplicationManagerInterface : public unity::shell::application::ApplicationManagerInterface
-{
-public:
-    ApplicationManagerInterface(QObject *parent) : unity::shell::application::ApplicationManagerInterface(parent) {}
-
-    virtual Application* findApplicationWithSession(const std::shared_ptr<mir::scene::Session> &session) = 0;
-};
-
-} // namespace qtmir
-
-#endif // QTMIR_APPLICATION_MANAGER_INTERFACE_H

=== modified file 'src/modules/Unity/Application/mirsurfaceinterface.h'
--- src/modules/Unity/Application/mirsurfaceinterface.h	2016-11-03 20:17:46 +0000
+++ src/modules/Unity/Application/mirsurfaceinterface.h	2016-11-15 17:55:38 +0000
@@ -116,7 +116,6 @@
     void ready();
     void cursorChanged(const QCursor &cursor);
     void raiseRequested();
-    void closeRequested();
     void framesPosted();
     void isBeingDisplayedChanged();
     void frameDropped();

=== modified file 'src/modules/Unity/Application/plugin.cpp'
--- src/modules/Unity/Application/plugin.cpp	2016-11-03 20:17:46 +0000
+++ src/modules/Unity/Application/plugin.cpp	2016-11-15 17:55:38 +0000
@@ -23,9 +23,8 @@
 #include "mirsurfaceinterface.h"
 #include "mirsurfaceitem.h"
 #include "mirsurfacelistmodel.h"
-#include "toplevelwindowmodel.h"
-#include "window.h"
 #include "windowmodel.h"
+#include "surfacemanager.h"
 
 // platforms/mirserver
 #include <mirsingleton.h>
@@ -65,8 +64,8 @@
         qRegisterMetaType<qtmir::Application*>("Application*");
         qRegisterMetaType<unity::shell::application::MirSurfaceInterface*>("MirSurfaceInterface*");
         qRegisterMetaType<unity::shell::application::MirSurfaceListInterface*>("unity::shell::application::MirSurfaceListInterface*");
+        qRegisterMetaType<unity::shell::application::SurfaceManagerInterface*>("unity::shell::application::SurfaceManagerInterface*");
         qRegisterMetaType<MirSurfaceAttrib>("MirSurfaceAttrib");
-        qRegisterMetaType<unity::shell::application::WindowInterface*>("unity::shell::application::WindowInterface*");
 
         qmlRegisterUncreatableType<unity::shell::application::ApplicationManagerInterface>(
                     uri, 0, 1, "ApplicationManagerInterface", "Abstract interface. Cannot be created in QML");
@@ -80,9 +79,9 @@
                     uri, 0, 1, "MirSurface", "MirSurface can't be instantiated from QML");
         qmlRegisterType<qtmir::MirSurfaceItem>(uri, 0, 1, "MirSurfaceItem");
         qmlRegisterSingletonType<qtmir::Mir>(uri, 0, 1, "Mir", mirSingleton);
+        qmlRegisterType<qtmir::SurfaceManager>(uri, 0, 1, "SurfaceManager");
 
         qmlRegisterType<qtmir::WindowModel>(uri, 0, 1, "WindowModel");
-        qmlRegisterType<qtmir::TopLevelWindowModel>(uri, 0, 1, "TopLevelWindowModel");
     }
 
     virtual void initializeEngine(QQmlEngine *engine, const char *uri)

=== added file 'src/modules/Unity/Application/surfacemanager.cpp'
--- src/modules/Unity/Application/surfacemanager.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/surfacemanager.cpp	2016-11-15 17:55:38 +0000
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "surfacemanager.h"
+
+#include "mirsurface.h"
+#include "sessionmanager.h"
+
+// mirserver
+#include "nativeinterface.h"
+
+// Qt
+#include <QGuiApplication>
+
+Q_LOGGING_CATEGORY(QTMIR_SURFACEMANAGER, "qtmir.surfacemanager", QtDebugMsg)
+
+#define DEBUG_MSG qCDebug(QTMIR_SURFACEMANAGER).nospace().noquote() << __func__
+
+using namespace qtmir;
+namespace unityapi = unity::shell::application;
+
+SurfaceManager::SurfaceManager(QObject *)
+{
+    DEBUG_MSG << "()";
+
+    auto nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
+
+    if (!nativeInterface) {
+        qFatal("ERROR: Unity.Application QML plugin requires use of the 'mirserver' QPA plugin");
+    }
+
+    m_windowController = static_cast<WindowControllerInterface*>(nativeInterface->nativeResourceForIntegration("WindowController"));
+
+    auto windowModel = static_cast<WindowModelNotifier*>(nativeInterface->nativeResourceForIntegration("WindowModelNotifier"));
+    connectToWindowModelNotifier(windowModel);
+
+    m_sessionManager = SessionManager::singleton();
+}
+
+void SurfaceManager::connectToWindowModelNotifier(WindowModelNotifier *notifier)
+{
+    connect(notifier, &WindowModelNotifier::windowAdded,        this, &SurfaceManager::onWindowAdded,        Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowRemoved,      this, &SurfaceManager::onWindowRemoved,      Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowReady,        this, &SurfaceManager::onWindowReady,        Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowMoved,        this, &SurfaceManager::onWindowMoved,        Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowStateChanged, this, &SurfaceManager::onWindowStateChanged, Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowFocusChanged, this, &SurfaceManager::onWindowFocusChanged, Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowsRaised,      this, &SurfaceManager::onWindowsRaised,      Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::modificationsStarted, this, &SurfaceManager::modificationsStarted, Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::modificationsEnded, this, &SurfaceManager::modificationsEnded, Qt::QueuedConnection);
+}
+
+void SurfaceManager::rememberMirSurface(MirSurface *surface)
+{
+    m_allSurfaces.append(surface);
+}
+
+void SurfaceManager::forgetMirSurface(const miral::Window &window)
+{
+    for (int i = 0; i < m_allSurfaces.count(); ++i) {
+        if (m_allSurfaces[i]->window() == window) {
+            m_allSurfaces.removeAt(i);
+            return;
+        }
+    }
+}
+void SurfaceManager::onWindowAdded(const NewWindow &window)
+{
+    auto mirSession = window.windowInfo.window().application();
+    SessionInterface* session = m_sessionManager->findSession(mirSession.get());
+
+    auto surface = new MirSurface(window, m_windowController, session);
+    rememberMirSurface(surface);
+
+    if (session)
+        session->registerSurface(surface);
+
+    Q_EMIT surfaceCreated(surface);
+}
+
+void SurfaceManager::onWindowRemoved(const miral::WindowInfo &windowInfo)
+{
+    MirSurface *surface = find(windowInfo);
+    forgetMirSurface(windowInfo.window());
+    surface->setLive(false);
+}
+
+MirSurface *SurfaceManager::find(const miral::WindowInfo &needle) const
+{
+    return find(needle.window());
+}
+
+MirSurface *SurfaceManager::find(const miral::Window &window) const
+{
+    Q_FOREACH(const auto surface, m_allSurfaces) {
+        if (surface->window() == window) {
+            return surface;
+        }
+    }
+    return nullptr;
+}
+
+void SurfaceManager::onWindowReady(const miral::WindowInfo &windowInfo)
+{
+    if (auto mirSurface = find(windowInfo)) {
+        mirSurface->setReady();
+    }
+}
+
+void SurfaceManager::onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft)
+{
+    if (auto mirSurface = find(windowInfo)) {
+        mirSurface->setPosition(topLeft);
+    }
+}
+
+void SurfaceManager::onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused)
+{
+    if (auto mirSurface = find(windowInfo)) {
+        mirSurface->setFocused(focused);
+    }
+}
+
+void SurfaceManager::onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state)
+{
+    if (auto mirSurface = find(windowInfo)) {
+        mirSurface->updateState(state);
+    }
+}
+
+void SurfaceManager::onWindowsRaised(const std::vector<miral::Window> &windows)
+{
+    // sad inefficiency when crossing API boundaries (from miral to qt)
+    const int raiseCount = windows.size();
+    QVector<unityapi::MirSurfaceInterface*> surfaces(raiseCount);
+    for (int i = 0; i < raiseCount; i++) {
+        auto mirSurface = find(windows[i]);
+        surfaces.append(mirSurface);
+    }
+    Q_EMIT surfacesRaised(surfaces);
+}
+
+void SurfaceManager::raise(unityapi::MirSurfaceInterface *surface)
+{
+    auto qtmirSurface = static_cast<qtmir::MirSurface*>(surface);
+    m_windowController->raise(qtmirSurface->window());
+}
+
+void SurfaceManager::activate(unityapi::MirSurfaceInterface *surface)
+{
+    auto qtmirSurface = static_cast<qtmir::MirSurface*>(surface);
+    m_windowController->activate(qtmirSurface ? qtmirSurface->window() : miral::Window());
+}

=== added file 'src/modules/Unity/Application/surfacemanager.h'
--- src/modules/Unity/Application/surfacemanager.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/surfacemanager.h	2016-11-15 17:55:38 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QTMIR_SURFACEMANAGER_H
+#define QTMIR_SURFACEMANAGER_H
+
+// common
+#include "windowmodelnotifier.h"
+
+// Unity API
+#include <unity/shell/application/SurfaceManagerInterface.h>
+
+#include <QVector>
+#include <QLoggingCategory>
+
+Q_DECLARE_LOGGING_CATEGORY(QTMIR_SURFACEMANAGER)
+
+namespace qtmir {
+
+class MirSurface;
+class SessionManager;
+class WindowControllerInterface;
+
+class SurfaceManager : public unity::shell::application::SurfaceManagerInterface
+{
+    Q_OBJECT
+
+public:
+    explicit SurfaceManager(QObject *parent = 0);
+    virtual ~SurfaceManager() {}
+
+    void raise(unity::shell::application::MirSurfaceInterface *surface) override;
+    void activate(unity::shell::application::MirSurfaceInterface *surface) override;
+
+private Q_SLOTS:
+    void onWindowAdded(const qtmir::NewWindow &windowInfo);
+    void onWindowRemoved(const miral::WindowInfo &windowInfo);
+    void onWindowReady(const miral::WindowInfo &windowInfo);
+    void onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft);
+    void onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state);
+    void onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused);
+    void onWindowsRaised(const std::vector<miral::Window> &windows);
+
+private:
+    void connectToWindowModelNotifier(WindowModelNotifier *notifier);
+    void rememberMirSurface(MirSurface *surface);
+    void forgetMirSurface(const miral::Window &window);
+    MirSurface* find(const miral::WindowInfo &needle) const;
+    MirSurface* find(const miral::Window &needle) const;
+
+    QVector<MirSurface*> m_allSurfaces;
+
+    WindowControllerInterface *m_windowController;
+    SessionManager* m_sessionManager;
+};
+
+} // namespace qtmir
+
+#endif // QTMIR_SURFACEMANAGER_H

=== removed file 'src/modules/Unity/Application/toplevelwindowmodel.cpp'
--- src/modules/Unity/Application/toplevelwindowmodel.cpp	2016-11-09 14:18:17 +0000
+++ src/modules/Unity/Application/toplevelwindowmodel.cpp	1970-01-01 00:00:00 +0000
@@ -1,691 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "toplevelwindowmodel.h"
-
-#include "application.h"
-#include "application_manager.h"
-#include "mirsurface.h"
-#include "sessionmanager.h"
-
-// mirserver
-#include "nativeinterface.h"
-
-// Qt
-#include <QGuiApplication>
-#include <QDebug>
-
-Q_LOGGING_CATEGORY(QTMIR_TOPLEVELWINDOWMODEL, "qtmir.toplevelwindowmodel", QtDebugMsg)
-
-#define DEBUG_MSG qCDebug(QTMIR_TOPLEVELWINDOWMODEL).nospace().noquote() << __func__
-
-using namespace qtmir;
-namespace unityapi = unity::shell::application;
-
-TopLevelWindowModel::TopLevelWindowModel()
-{
-    auto nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
-
-    if (!nativeInterface) {
-        qFatal("ERROR: Unity.Application QML plugin requires use of the 'mirserver' QPA plugin");
-    }
-
-    m_windowController = static_cast<WindowControllerInterface*>(nativeInterface->nativeResourceForIntegration("WindowController"));
-
-    auto windowModel = static_cast<WindowModelNotifier*>(nativeInterface->nativeResourceForIntegration("WindowModelNotifier"));
-    connectToWindowModelNotifier(windowModel);
-
-    setApplicationManager(ApplicationManager::singleton());
-
-    m_sessionManager = SessionManager::singleton();
-}
-
-TopLevelWindowModel::TopLevelWindowModel(WindowModelNotifier *notifier,
-                         WindowControllerInterface *controller)
-    : m_windowController(controller)
-{
-    connectToWindowModelNotifier(notifier);
-}
-
-void TopLevelWindowModel::setApplicationManager(ApplicationManagerInterface* value)
-{
-    if (m_applicationManager == value) {
-        return;
-    }
-
-    Q_ASSERT(m_modelState == IdleState);
-    m_modelState = ResettingState;
-
-    beginResetModel();
-
-    if (m_applicationManager) {
-        m_windowModel.clear();
-        disconnect(m_applicationManager, 0, this, 0);
-    }
-
-    m_applicationManager = value;
-
-    if (m_applicationManager) {
-        connect(m_applicationManager, &QAbstractItemModel::rowsInserted,
-                this, [this](const QModelIndex &/*parent*/, int first, int last) {
-                    for (int i = first; i <= last; ++i) {
-                        auto application = m_applicationManager->get(i);
-                        addApplication(static_cast<Application*>(application));
-                    }
-                });
-
-        connect(m_applicationManager, &QAbstractItemModel::rowsAboutToBeRemoved,
-                this, [this](const QModelIndex &/*parent*/, int first, int last) {
-                    for (int i = first; i <= last; ++i) {
-                        auto application = m_applicationManager->get(i);
-                        removeApplication(static_cast<Application*>(application));
-                    }
-                });
-
-        for (int i = 0; i < m_applicationManager->rowCount(); ++i) {
-            auto application = m_applicationManager->get(i);
-            addApplication(static_cast<Application*>(application));
-        }
-    }
-
-    endResetModel();
-    m_modelState = IdleState;
-}
-
-void TopLevelWindowModel::addApplication(Application *application)
-{
-    DEBUG_MSG << "(" << application->appId() << ")";
-
-    if (application->state() != unityapi::ApplicationInfoInterface::Stopped && application->surfaceList()->count() == 0) {
-        prependPlaceholder(application);
-    }
-}
-
-void TopLevelWindowModel::removeApplication(Application *application)
-{
-    DEBUG_MSG << "(" << application->appId() << ")";
-
-    Q_ASSERT(m_modelState == IdleState);
-
-    int i = 0;
-    while (i < m_windowModel.count()) {
-        if (m_windowModel.at(i).application == application) {
-            removeAt(i);
-        } else {
-            ++i;
-        }
-    }
-}
-
-void TopLevelWindowModel::prependPlaceholder(Application *application)
-{
-    DEBUG_MSG << "(" << application->appId() << ")";
-
-    prependSurfaceHelper(nullptr, application);
-}
-
-void TopLevelWindowModel::prependSurface(MirSurface *surface, Application *application)
-{
-    Q_ASSERT(surface != nullptr);
-
-    bool filledPlaceholder = false;
-    for (int i = 0; i < m_windowModel.count() && !filledPlaceholder; ++i) {
-        ModelEntry &entry = m_windowModel[i];
-        if (entry.application == application && entry.window->surface() == nullptr) {
-            entry.window->setSurface(surface);
-            connectSurface(surface);
-            DEBUG_MSG << " appId=" << application->appId() << " surface=" << surface
-                      << ", filling out placeholder. after: " << toString();
-            filledPlaceholder = true;
-        }
-    }
-
-    if (!filledPlaceholder) {
-        DEBUG_MSG << " appId=" << application->appId() << " surface=" << surface << ", adding new row";
-        prependSurfaceHelper(surface, application);
-    }
-}
-
-void TopLevelWindowModel::prependSurfaceHelper(MirSurface *surface, Application *application)
-{
-    if (m_modelState == IdleState) {
-        m_modelState = InsertingState;
-        beginInsertRows(QModelIndex(), 0 /*first*/, 0 /*last*/);
-    } else {
-        Q_ASSERT(m_modelState == ResettingState);
-        // No point in signaling anything if we're resetting the whole model
-    }
-
-    int id = generateId();
-    Window *window = new Window(id);
-    if (surface) {
-        window->setSurface(surface);
-    }
-    m_windowModel.prepend(ModelEntry(window, application));
-    if (surface) {
-        connectSurface(surface);
-    }
-
-    connectWindow(window);
-
-    if (m_modelState == InsertingState) {
-        endInsertRows();
-        Q_EMIT countChanged();
-        Q_EMIT listChanged();
-        m_modelState = IdleState;
-    }
-
-    if (!surface) {
-        // focus the newly added window. miral can't help with that as it doesn't know about it.
-        window->setFocused(true);
-        if (m_focusedWindow && m_focusedWindow->surface()) {
-            m_windowController->activate(miral::Window());
-        }
-    }
-
-    DEBUG_MSG << " after " << toString();
-}
-
-void TopLevelWindowModel::connectWindow(Window *window)
-{
-    connect(window, &unityapi::WindowInterface::focusRequested, this, [this, window]() {
-        if (!window->surface()) {
-            // miral doesn't know about this window, so we have to do it ourselves
-            window->setFocused(true);
-            raiseId(window->id());
-            Window *previousWindow = m_focusedWindow;
-            setFocusedWindow(window);
-            if (previousWindow && previousWindow->surface() && previousWindow->surface()->focused()) {
-                m_windowController->activate(miral::Window());
-            }
-        }
-    });
-
-    connect(window, &unityapi::WindowInterface::focusedChanged, this, [this, window](bool focused) {
-        if (window->surface()) {
-            // Condense changes to the focused window
-            // eg: Do focusedWindow=A to focusedWindow=B instead of
-            // focusedWindow=A to focusedWindow=null to focusedWindow=B
-            m_focusedWindowChanged = true;
-            if (focused) {
-                Q_ASSERT(m_newlyFocusedWindow == nullptr);
-                m_newlyFocusedWindow = window;
-            }
-        }
-    });
-
-    connect(window, &Window::closeRequested, this, [this, window]() {
-        if (!window->surface()) {
-            int index = indexForId(window->id());
-            Q_ASSERT(index >= 0);
-            m_windowModel[index].application->close();
-        }
-    });
-}
-
-void TopLevelWindowModel::connectSurface(MirSurfaceInterface *surface)
-{
-    connect(surface, &MirSurfaceInterface::liveChanged, this, [this, surface](bool live){
-            if (!live) {
-                onSurfaceDied(surface);
-            }
-        });
-    connect(surface, &QObject::destroyed, this, [this, surface](){ this->onSurfaceDestroyed(surface); });
-}
-
-void TopLevelWindowModel::onSurfaceDied(MirSurfaceInterface *surface)
-{
-    int i = indexOf(surface);
-    if (i == -1) {
-        return;
-    }
-
-    auto application = m_windowModel[i].application;
-
-    // can't be starting if it already has a surface
-    Q_ASSERT(application->state() != unityapi::ApplicationInfoInterface::Starting);
-
-    if (application->state() == unityapi::ApplicationInfoInterface::Running) {
-        m_windowModel[i].removeOnceSurfaceDestroyed = true;
-    } else {
-        // assume it got killed by the out-of-memory daemon.
-        //
-        // So leave entry in the model and only remove its surface, so shell can display a screenshot
-        // in its place.
-        m_windowModel[i].removeOnceSurfaceDestroyed = false;
-    }
-}
-
-void TopLevelWindowModel::onSurfaceDestroyed(MirSurfaceInterface *surface)
-{
-    int i = indexOf(surface);
-    if (i == -1) {
-        return;
-    }
-
-    if (m_windowModel[i].removeOnceSurfaceDestroyed) {
-        removeAt(i);
-    } else {
-        auto window = m_windowModel[i].window;
-        window->setSurface(nullptr);
-        window->setFocused(false);
-        DEBUG_MSG << " Removed surface from entry. After: " << toString();
-    }
-}
-
-void TopLevelWindowModel::connectToWindowModelNotifier(WindowModelNotifier *notifier)
-{
-    connect(notifier, &WindowModelNotifier::windowAdded,        this, &TopLevelWindowModel::onWindowAdded,        Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowRemoved,      this, &TopLevelWindowModel::onWindowRemoved,      Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowReady,        this, &TopLevelWindowModel::onWindowReady,        Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowMoved,        this, &TopLevelWindowModel::onWindowMoved,        Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowStateChanged, this, &TopLevelWindowModel::onWindowStateChanged, Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowFocusChanged, this, &TopLevelWindowModel::onWindowFocusChanged, Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowsRaised,      this, &TopLevelWindowModel::onWindowsRaised,      Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::modificationsStarted, this, &TopLevelWindowModel::onModificationsStarted, Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::modificationsEnded, this, &TopLevelWindowModel::onModificationsEnded, Qt::QueuedConnection);
-}
-
-void TopLevelWindowModel::onWindowAdded(const NewWindow &window)
-{
-    auto mirSession = window.windowInfo.window().application();
-    SessionInterface* session = m_sessionManager->findSession(mirSession.get());
-
-    auto surface = new MirSurface(window, m_windowController, session);
-    rememberMirSurface(surface);
-
-    if (session)
-        session->registerSurface(surface);
-
-    if (window.windowInfo.type() == mir_surface_type_inputmethod) {
-        int id = generateId();
-        Window *qmlWindow = new Window(id);
-        connectWindow(qmlWindow);
-        qmlWindow->setSurface(surface);
-        setInputMethodWindow(qmlWindow);
-    } else {
-        Application *application = m_applicationManager->findApplicationWithSession(mirSession);
-        if (application) {
-            prependSurface(surface, application);
-        } else {
-            // Must be a prompt session. No need to do anything about it here as a prompt surface is not top-level.
-            // It will show up in the qtmir::Application::promptSurfaceList of some application.
-        }
-    }
-    // TODO: handle surfaces that are neither top-level windows nor input method. eg: child dialogs, popups, menus
-}
-
-void TopLevelWindowModel::onWindowRemoved(const miral::WindowInfo &windowInfo)
-{
-    forgetMirSurface(windowInfo.window());
-
-    if (windowInfo.type() == mir_surface_type_inputmethod) {
-        removeInputMethodWindow();
-        return;
-    }
-
-    const int index = findIndexOf(windowInfo.window());
-    if (index >= 0) {
-        auto surface = static_cast<MirSurface*>(m_windowModel[index].window->surface());
-        surface->setLive(false);
-    }
-}
-
-void TopLevelWindowModel::rememberMirSurface(MirSurface *surface)
-{
-    m_allSurfaces.append(surface);
-}
-
-void TopLevelWindowModel::forgetMirSurface(const miral::Window &window)
-{
-    for (int i = 0; i < m_allSurfaces.count(); ++i) {
-        if (m_allSurfaces[i]->window() == window) {
-            m_allSurfaces.removeAt(i);
-            return;
-        }
-    }
-}
-
-void TopLevelWindowModel::removeAt(int index)
-{
-    if (m_modelState == IdleState) {
-        beginRemoveRows(QModelIndex(), index, index);
-        m_modelState = RemovingState;
-    } else {
-        Q_ASSERT(m_modelState == ResettingState);
-        // No point in signaling anything if we're resetting the whole model
-    }
-
-    auto window = m_windowModel[index].window;
-
-    window->setSurface(nullptr);
-    window->setFocused(false);
-
-    m_windowModel.removeAt(index);
-
-    if (m_modelState == RemovingState) {
-        endRemoveRows();
-        Q_EMIT countChanged();
-        Q_EMIT listChanged();
-        m_modelState = IdleState;
-    }
-
-    disconnect(window, 0, this, 0);
-    if (m_focusedWindow == window) {
-        setFocusedWindow(nullptr);
-    }
-    delete window;
-
-    DEBUG_MSG << " after " << toString();
-}
-
-void TopLevelWindowModel::onWindowReady(const miral::WindowInfo &windowInfo)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->setReady();
-    }
-}
-
-void TopLevelWindowModel::onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->setPosition(topLeft);
-    }
-}
-
-void TopLevelWindowModel::onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->setFocused(focused);
-    }
-}
-
-void TopLevelWindowModel::onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->updateState(state);
-    }
-}
-
-void TopLevelWindowModel::setInputMethodWindow(Window *window)
-{
-    if (m_inputMethodWindow) {
-        qWarning("Multiple Input Method Surfaces created, removing the old one!");
-        delete m_inputMethodWindow;
-    }
-    m_inputMethodWindow = window;
-    Q_EMIT inputMethodSurfaceChanged(m_inputMethodWindow->surface());
-}
-
-void TopLevelWindowModel::removeInputMethodWindow()
-{
-    if (m_inputMethodWindow) {
-        delete m_inputMethodWindow;
-        m_inputMethodWindow = nullptr;
-        Q_EMIT inputMethodSurfaceChanged(nullptr);
-    }
-}
-
-void TopLevelWindowModel::onWindowsRaised(const std::vector<miral::Window> &windows)
-{
-    const int raiseCount = windows.size();
-    for (int i = 0; i < raiseCount; i++) {
-        int fromIndex = findIndexOf(windows[i]);
-        if (fromIndex != -1) {
-            move(fromIndex, 0);
-        }
-    }
-}
-
-int TopLevelWindowModel::rowCount(const QModelIndex &/*parent*/) const
-{
-    return m_windowModel.count();
-}
-
-QVariant TopLevelWindowModel::data(const QModelIndex& index, int role) const
-{
-    if (index.row() < 0 || index.row() >= m_windowModel.size())
-        return QVariant();
-
-    if (role == WindowRole) {
-        unityapi::WindowInterface *window = m_windowModel.at(index.row()).window;
-        return QVariant::fromValue(window);
-    } else if (role == ApplicationRole) {
-        return QVariant::fromValue(m_windowModel.at(index.row()).application);
-    } else {
-        return QVariant();
-    }
-}
-
-MirSurface *TopLevelWindowModel::find(const miral::WindowInfo &needle) const
-{
-    auto window = needle.window();
-    Q_FOREACH(const auto surface, m_allSurfaces) {
-        if (surface->window() == window) {
-            return surface;
-        }
-    }
-    return nullptr;
-}
-
-int TopLevelWindowModel::findIndexOf(const miral::Window &needle) const
-{
-    for (int i=0; i<m_windowModel.count(); i++) {
-        auto surface = static_cast<MirSurface*>(m_windowModel[i].window->surface());
-        if (surface && surface->window() == needle) {
-            return i;
-        }
-    }
-    return -1;
-}
-
-int TopLevelWindowModel::generateId()
-{
-    int id = m_nextId;
-    m_nextId = nextFreeId(m_nextId + 1);
-    return id;
-}
-
-int TopLevelWindowModel::nextFreeId(int candidateId)
-{
-    if (candidateId > m_maxId) {
-        return nextFreeId(1);
-    } else {
-        if (indexForId(candidateId) == -1) {
-            // it's indeed free
-            return candidateId;
-        } else {
-            return nextFreeId(candidateId + 1);
-        }
-    }
-}
-
-QString TopLevelWindowModel::toString()
-{
-    QString str;
-    for (int i = 0; i < m_windowModel.count(); ++i) {
-        auto item = m_windowModel.at(i);
-
-        QString itemStr = QString("(index=%1,appId=%2,surface=0x%3,id=%4)")
-            .arg(i)
-            .arg(item.application->appId())
-            .arg((qintptr)item.window->surface(), 0, 16)
-            .arg(item.window->id());
-
-        if (i > 0) {
-            str.append(",");
-        }
-        str.append(itemStr);
-    }
-    return str;
-}
-
-int TopLevelWindowModel::indexOf(MirSurfaceInterface *surface)
-{
-    for (int i = 0; i < m_windowModel.count(); ++i) {
-        if (m_windowModel.at(i).window->surface() == surface) {
-            return i;
-        }
-    }
-    return -1;
-}
-
-int TopLevelWindowModel::indexForId(int id) const
-{
-    for (int i = 0; i < m_windowModel.count(); ++i) {
-        if (m_windowModel[i].window->id() == id) {
-            return i;
-        }
-    }
-    return -1;
-}
-
-unityapi::WindowInterface *TopLevelWindowModel::windowAt(int index) const
-{
-    if (index >=0 && index < m_windowModel.count()) {
-        return m_windowModel[index].window;
-    } else {
-        return nullptr;
-    }
-}
-
-unityapi::MirSurfaceInterface *TopLevelWindowModel::surfaceAt(int index) const
-{
-    if (index >=0 && index < m_windowModel.count()) {
-        return m_windowModel[index].window->surface();
-    } else {
-        return nullptr;
-    }
-}
-
-unityapi::ApplicationInfoInterface *TopLevelWindowModel::applicationAt(int index) const
-{
-    if (index >=0 && index < m_windowModel.count()) {
-        return m_windowModel[index].application;
-    } else {
-        return nullptr;
-    }
-}
-
-int TopLevelWindowModel::idAt(int index) const
-{
-    if (index >=0 && index < m_windowModel.count()) {
-        return m_windowModel[index].window->id();
-    } else {
-        return 0;
-    }
-}
-
-void TopLevelWindowModel::raiseId(int id)
-{
-    if (m_modelState == IdleState) {
-        DEBUG_MSG << "(id=" << id << ") - do it now.";
-        doRaiseId(id);
-    } else {
-        DEBUG_MSG << "(id=" << id << ") - Model busy (modelState=" << m_modelState << "). Try again in the next event loop.";
-        // The model has just signalled some change. If we have a Repeater responding to this update, it will get nuts
-        // if we perform yet another model change straight away.
-        //
-        // A bad sympton of this problem is a Repeater.itemAt(index) call returning null event though Repeater.count says
-        // the index is definitely within bounds.
-        QMetaObject::invokeMethod(this, "raiseId", Qt::QueuedConnection, Q_ARG(int, id));
-    }
-}
-
-void TopLevelWindowModel::doRaiseId(int id)
-{
-    int fromIndex = indexForId(id);
-    if (fromIndex != -1) {
-        auto surface = static_cast<MirSurface*>(m_windowModel[fromIndex].window->surface());
-        if (surface) {
-            m_windowController->raise(surface->window());
-        } else {
-            // move it ourselves. Since there's no mir::scene::Surface/miral::Window, there's nothing
-            // miral can do about it.
-            move(fromIndex, 0);
-        }
-    }
-}
-
-void TopLevelWindowModel::setFocusedWindow(Window *window)
-{
-    if (window != m_focusedWindow) {
-        DEBUG_MSG << "(" << window << ")";
-
-        Window* previousWindow = m_focusedWindow;
-
-        m_focusedWindow = window;
-        Q_EMIT focusedWindowChanged(m_focusedWindow);
-
-        if (previousWindow && previousWindow->focused() && !previousWindow->surface()) {
-            // do it ourselves. miral doesn't know about this window
-            previousWindow->setFocused(false);
-        }
-    }
-}
-
-unityapi::MirSurfaceInterface* TopLevelWindowModel::inputMethodSurface() const
-{
-    return m_inputMethodWindow ? m_inputMethodWindow->surface() : nullptr;
-}
-
-unityapi::WindowInterface* TopLevelWindowModel::focusedWindow() const
-{
-    return m_focusedWindow;
-}
-
-void TopLevelWindowModel::move(int from, int to)
-{
-    if (from == to) return;
-    DEBUG_MSG << " from=" << from << " to=" << to;
-
-    if (from >= 0 && from < m_windowModel.size() && to >= 0 && to < m_windowModel.size()) {
-        QModelIndex parent;
-        /* When moving an item down, the destination index needs to be incremented
-           by one, as explained in the documentation:
-           http://qt-project.org/doc/qt-5.0/qtcore/qabstractitemmodel.html#beginMoveRows */
-
-        Q_ASSERT(m_modelState == IdleState);
-        m_modelState = MovingState;
-
-        beginMoveRows(parent, from, from, parent, to + (to > from ? 1 : 0));
-#if QT_VERSION < QT_VERSION_CHECK(5, 6, 0)
-        const auto &window = m_windowModel.takeAt(from);
-        m_windowModel.insert(to, window);
-#else
-        m_windowModel.move(from, to);
-#endif
-        endMoveRows();
-
-        Q_EMIT listChanged();
-        m_modelState = IdleState;
-
-        DEBUG_MSG << " after " << toString();
-    }
-}
-void TopLevelWindowModel::onModificationsStarted()
-{
-}
-
-void TopLevelWindowModel::onModificationsEnded()
-{
-    if (m_focusedWindowChanged) {
-        setFocusedWindow(m_newlyFocusedWindow);
-    }
-    // reset
-    m_focusedWindowChanged = false;
-    m_newlyFocusedWindow = nullptr;
-}

=== removed file 'src/modules/Unity/Application/toplevelwindowmodel.h'
--- src/modules/Unity/Application/toplevelwindowmodel.h	2016-11-04 11:06:15 +0000
+++ src/modules/Unity/Application/toplevelwindowmodel.h	1970-01-01 00:00:00 +0000
@@ -1,161 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TOPLEVELWINDOWMODEL_H
-#define TOPLEVELWINDOWMODEL_H
-
-#include <QLoggingCategory>
-
-#include "mirsurface.h"
-#include "window.h"
-#include "windowmodelnotifier.h"
-
-// Unity API
-#include <unity/shell/application/TopLevelWindowModelInterface.h>
-
-Q_DECLARE_LOGGING_CATEGORY(QTMIR_TOPLEVELWINDOWMODEL)
-
-namespace unity {
-    namespace shell {
-        namespace application {
-            class ApplicationInfoInterface;
-            class ApplicationManagerInterface;
-            class MirSurfaceInterface;
-        }
-    }
-}
-
-namespace qtmir {
-
-class Application;
-class ApplicationManagerInterface;
-class SessionManager;
-class WindowControllerInterface;
-
-class TopLevelWindowModel : public unity::shell::application::TopLevelWindowModelInterface
-{
-    Q_OBJECT
-
-public:
-    TopLevelWindowModel();
-    explicit TopLevelWindowModel(WindowModelNotifier *notifier,
-                         WindowControllerInterface *controller); // For testing
-
-    // From unity::shell::application::TopLevelWindowModelInterface
-    unity::shell::application::MirSurfaceInterface* inputMethodSurface() const override;
-    unity::shell::application::WindowInterface* focusedWindow() const override;
-
-    // From QAbstractItemModel
-    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
-    QVariant data(const QModelIndex& index, int role) const override;
-
-    // Own API
-    void setApplicationManager(ApplicationManagerInterface*);
-
-public Q_SLOTS:
-    // From unity::shell::application::TopLevelWindowModelInterface
-    unity::shell::application::MirSurfaceInterface *surfaceAt(int index) const override;
-    unity::shell::application::WindowInterface *windowAt(int index) const override;
-    unity::shell::application::ApplicationInfoInterface *applicationAt(int index) const override;
-    int idAt(int index) const override;
-    int indexForId(int id) const override;
-    void raiseId(int id) override;
-
-private Q_SLOTS:
-    void onWindowAdded(const qtmir::NewWindow &windowInfo);
-    void onWindowRemoved(const miral::WindowInfo &windowInfo);
-    void onWindowReady(const miral::WindowInfo &windowInfo);
-    void onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft);
-    void onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state);
-    void onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused);
-    void onWindowsRaised(const std::vector<miral::Window> &windows);
-    void onModificationsStarted();
-    void onModificationsEnded();
-
-private:
-    void doRaiseId(int id);
-    int generateId();
-    int nextFreeId(int candidateId);
-    void connectToWindowModelNotifier(WindowModelNotifier *notifier);
-    QString toString();
-    int indexOf(MirSurfaceInterface *surface);
-
-    void setInputMethodWindow(Window *window);
-    void setFocusedWindow(Window *window);
-    void removeInputMethodWindow();
-    MirSurface* find(const miral::WindowInfo &needle) const;
-    int findIndexOf(const miral::Window &needle) const;
-    void removeAt(int index);
-
-    void addApplication(Application *application);
-    void removeApplication(Application *application);
-
-    void prependPlaceholder(Application *application);
-    void prependSurface(MirSurface *surface, Application *application);
-    void prependSurfaceHelper(MirSurface *surface, Application *application);
-
-    void connectWindow(Window *window);
-    void connectSurface(MirSurfaceInterface *surface);
-
-    void onSurfaceDied(MirSurfaceInterface *surface);
-    void onSurfaceDestroyed(MirSurfaceInterface *surface);
-
-    void move(int from, int to);
-
-    void rememberMirSurface(MirSurface *surface);
-    void forgetMirSurface(const miral::Window &window);
-
-    struct ModelEntry {
-        ModelEntry() {}
-        ModelEntry(Window *window,
-                   Application *application)
-            : window(window), application(application) {}
-        Window *window{nullptr};
-        Application *application{nullptr};
-        bool removeOnceSurfaceDestroyed{false};
-    };
-
-    QVector<ModelEntry> m_windowModel;
-    WindowControllerInterface *m_windowController;
-    SessionManager* m_sessionManager;
-    Window* m_inputMethodWindow{nullptr};
-    Window* m_focusedWindow{nullptr};
-    QVector<MirSurface*> m_allSurfaces;
-
-    int m_nextId{1};
-    // Just something big enough that we don't risk running out of unused id numbers.
-    // Not sure if QML int type supports something close to std::numeric_limits<int>::max() and
-    // there's no reason to try out its limits.
-    static const int m_maxId{1000000};
-
-    ApplicationManagerInterface* m_applicationManager{nullptr};
-
-    enum ModelState {
-        IdleState,
-        InsertingState,
-        RemovingState,
-        MovingState,
-        ResettingState
-    };
-    ModelState m_modelState{IdleState};
-
-    // Valid between modificationsStarted and modificationsEnded
-    bool m_focusedWindowChanged{false};
-    Window *m_newlyFocusedWindow{nullptr};
-};
-
-} // namespace qtmir
-#endif // TOPLEVELWINDOWMODEL_H

=== removed file 'src/modules/Unity/Application/window.cpp'
--- src/modules/Unity/Application/window.cpp	2016-11-07 11:44:55 +0000
+++ src/modules/Unity/Application/window.cpp	1970-01-01 00:00:00 +0000
@@ -1,186 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * 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; version 3.
- *
- * 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include "window.h"
-#include "mirsurface.h"
-
-#include <QQmlEngine>
-
-namespace unityapi = unity::shell::application;
-using namespace qtmir;
-
-Window::Window(int id)
-    : WindowInterface(nullptr)
-    , m_id(id)
-{
-    QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);
-}
-
-QPoint Window::position() const
-{
-    return m_position;
-}
-
-QPoint Window::requestedPosition() const
-{
-    return m_requestedPosition;
-}
-
-void Window::setRequestedPosition(const QPoint &value)
-{
-    if (value != m_requestedPosition) {
-        m_requestedPosition = value;
-        Q_EMIT requestedPositionChanged(m_requestedPosition);
-        if (m_surface) {
-            m_surface->setRequestedPosition(value);
-        } else {
-            // fake-miral: always comply
-            m_position = m_requestedPosition;
-            Q_EMIT positionChanged(m_position);
-        }
-    }
-}
-
-Mir::State Window::state() const
-{
-    return m_state;
-}
-
-bool Window::focused() const
-{
-    return m_focused;
-}
-
-bool Window::confinesMousePointer() const
-{
-    if (m_surface) {
-        return m_surface->confinesMousePointer();
-    } else {
-        return false;
-    }
-}
-
-int Window::id() const
-{
-    return m_id;
-}
-
-unityapi::MirSurfaceInterface* Window::surface() const
-{
-    return m_surface;
-}
-
-void Window::requestState(Mir::State state)
-{
-    if (m_surface) {
-        m_surface->requestState(state);
-    } else if (m_state != state) {
-        m_state = state;
-        Q_EMIT stateChanged(m_state);
-    }
-}
-
-void Window::requestFocus()
-{
-    if (m_surface) {
-        m_surface->requestFocus();
-    } else {
-        Q_EMIT focusRequested();
-    }
-}
-
-void Window::close()
-{
-    if (m_surface) {
-        m_surface->close();
-    } else {
-        Q_EMIT closeRequested();
-    }
-}
-
-void Window::setSurface(MirSurface *surface)
-{
-    if (m_surface) {
-        disconnect(m_surface, 0, this, 0);
-    }
-
-    m_surface = surface;
-
-    if (m_surface) {
-        connect(surface, &MirSurfaceInterface::focusRequested, this, [this]() {
-            Q_EMIT focusRequested();
-        });
-
-        connect(surface, &MirSurfaceInterface::closeRequested, this, &Window::closeRequested);
-
-        connect(surface, &MirSurfaceInterface::positionChanged, this, [this]() {
-            updatePosition();
-        });
-
-        connect(surface, &MirSurfaceInterface::stateChanged, this, [this]() {
-            updateState();
-        });
-
-        connect(surface, &MirSurfaceInterface::focusedChanged, this, [this]() {
-            updateFocused();
-        });
-
-        // bring it up to speed
-        m_surface->setRequestedPosition(m_requestedPosition);
-        m_surface->requestState(m_state);
-
-        // and sync with surface
-        updatePosition();
-        updateState();
-        updateFocused();
-    }
-
-    Q_EMIT surfaceChanged(surface);
-}
-
-void Window::updatePosition()
-{
-    if (m_surface->position() != m_position) {
-        m_position = m_surface->position();
-        Q_EMIT positionChanged(m_position);
-    }
-}
-
-void Window::updateState()
-{
-    if (m_surface->state() != m_state) {
-        m_state = m_surface->state();
-        Q_EMIT stateChanged(m_state);
-    }
-}
-
-void Window::updateFocused()
-{
-    if (m_surface->focused() != m_focused) {
-        m_focused = m_surface->focused();
-        Q_EMIT focusedChanged(m_focused);
-    }
-}
-
-void Window::setFocused(bool value)
-{
-    if (value != m_focused) {
-        m_focused = value;
-        Q_EMIT focusedChanged(m_focused);
-        // when we have a surface we get focus changes from updateFocused() instead
-        Q_ASSERT(!m_surface);
-    }
-}

=== removed file 'src/modules/Unity/Application/window.h'
--- src/modules/Unity/Application/window.h	2016-11-03 20:17:46 +0000
+++ src/modules/Unity/Application/window.h	1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * 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; version 3.
- *
- * 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, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef QTMIR_WINDOW_H
-#define QTMIR_WINDOW_H
-
-// unity-api
-#include <unity/shell/application/WindowInterface.h>
-
-namespace qtmir {
-
-class MirSurface;
-
-class Window : public unity::shell::application::WindowInterface
-{
-    Q_OBJECT
-
-public:
-    Window(int id);
-    QPoint position() const override;
-    QPoint requestedPosition() const override;
-    void setRequestedPosition(const QPoint &) override;
-    Mir::State state() const override;
-    bool focused() const override;
-    bool confinesMousePointer() const override;
-    int id() const override;
-    unity::shell::application::MirSurfaceInterface* surface() const override;
-
-    void setSurface(MirSurface *surface);
-    void setFocused(bool value);
-
-public Q_SLOTS:
-    void requestState(Mir::State state) override;
-    void requestFocus() override;
-    void close() override;
-
-Q_SIGNALS:
-    void closeRequested();
-
-private:
-    void updatePosition();
-    void updateState();
-    void updateFocused();
-
-    QPoint m_position;
-    QPoint m_requestedPosition;
-    bool m_focused{false};
-    int m_id;
-    Mir::State m_state{Mir::RestoredState};
-    MirSurface *m_surface{nullptr};
-};
-
-} // namespace qtmir {
-#endif // QTMIR_WINDOW_H