Merge lp:~dandrader/miral/moveStuffToUnityApi into lp:miral

[Daniel d'Andrada]

[miral-qt] Move stuff to unity-api

+ bunch of other improvements and fixes

Works with lp:~dandrader/unity8/miral

Needs lp:~dandrader/unity-api/miral

[lp:~dandrader/miral/moveStuffToUnityApi]

426. By Daniel d'Andrada on 2016-11-01

[miral-qt] Move stuff to unity-api

+ bunch of other improvements and fixes

[Alan Griffiths (alan-griffiths)]

+// Code below crashes with things like move(from=-1, to=0) when there's only one item in the list
+#if 0
...
+#endif

Why are we keeping it?

[Gerry Boland (gerboland)]

+// Code below crashes with things like move(from=-1, to=0) when there's only one item in the list
+#if 0

if the simpler code works, why keep this?

[Gerry Boland (gerboland)]

Rest looks reasonable

review: Approve

[lp:~dandrader/miral/moveStuffToUnityApi]

427. By Daniel d'Andrada on 2016-11-03

Remove commented-out code

[Daniel d'Andrada (dandrader)]

Removed the commented-out code.

[Gerry Boland (gerboland)]

Ok

review: Approve

=== modified file 'miral-qt/CMakeLists.txt'
--- miral-qt/CMakeLists.txt	2016-10-26 14:03:04 +0000
+++ miral-qt/CMakeLists.txt	2016-11-03 12:11:13 +0000
@@ -93,7 +93,7 @@
 pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
 pkg_check_modules(QTDBUSTEST libqtdbustest-1 REQUIRED)
 pkg_check_modules(QTDBUSMOCK libqtdbusmock-1 REQUIRED)
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=22)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=23)
 pkg_check_modules(CGMANAGER libcgmanager REQUIRED)
 pkg_check_modules(CONTENT_HUB libcontent-hub>=0.2 REQUIRED)
 

=== modified file 'miral-qt/debian/control'
--- miral-qt/debian/control	2016-09-23 15:56:53 +0000
+++ miral-qt/debian/control	2016-11-03 12:11:13 +0000
@@ -24,7 +24,7 @@
                libubuntu-app-launch2-dev (>= 0.9),
                libubuntu-application-api-dev (>= 2.1.0),
                libudev-dev,
-               libunity-api-dev (>= 7.119),
+               libunity-api-dev (>= 7.120),
                liburl-dispatcher1-dev,
                libxkbcommon-dev,
                libxrender-dev,
@@ -98,7 +98,7 @@
 Conflicts: libqtmir,
            libunity-mir1,
 Provides: unity-application-impl,
-          unity-application-impl-22,
+          unity-application-impl-23,
 Description: Qt plugin for Unity specific Mir APIs
  QtMir provides Qt/QML bindings for Mir features that are exposed through the
  qtmir-desktop or qtmir-android QPA plugin such as Application management

=== modified file 'miral-qt/debian/gles-patches/convert-to-gles.patch'
--- miral-qt/debian/gles-patches/convert-to-gles.patch	2016-09-23 15:56:53 +0000
+++ miral-qt/debian/gles-patches/convert-to-gles.patch	2016-11-03 12:11:13 +0000
@@ -84,7 +84,7 @@
 -Conflicts: libqtmir,
 -           libunity-mir1,
 -Provides: unity-application-impl,
--          unity-application-impl-22,
+-          unity-application-impl-23,
 -Description: Qt plugin for Unity specific Mir APIs
 - QtMir provides Qt/QML bindings for Mir features that are exposed through the
 - qtmir-desktop or qtmir-android QPA plugin such as Application management

=== modified file 'miral-qt/src/common/debughelpers.cpp'
--- miral-qt/src/common/debughelpers.cpp	2016-10-06 11:04:44 +0000
+++ miral-qt/src/common/debughelpers.cpp	2016-11-03 12:11:13 +0000
@@ -149,6 +149,8 @@
         return "vertmaximized";
     case mir_surface_state_fullscreen:
         return "fullscreen";
+    case mir_surface_state_hidden:
+        return "hidden";
     default:
         return "???";
     }

=== modified file 'miral-qt/src/common/windowmodelnotifier.h'
--- miral-qt/src/common/windowmodelnotifier.h	2016-10-06 20:56:04 +0000
+++ miral-qt/src/common/windowmodelnotifier.h	2016-11-03 12:11:13 +0000
@@ -77,6 +77,8 @@
     void windowStateChanged(const miral::WindowInfo &window, Mir::State state);
     void windowFocusChanged(const miral::WindowInfo &window, bool focused);
     void windowsRaised(const std::vector<miral::Window> &windows); // results in deep copy when passed over Queued connection:(
+    void modificationsStarted();
+    void modificationsEnded();
 
 private:
     Q_DISABLE_COPY(WindowModelNotifier)

=== modified file 'miral-qt/src/modules/Unity/Application/CMakeLists.txt'
--- miral-qt/src/modules/Unity/Application/CMakeLists.txt	2016-11-02 15:19:09 +0000
+++ miral-qt/src/modules/Unity/Application/CMakeLists.txt	2016-11-03 12:11:13 +0000
@@ -57,6 +57,7 @@
     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
@@ -65,6 +66,8 @@
     ${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
 # Feed the automoc monster
     session_interface.h
     applicationinfo.h

=== modified file 'miral-qt/src/modules/Unity/Application/mirsurface.h'
--- miral-qt/src/modules/Unity/Application/mirsurface.h	2016-11-02 15:36:49 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurface.h	2016-11-03 12:11:13 +0000
@@ -168,9 +168,13 @@
     std::shared_ptr<SurfaceObserver> surfaceObserver() const;
 
 public Q_SLOTS:
+    ////
+    // unity::shell::application::MirSurfaceInterface
     void requestState(Mir::State qmlState) override;
+
+    ////
+    // qtmir::MirSurfaceInterface
     void onCompositorSwappedBuffers() override;
-
     void setShellChrome(Mir::ShellChrome shellChrome) override;
 
 private Q_SLOTS:

=== modified file 'miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h'
--- miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h	2016-10-06 15:36:43 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h	2016-11-03 12:11:13 +0000
@@ -39,21 +39,10 @@
 {
     Q_OBJECT
 
-    /**
-     * @brief Position of the current surface buffer, in pixels.
-     */
-    // TODO: Move to unity::shell::application::MirSurfaceInterface
-    Q_PROPERTY(QPoint position READ position NOTIFY positionChanged)
-
-    // TODO: Move to unity::shell::application::MirSurfaceInterface
-    Q_PROPERTY(QPoint requestedPosition READ requestedPosition WRITE setRequestedPosition NOTIFY requestedPositionChanged)
-
 public:
     MirSurfaceInterface(QObject *parent = nullptr) : unity::shell::application::MirSurfaceInterface(parent) {}
     virtual ~MirSurfaceInterface() {}
 
-    virtual QPoint position() const = 0;
-
     virtual void setLive(bool value) = 0;
 
     virtual bool isReady() const = 0;
@@ -118,13 +107,7 @@
 
     virtual bool inputAreaContains(const QPoint &) const = 0;
 
-    // TODO: Move to unity::shell::application::MirSurfaceInterface
-    virtual QPoint requestedPosition() const = 0;
-    virtual void setRequestedPosition(const QPoint &) = 0;
-
 public Q_SLOTS:
-    virtual void requestState(Mir::State qmlState) = 0; // TODO: move to unity-api
-
     virtual void onCompositorSwappedBuffers() = 0;
 
     virtual void setShellChrome(Mir::ShellChrome shellChrome) = 0;
@@ -137,10 +120,6 @@
     void framesPosted();
     void isBeingDisplayedChanged();
     void frameDropped();
-    void positionChanged(QPoint position);
-
-    // TODO: Move to unity::shell::application::MirSurfaceInterface
-    void requestedPositionChanged(QPoint position);
 };
 
 } // namespace qtmir

=== modified file 'miral-qt/src/modules/Unity/Application/plugin.cpp'
--- miral-qt/src/modules/Unity/Application/plugin.cpp	2016-09-29 14:33:52 +0000
+++ miral-qt/src/modules/Unity/Application/plugin.cpp	2016-11-03 12:11:13 +0000
@@ -24,6 +24,7 @@
 #include "mirsurfaceitem.h"
 #include "mirsurfacelistmodel.h"
 #include "toplevelwindowmodel.h"
+#include "window.h"
 #include "windowmodel.h"
 
 // platforms/mirserver
@@ -65,6 +66,7 @@
         qRegisterMetaType<unity::shell::application::MirSurfaceInterface*>("MirSurfaceInterface*");
         qRegisterMetaType<unity::shell::application::MirSurfaceListInterface*>("unity::shell::application::MirSurfaceListInterface*");
         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");

=== modified file 'miral-qt/src/modules/Unity/Application/toplevelwindowmodel.cpp'
--- miral-qt/src/modules/Unity/Application/toplevelwindowmodel.cpp	2016-10-28 11:57:11 +0000
+++ miral-qt/src/modules/Unity/Application/toplevelwindowmodel.cpp	2016-11-03 12:11:13 +0000
@@ -16,6 +16,7 @@
 
 #include "toplevelwindowmodel.h"
 
+#include "application.h"
 #include "application_manager.h"
 #include "mirsurface.h"
 #include "sessionmanager.h"
@@ -27,9 +28,9 @@
 #include <QGuiApplication>
 #include <QDebug>
 
-Q_LOGGING_CATEGORY(QTMIR_WINDOWMODEL, "qtmir.windowmodel", QtDebugMsg)
+Q_LOGGING_CATEGORY(QTMIR_TOPLEVELWINDOWMODEL, "qtmir.toplevelwindowmodel", QtDebugMsg)
 
-#define DEBUG_MSG qCDebug(QTMIR_WINDOWMODEL).nospace().noquote() << __func__
+#define DEBUG_MSG qCDebug(QTMIR_TOPLEVELWINDOWMODEL).nospace().noquote() << __func__
 
 using namespace qtmir;
 namespace unityapi = unity::shell::application;
@@ -82,7 +83,7 @@
                 this, [this](const QModelIndex &/*parent*/, int first, int last) {
                     for (int i = first; i <= last; ++i) {
                         auto application = m_applicationManager->get(i);
-                        addApplication(application);
+                        addApplication(static_cast<Application*>(application));
                     }
                 });
 
@@ -90,13 +91,13 @@
                 this, [this](const QModelIndex &/*parent*/, int first, int last) {
                     for (int i = first; i <= last; ++i) {
                         auto application = m_applicationManager->get(i);
-                        removeApplication(application);
+                        removeApplication(static_cast<Application*>(application));
                     }
                 });
 
         for (int i = 0; i < m_applicationManager->rowCount(); ++i) {
             auto application = m_applicationManager->get(i);
-            addApplication(application);
+            addApplication(static_cast<Application*>(application));
         }
     }
 
@@ -104,16 +105,16 @@
     m_modelState = IdleState;
 }
 
-void TopLevelWindowModel::addApplication(unityapi::ApplicationInfoInterface *application)
+void TopLevelWindowModel::addApplication(Application *application)
 {
     DEBUG_MSG << "(" << application->appId() << ")";
 
     if (application->state() != unityapi::ApplicationInfoInterface::Stopped && application->surfaceList()->count() == 0) {
-        appendPlaceholder(application);
+        prependPlaceholder(application);
     }
 }
 
-void TopLevelWindowModel::removeApplication(unityapi::ApplicationInfoInterface *application)
+void TopLevelWindowModel::removeApplication(Application *application)
 {
     DEBUG_MSG << "(" << application->appId() << ")";
 
@@ -138,52 +139,57 @@
     DEBUG_MSG << " after " << toString();
 }
 
-void TopLevelWindowModel::appendPlaceholder(unityapi::ApplicationInfoInterface *application)
+void TopLevelWindowModel::prependPlaceholder(Application *application)
 {
     DEBUG_MSG << "(" << application->appId() << ")";
 
-    appendSurfaceHelper(nullptr, application);
+    prependSurfaceHelper(nullptr, application);
 }
 
-void TopLevelWindowModel::appendSurface(MirSurface *surface, unityapi::ApplicationInfoInterface *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.surface == nullptr) {
-            entry.surface = surface;
+        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();
-            Q_EMIT dataChanged(index(i) /* topLeft */, index(i) /* bottomRight */, QVector<int>() << SurfaceRole);
             filledPlaceholder = true;
         }
     }
 
     if (!filledPlaceholder) {
         DEBUG_MSG << " appId=" << application->appId() << " surface=" << surface << ", adding new row";
-        appendSurfaceHelper(surface, application);
+        prependSurfaceHelper(surface, application);
     }
 }
 
-void TopLevelWindowModel::appendSurfaceHelper(MirSurface *surface, unityapi::ApplicationInfoInterface *application)
+void TopLevelWindowModel::prependSurfaceHelper(MirSurface *surface, Application *application)
 {
     if (m_modelState == IdleState) {
         m_modelState = InsertingState;
-        beginInsertRows(QModelIndex(), m_windowModel.size() /*first*/, m_windowModel.size() /*last*/);
+        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();
-    m_windowModel.append(ModelEntry(surface, application, id));
+    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();
@@ -191,9 +197,54 @@
         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){
@@ -237,11 +288,9 @@
     if (m_windowModel[i].removeOnceSurfaceDestroyed) {
         removeAt(i);
     } else {
-        if (m_windowModel[i].surface == m_focusedSurface) {
-            setFocusedSurface(nullptr);
-        }
-        m_windowModel[i].surface = nullptr;
-        Q_EMIT dataChanged(index(i) /* topLeft */, index(i) /* bottomRight */, QVector<int>() << SurfaceRole);
+        auto window = m_windowModel[i].window;
+        window->setSurface(nullptr);
+        window->setFocused(false);
         DEBUG_MSG << " Removed surface from entry. After: " << toString();
     }
 }
@@ -255,14 +304,8 @@
     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);
-}
-
-QHash<int, QByteArray> TopLevelWindowModel::roleNames() const
-{
-    QHash<int, QByteArray> roleNames { {SurfaceRole, "surface"},
-                                       {ApplicationRole, "application"},
-                                       {IdRole, "id"} };
-    return roleNames;
+    connect(notifier, &WindowModelNotifier::modificationsStarted, this, &TopLevelWindowModel::onModificationsStarted, Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::modificationsEnded, this, &TopLevelWindowModel::onModificationsEnded, Qt::QueuedConnection);
 }
 
 void TopLevelWindowModel::onWindowAdded(const NewWindow &window)
@@ -276,11 +319,16 @@
         session->registerSurface(surface);
 
     if (window.windowInfo.type() == mir_surface_type_inputmethod) {
-        setInputMethodWindow(surface);
+        int id = generateId();
+        Window *qmlWindow = new Window(id);
+        connectWindow(qmlWindow);
+        qmlWindow->setSurface(surface);
+        setInputMethodWindow(qmlWindow);
     } else {
-        unityapi::ApplicationInfoInterface *application = m_applicationManager->findApplicationWithSession(mirSession);
-        appendSurface(surface, application);
+        Application *application = m_applicationManager->findApplicationWithSession(mirSession);
+        prependSurface(surface, 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)
@@ -292,7 +340,8 @@
 
     const int index = findIndexOf(windowInfo.window());
     if (index >= 0) {
-        m_windowModel[index].surface->setLive(false);
+        auto surface = static_cast<MirSurface*>(m_windowModel[index].window->surface());
+        surface->setLive(false);
     }
 }
 
@@ -306,12 +355,15 @@
         // No point in signaling anything if we're resetting the whole model
     }
 
-    if (m_windowModel[index].surface != nullptr && m_windowModel[index].surface == m_focusedSurface) {
-        setFocusedSurface(nullptr);
-    }
+    auto window = m_windowModel[index].window;
+
+    window->setSurface(nullptr);
+    window->setFocused(false);
 
     m_windowModel.removeAt(index);
 
+    delete window;
+
     if (m_modelState == RemovingState) {
         endRemoveRows();
         Q_EMIT countChanged();
@@ -340,12 +392,6 @@
 {
     if (auto mirSurface = find(windowInfo)) {
         mirSurface->setFocused(focused);
-
-        if (focused) {
-            setFocusedSurface(mirSurface);
-        } else if (mirSurface == m_focusedSurface) {
-            setFocusedSurface(nullptr);
-        }
     }
 }
 
@@ -353,78 +399,41 @@
 {
     if (auto mirSurface = find(windowInfo)) {
         mirSurface->updateState(state);
+    } else if (m_inputMethodWindow) {
+        auto surface = static_cast<MirSurface*>(m_inputMethodWindow->surface());
+        if (surface->window() == windowInfo.window()) {
+            surface->updateState(state);
+        }
     }
 }
 
-void TopLevelWindowModel::setInputMethodWindow(MirSurface *surface)
+void TopLevelWindowModel::setInputMethodWindow(Window *window)
 {
-    if (m_inputMethodSurface) {
-        qDebug("Multiple Input Method Surfaces created, removing the old one!");
-        delete m_inputMethodSurface;
+    if (m_inputMethodWindow) {
+        qWarning("Multiple Input Method Surfaces created, removing the old one!");
+        delete m_inputMethodWindow;
     }
-    m_inputMethodSurface = surface;
-    Q_EMIT inputMethodSurfaceChanged(m_inputMethodSurface);
+    m_inputMethodWindow = window;
+    Q_EMIT inputMethodSurfaceChanged(m_inputMethodWindow->surface());
 }
 
 void TopLevelWindowModel::removeInputMethodWindow()
 {
-    if (m_inputMethodSurface) {
-        delete m_inputMethodSurface;
-        m_inputMethodSurface = nullptr;
-        Q_EMIT inputMethodSurfaceChanged(m_inputMethodSurface);
+    if (m_inputMethodWindow) {
+        delete m_inputMethodWindow;
+        m_inputMethodWindow = nullptr;
+        Q_EMIT inputMethodSurfaceChanged(nullptr);
     }
 }
 
 void TopLevelWindowModel::onWindowsRaised(const std::vector<miral::Window> &windows)
 {
-    // Reminder: last item in the "windows" list should end up at the top of the model
-    const int modelCount = m_windowModel.count();
     const int raiseCount = windows.size();
-
-    // Assumption: no NO-OPs are in this list - Qt will crash on endMoveRows() if you try NO-OPs!!!
-    // A NO-OP is if
-    //    1. "indices" is an empty list
-    //    2. "indices" of the form (..., modelCount - 2, modelCount - 1) which results in an unchanged list
-
-    // Precompute the list of indices of Windows/Surfaces to raise, including the offsets due to
-    // indices which have already been moved.
-    QVector<QPair<int /*from*/, int /*to*/>> moveList;
-
-    for (int i=raiseCount-1; i>=0; i--) {
-        int from = findIndexOf(windows[i]);
-        const int to = modelCount - raiseCount + i;
-
-        int moveCount = 0;
-        // how many list items under "index" have been moved so far, correct "from" to suit
-        for (int j=raiseCount-1; j>i; j--) {
-            if (findIndexOf(windows[j]) < from) {
-                moveCount++;
-            }
-        }
-        from -= moveCount;
-
-        if (from == to) {
-            // is NO-OP, would result in moving element to itself
-        } else {
-            moveList.prepend({from, to});
-        }
-    }
-
-    // Perform the moving, trusting the moveList is correct for each iteration.
-    QModelIndex parent;
-    for (int i=moveList.count()-1; i>=0; i--) {
-        const int from = moveList[i].first;
-        const int to = moveList[i].second;
-
-        beginMoveRows(parent, from, from, parent, to+1);
-#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();
+    for (int i = 0; i < raiseCount; i++) {
+        int fromIndex = findIndexOf(windows[i]);
+        if (fromIndex != -1) {
+            move(fromIndex, 0);
+        }
     }
 }
 
@@ -438,13 +447,11 @@
     if (index.row() < 0 || index.row() >= m_windowModel.size())
         return QVariant();
 
-    if (role == SurfaceRole) {
-        unityapi::MirSurfaceInterface *surface = m_windowModel.at(index.row()).surface;
-        return QVariant::fromValue(surface);
+    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 if (role == IdRole) {
-        return QVariant::fromValue(m_windowModel.at(index.row()).id);
     } else {
         return QVariant();
     }
@@ -454,8 +461,9 @@
 {
     auto window = needle.window();
     Q_FOREACH(const auto entry, m_windowModel) {
-        if (entry.surface && entry.surface->window() == window) {
-            return entry.surface;
+        auto surface = static_cast<MirSurface*>(entry.window->surface());
+        if (surface && surface->window() == window) {
+            return surface;
         }
     }
     return nullptr;
@@ -464,7 +472,8 @@
 int TopLevelWindowModel::findIndexOf(const miral::Window &needle) const
 {
     for (int i=0; i<m_windowModel.count(); i++) {
-        if (m_windowModel[i].surface && m_windowModel[i].surface->window() == needle) {
+        auto surface = static_cast<MirSurface*>(m_windowModel[i].window->surface());
+        if (surface && surface->window() == needle) {
             return i;
         }
     }
@@ -501,8 +510,8 @@
         QString itemStr = QString("(index=%1,appId=%2,surface=0x%3,id=%4)")
             .arg(i)
             .arg(item.application->appId())
-            .arg((qintptr)item.surface, 0, 16)
-            .arg(item.id);
+            .arg((qintptr)item.window->surface(), 0, 16)
+            .arg(item.window->id());
 
         if (i > 0) {
             str.append(",");
@@ -515,7 +524,7 @@
 int TopLevelWindowModel::indexOf(MirSurfaceInterface *surface)
 {
     for (int i = 0; i < m_windowModel.count(); ++i) {
-        if (m_windowModel.at(i).surface == surface) {
+        if (m_windowModel.at(i).window->surface() == surface) {
             return i;
         }
     }
@@ -525,17 +534,26 @@
 int TopLevelWindowModel::indexForId(int id) const
 {
     for (int i = 0; i < m_windowModel.count(); ++i) {
-        if (m_windowModel[i].id == id) {
+        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].surface;
+        return m_windowModel[index].window->surface();
     } else {
         return nullptr;
     }
@@ -553,7 +571,7 @@
 int TopLevelWindowModel::idAt(int index) const
 {
     if (index >=0 && index < m_windowModel.count()) {
-        return m_windowModel[index].id;
+        return m_windowModel[index].window->id();
     } else {
         return 0;
     }
@@ -579,29 +597,53 @@
 {
     int fromIndex = indexForId(id);
     if (fromIndex != -1) {
-        auto surface = m_windowModel[fromIndex].surface;
+        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, m_windowModel.count() - 1);
-        }
-    }
-}
-
-void TopLevelWindowModel::setFocusedSurface(MirSurface *surface)
-{
-    if (surface != m_focusedSurface) {
-        DEBUG_MSG << "(" << surface << ")";
-        m_focusedSurface = surface;
-        Q_EMIT focusedSurfaceChanged(m_focusedSurface);
-    }
-}
-
-unityapi::MirSurfaceInterface* TopLevelWindowModel::focusedSurface() const
-{
-    return m_focusedSurface;
+            move(fromIndex, 0);
+        }
+    }
+}
+
+Window *TopLevelWindowModel::findWindowWithSurface(MirSurface *surface)
+{
+    for (int i = 0; i < m_windowModel.count(); ++i) {
+        Window *window = m_windowModel[i].window;
+        if (window->surface() == surface) {
+            return window;
+        }
+    }
+    return nullptr;
+}
+
+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)
@@ -619,11 +661,30 @@
         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;
+}

=== modified file 'miral-qt/src/modules/Unity/Application/toplevelwindowmodel.h'
--- miral-qt/src/modules/Unity/Application/toplevelwindowmodel.h	2016-10-06 21:13:42 +0000
+++ miral-qt/src/modules/Unity/Application/toplevelwindowmodel.h	2016-11-03 12:11:13 +0000
@@ -17,12 +17,15 @@
 #ifndef TOPLEVELWINDOWMODEL_H
 #define TOPLEVELWINDOWMODEL_H
 
-#include <QAbstractListModel>
 #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 {
@@ -37,97 +40,39 @@
 
 namespace qtmir {
 
+class Application;
 class ApplicationManagerInterface;
 class SessionManager;
 class WindowControllerInterface;
 
-// TODO: Define an interface in unityapi
-class TopLevelWindowModel : public QAbstractListModel
+class TopLevelWindowModel : public unity::shell::application::TopLevelWindowModelInterface
 {
     Q_OBJECT
 
-    Q_PROPERTY(int count READ count NOTIFY countChanged)
-
-    Q_PROPERTY(unity::shell::application::MirSurfaceInterface* inputMethodSurface READ inputMethodSurface NOTIFY inputMethodSurfaceChanged)
-
-    Q_PROPERTY(unity::shell::application::MirSurfaceInterface* focusedSurface READ focusedSurface
-                                                                              NOTIFY focusedSurfaceChanged)
-
 public:
-    /**
-     * @brief The Roles supported by the model
-     *
-     * SurfaceRole - A MirSurfaceInterface. It will be null if the application is still starting up
-     * ApplicationRole - An ApplicationInfoInterface
-     * IdRole - A unique identifier for this entry. Useful to unambiguosly track elements as they move around in the list
-     */
-    enum Roles {
-        SurfaceRole = Qt::UserRole,
-        ApplicationRole = Qt::UserRole + 1,
-        IdRole = Qt::UserRole + 2,
-    };
-
     TopLevelWindowModel();
     explicit TopLevelWindowModel(WindowModelNotifier *notifier,
                          WindowControllerInterface *controller); // For testing
 
-    // QAbstractItemModel methods
+    // 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;
 
-    QHash<int, QByteArray> roleNames() const override;
-
-    int count() const { return rowCount(); }
-
-    unity::shell::application::MirSurfaceInterface* inputMethodSurface() const { return m_inputMethodSurface; }
-
-    unity::shell::application::MirSurfaceInterface* focusedSurface() const;
-
+    // Own API
     void setApplicationManager(ApplicationManagerInterface*);
 
 public Q_SLOTS:
-    /**
-     * @brief Returns the surface at the given index
-     *
-     * It will be a nullptr if the application is still starting up and thus hasn't yet created
-     * and drawn into a surface.
-     */
-    unity::shell::application::MirSurfaceInterface *surfaceAt(int index) const;
-
-    /**
-     * @brief Returns the application at the given index
-     */
-    unity::shell::application::ApplicationInfoInterface *applicationAt(int index) const;
-
-    /**
-     * @brief Returns the unique id of the element at the given index
-     */
-    int idAt(int index) const;
-
-    /**
-     * @brief Returns the index where the row with the given id is located
-     *
-     * Returns -1 if there's no row with the given id.
-     */
-    int indexForId(int id) const;
-
-    /**
-     * @brief Raises the row with the given id to the top of the window stack (index == count-1)
-     */
-    void raiseId(int id);
-
-Q_SIGNALS:
-    void countChanged();
-    void inputMethodSurfaceChanged(unity::shell::application::MirSurfaceInterface* inputMethodSurface);
-
-    /**
-     * @brief Emitted when the list changes
-     *
-     * Emitted when model gains an element, loses an element or when elements exchange positions.
-     */
-    void listChanged();
-
-    void focusedSurfaceChanged(unity::shell::application::MirSurfaceInterface *focusedSurface);
+    // 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);
@@ -137,6 +82,8 @@
     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);
@@ -146,22 +93,22 @@
     QString toString();
     int indexOf(MirSurfaceInterface *surface);
 
-    void setInputMethodWindow(MirSurface *surface);
-    void setFocusedSurface(MirSurface *surface);
+    void setInputMethodWindow(Window *window);
+    Window *findWindowWithSurface(MirSurface *surface);
+    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(unity::shell::application::ApplicationInfoInterface *application);
-    void removeApplication(unity::shell::application::ApplicationInfoInterface *application);
-
-    void appendPlaceholder(unity::shell::application::ApplicationInfoInterface *application);
-    void appendSurface(MirSurface *surface,
-                       unity::shell::application::ApplicationInfoInterface *application);
-    void appendSurfaceHelper(MirSurface *surface,
-                             unity::shell::application::ApplicationInfoInterface *application);
-
+    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);
@@ -171,21 +118,19 @@
 
     struct ModelEntry {
         ModelEntry() {}
-        ModelEntry(MirSurface *surface,
-                   unity::shell::application::ApplicationInfoInterface *application,
-                   int id)
-            : surface(surface), application(application), id(id) {}
-        MirSurface *surface{nullptr};
-        unity::shell::application::ApplicationInfoInterface *application{nullptr};
-        int id{-1};
+        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;
-    MirSurface* m_inputMethodSurface{nullptr};
-    MirSurface* m_focusedSurface{nullptr};
+    Window* m_inputMethodWindow{nullptr};
+    Window* m_focusedWindow{nullptr};
     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
@@ -202,6 +147,10 @@
         ResettingState
     };
     ModelState m_modelState{IdleState};
+
+    // Valid between modificationsStarted and modificationsEnded
+    bool m_focusedWindowChanged{false};
+    Window *m_newlyFocusedWindow{nullptr};
 };
 
 } // namespace qtmir

=== added file 'miral-qt/src/modules/Unity/Application/window.cpp'
--- miral-qt/src/modules/Unity/Application/window.cpp	1970-01-01 00:00:00 +0000
+++ miral-qt/src/modules/Unity/Application/window.cpp	2016-11-03 12:11:13 +0000
@@ -0,0 +1,190 @@
+/*
+ * 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();
+        });
+
+        // QPointer is based on QWeakPointer which will be cleared only on QObject destructor (according to docs).
+        // We don't want that. MirSurface emits detroyed() early on
+        connect(surface, &QObject::destroyed, this, [this, surface](){ setSurface(nullptr); });
+
+        // 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);
+    }
+}

=== added file 'miral-qt/src/modules/Unity/Application/window.h'
--- miral-qt/src/modules/Unity/Application/window.h	1970-01-01 00:00:00 +0000
+++ miral-qt/src/modules/Unity/Application/window.h	2016-11-03 12:11:13 +0000
@@ -0,0 +1,67 @@
+/*
+ * 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

=== modified file 'miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp'
--- miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp	2016-11-01 10:28:07 +0000
+++ miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp	2016-11-03 12:11:13 +0000
@@ -192,12 +192,12 @@
 
 void WindowManagementPolicy::advise_begin()
 {
-    // TODO
+    Q_EMIT m_windowModel.modificationsStarted();
 }
 
 void WindowManagementPolicy::advise_end()
 {
-    // TODO
+    Q_EMIT m_windowModel.modificationsEnded();
 }
 
 /* Following methods all called from the Qt GUI thread to deliver events to clients */
@@ -248,13 +248,15 @@
 // raises the window tree and focus it.
 void WindowManagementPolicy::activate(const miral::Window &window)
 {
-    auto &windowInfo = m_tools.info_for(window);
+    if (window) {
+        auto &windowInfo = m_tools.info_for(window);
 
-    // restore from minimized if needed
-    if (windowInfo.state() == mir_surface_state_minimized) {
-        auto extraInfo = getExtraInfo(windowInfo);
-        Q_ASSERT(extraInfo->previousState != Mir::MinimizedState);
-        requestState(window, extraInfo->previousState);
+        // restore from minimized if needed
+        if (windowInfo.state() == mir_surface_state_minimized) {
+            auto extraInfo = getExtraInfo(windowInfo);
+            Q_ASSERT(extraInfo->previousState != Mir::MinimizedState);
+            requestState(window, extraInfo->previousState);
+        }
     }
 
     m_tools.invoke_under_lock([&]() {