Merge lp:~gerboland/miral/qt-add-window-model-qt-side into lp:miral

[Gerry Boland]

[miral-qt] Add Qt-side window model

[Alan Griffiths (alan-griffiths)]

Nits again:

+#include <mir/shell/abstract_shell.h>

We only use <mir/shell/shell.h>

~~~~

In miral-qt/src/platforms/mirserver/screensmodel.h

+#include <mir/shell/window_manager.h>

Not needed.

~~~~

+ auto e = reinterpret_cast<MirEvent const*>(event); // naughty

Is Mir missing a good way to do this? (C.f. mir_keyboard_event_input_event())

review: Needs Fixing

[Gerry Boland (gerboland)]

> Nits again:
>
> +#include <mir/shell/abstract_shell.h>
>
> We only use <mir/shell/shell.h>
Fixed

> ~~~~
>
> In miral-qt/src/platforms/mirserver/screensmodel.h
>
> +#include <mir/shell/window_manager.h>
>
> Not needed.
Fixed

> ~~~~
>
> + auto e = reinterpret_cast<MirEvent const*>(event); // naughty
>
> Is Mir missing a good way to do this? (C.f. mir_keyboard_event_input_event())

I couldn't find another way to achieve this in Mir's apis.

[lp:~gerboland/miral/qt-add-window-model-qt-side]

252. By Gerry Boland on 2016-07-27

Only use mir/shell/shell.h

253. By Gerry Boland on 2016-07-27

Another unnecessary header

[Alan Griffiths (alan-griffiths)]

Good stuff to have on trunk (even if it is still a little flaky).

review: Approve

=== added file 'miral-qt/demos/qml-demo-shell/windowModel.qml'
--- miral-qt/demos/qml-demo-shell/windowModel.qml	1970-01-01 00:00:00 +0000
+++ miral-qt/demos/qml-demo-shell/windowModel.qml	2016-07-27 16:52:34 +0000
@@ -0,0 +1,38 @@
+import QtQuick 2.4
+import Unity.Application 0.1
+
+FocusScope {
+    focus: true
+
+    WindowModel {
+        id: windowModel;
+    }
+
+    Repeater {
+        anchors.fill: parent
+        model: windowModel
+
+        delegate: MirSurfaceItem {
+            id: surfaceItem
+            surface: model.surface
+            consumesInput: true // QUESTION: why is this non-default?
+            x: surface.position.x
+            y: surface.position.y
+            width: surface.size.width
+            height: surface.size.height
+            focus: surface.focused
+
+            Rectangle {
+                anchors { top: parent.bottom; right: parent.right }
+                width: childrenRect.width
+                height: childrenRect.height
+                color: surface.focused ? "red" : "lightsteelblue"
+                opacity: 0.8
+                Text {
+                    text: surface.position.x + "," + surface.position.y + " " + surface.size.width + "x" + surface.size.height
+                    font.pixelSize: 10
+                }
+            }
+        }
+    }
+}

=== modified file 'miral-qt/src/common/mirqtconversion.h'
--- miral-qt/src/common/mirqtconversion.h	2016-07-27 16:52:34 +0000
+++ miral-qt/src/common/mirqtconversion.h	2016-07-27 16:52:34 +0000
@@ -3,26 +3,55 @@
 
 #include <QSize>
 #include <QPoint>
+#include <QRect>
 
 #include <mir/geometry/size.h>
 #include <mir/geometry/point.h>
+#include <mir/geometry/rectangle.h>
 
 namespace qtmir {
 
 /*
- * Some handy conversions from Mir types to Qt types
+ * Some handy conversions from Mir types to Qt types and back
  */
 
-inline QSize toQSize(mir::geometry::Size size)
+inline QSize toQSize(const mir::geometry::Size size)
 {
     return QSize(size.width.as_int(), size.height.as_int());
 }
 
+inline mir::geometry::Size toMirSize(const QSize size)
+{
+    namespace mg = mir::geometry;
+    return mg::Size{ mg::Width{ size.width()}, mg::Height{ size.height()} };
+}
+
 inline QPoint toQPoint(mir::geometry::Point point)
 {
     return QPoint(point.x.as_int(), point.y.as_int());
 }
 
+inline mir::geometry::Point toMirPoint(const QPoint point)
+{
+    namespace mg = mir::geometry;
+    return mg::Point{ mg::X{ point.x()}, mg::Y{ point.y()} };
+}
+
+inline QRect toQRect(const mir::geometry::Rectangle rect)
+{
+    return QRect(rect.top_left.x.as_int(), rect.top_left.y.as_int(),
+                 rect.size.width.as_int(), rect.size.height.as_int());
+}
+
+inline mir::geometry::Rectangle toMirRectangle(const QRect rect)
+{
+    namespace mg = mir::geometry;
+    return mg::Rectangle{
+        mg::Point{ mg::X{ rect.x()}, mg::Y{ rect.y()} },
+        mg::Size{ mg::Width{ rect.width()}, mg::Height{ rect.height()} }
+    };
+}
+
 } // namespace qtmir
 
 #endif // MIRQTCONVERSION_H

=== modified file 'miral-qt/src/common/windowmodelinterface.h'
--- miral-qt/src/common/windowmodelinterface.h	2016-07-27 16:52:34 +0000
+++ miral-qt/src/common/windowmodelinterface.h	2016-07-27 16:52:34 +0000
@@ -68,9 +68,9 @@
     virtual ~WindowModelInterface() = default;
 
 Q_SIGNALS:
-    void windowAdded(const NumberedWindow);
+    void windowAdded(const qtmir::NumberedWindow);
     void windowRemoved(const unsigned int index);
-    void windowChanged(const DirtiedWindow);
+    void windowChanged(const qtmir::DirtiedWindow);
 
 private:
     Q_DISABLE_COPY(WindowModelInterface)

=== modified file 'miral-qt/src/modules/Unity/Application/CMakeLists.txt'
--- miral-qt/src/modules/Unity/Application/CMakeLists.txt	2016-07-26 12:45:17 +0000
+++ miral-qt/src/modules/Unity/Application/CMakeLists.txt	2016-07-27 16:52:34 +0000
@@ -49,6 +49,7 @@
     timesource.cpp
     tracepoints.c
     settings.cpp
+    windowmodel.cpp
 # We need to run moc on these headers
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h

=== modified file 'miral-qt/src/modules/Unity/Application/dbuswindowstack.cpp'
--- miral-qt/src/modules/Unity/Application/dbuswindowstack.cpp	2016-06-01 22:06:51 +0000
+++ miral-qt/src/modules/Unity/Application/dbuswindowstack.cpp	2016-07-27 16:52:34 +0000
@@ -28,10 +28,10 @@
 {
     qRegisterMetaType<AppIdDesktopFile>();
     qDBusRegisterMetaType<AppIdDesktopFile>();
-    qRegisterMetaType<WindowInfo>();
-    qRegisterMetaType< QList<WindowInfo> >();
-    qDBusRegisterMetaType<WindowInfo>();
-    qDBusRegisterMetaType< QList<WindowInfo> >();
+    qRegisterMetaType<DBusWindowInfo>();
+    qRegisterMetaType< QList<DBusWindowInfo> >();
+    qDBusRegisterMetaType<DBusWindowInfo>();
+    qDBusRegisterMetaType< QList<DBusWindowInfo> >();
 
     QDBusConnection::sessionBus().registerService("com.canonical.Unity.WindowStack");
     // TODO ExportScriptableSlots shouldn't be needed but without it i don't get the methods :-/
@@ -54,13 +54,13 @@
     return res;
 }
 
-QList<WindowInfo> DBusWindowStack::GetWindowStack()
+QList<DBusWindowInfo> DBusWindowStack::GetWindowStack()
 {
-    QList<WindowInfo> res;
+    QList<DBusWindowInfo> res;
     ApplicationManager *appMgr = static_cast<ApplicationManager*>(parent());
     const QList<Application*> &applications = appMgr->list();
     Q_FOREACH(Application* app, applications) {
-        WindowInfo wi;
+        DBusWindowInfo wi;
         wi.window_id = 0;
         wi.app_id = app->appId();
         wi.focused = app->focused();
@@ -96,7 +96,7 @@
     return a;
 }
 
-QDBusArgument &operator<<(QDBusArgument &a, const WindowInfo &wi)
+QDBusArgument &operator<<(QDBusArgument &a, const DBusWindowInfo &wi)
 {
     a.beginStructure();
     a << wi.window_id << wi.app_id << wi.focused << wi.stage;
@@ -104,7 +104,7 @@
     return a;
 }
 
-const QDBusArgument &operator>>(const QDBusArgument &a, WindowInfo &wi)
+const QDBusArgument &operator>>(const QDBusArgument &a, DBusWindowInfo &wi)
 {
     a.beginStructure();
     a >> wi.window_id >> wi.app_id >> wi.focused >> wi.stage;

=== modified file 'miral-qt/src/modules/Unity/Application/dbuswindowstack.h'
--- miral-qt/src/modules/Unity/Application/dbuswindowstack.h	2016-06-01 22:06:51 +0000
+++ miral-qt/src/modules/Unity/Application/dbuswindowstack.h	2016-07-27 16:52:34 +0000
@@ -34,7 +34,7 @@
 QDBusArgument &operator<<(QDBusArgument &a, const AppIdDesktopFile &aidf);
 const QDBusArgument &operator>>(const QDBusArgument &a, AppIdDesktopFile &aidf);
 
-class WindowInfo
+class DBusWindowInfo
 {
 public:
     unsigned int window_id;
@@ -43,8 +43,8 @@
     unsigned int stage;
 };
 
-QDBusArgument &operator<<(QDBusArgument &a, const WindowInfo &aidf);
-const QDBusArgument &operator>>(const QDBusArgument &a, WindowInfo &aidf);
+QDBusArgument &operator<<(QDBusArgument &a, const DBusWindowInfo &aidf);
+const QDBusArgument &operator>>(const QDBusArgument &a, DBusWindowInfo &aidf);
 
 class DBusWindowStack : public QObject
 {
@@ -55,7 +55,7 @@
     ~DBusWindowStack();
 
     Q_INVOKABLE Q_SCRIPTABLE qtmir::AppIdDesktopFile GetAppIdFromPid(unsigned int pid);
-    Q_INVOKABLE Q_SCRIPTABLE QList<qtmir::WindowInfo> GetWindowStack();
+    Q_INVOKABLE Q_SCRIPTABLE QList<qtmir::DBusWindowInfo> GetWindowStack();
     Q_INVOKABLE Q_SCRIPTABLE QStringList GetWindowProperties(unsigned int window_id, const QString &app_id, const QStringList &names);
 
 Q_SIGNALS:
@@ -67,6 +67,6 @@
 } // namespace qtmir
 
 Q_DECLARE_METATYPE(qtmir::AppIdDesktopFile)
-Q_DECLARE_METATYPE(qtmir::WindowInfo)
+Q_DECLARE_METATYPE(qtmir::DBusWindowInfo)
 
 #endif // DBUSWINDOWSTACK_H

=== modified file 'miral-qt/src/modules/Unity/Application/mirsurface.cpp'
--- miral-qt/src/modules/Unity/Application/mirsurface.cpp	2016-07-26 12:45:17 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurface.cpp	2016-07-27 16:52:34 +0000
@@ -21,6 +21,7 @@
 
 // from common dir
 #include <debughelpers.h>
+#include "mirqtconversion.h"
 
 // mirserver
 #include <surfaceobserver.h>
@@ -196,6 +197,7 @@
 {
     DEBUG_MSG << "()";
 
+    m_position = toQPoint(surface->top_left());
     m_minimumWidth = creationHints.minWidth;
     m_minimumHeight = creationHints.minHeight;
     m_maximumWidth = creationHints.maxWidth;
@@ -518,6 +520,11 @@
     }
 }
 
+QPoint MirSurface::position() const
+{
+    return m_position;
+}
+
 QSize MirSurface::size() const
 {
     return m_size;
@@ -1017,6 +1024,15 @@
     m_session->session()->destroy_surface(m_surface);
 }
 
+void MirSurface::setPosition(const QPoint newPosition)
+{
+    if (m_position == newPosition) {
+        return;
+    }
+    m_position = newPosition;
+    Q_EMIT positionChanged(m_position);
+}
+
 void MirSurface::setCloseTimer(AbstractTimer *timer)
 {
     bool timerWasRunning = false;

=== modified file 'miral-qt/src/modules/Unity/Application/mirsurface.h'
--- miral-qt/src/modules/Unity/Application/mirsurface.h	2016-07-26 12:45:17 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurface.h	2016-07-27 16:52:34 +0000
@@ -72,6 +72,9 @@
     void resize(int width, int height) override;
     void resize(const QSize &size) override { resize(size.width(), size.height()); }
 
+    QPoint position() const override;
+    void setPosition(const QPoint newPosition) override;
+
     Mir::State state() const override;
     void setState(Mir::State qmlState) override;
 
@@ -216,6 +219,7 @@
 
     std::shared_ptr<SurfaceObserver> m_surfaceObserver;
 
+    QPoint m_position;
     QSize m_size;
     QString m_keymap;
 

=== modified file 'miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h'
--- miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h	2016-07-26 12:45:17 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h	2016-07-27 16:52:34 +0000
@@ -24,6 +24,7 @@
 
 // Qt
 #include <QCursor>
+#include <QPoint>
 #include <QSharedPointer>
 #include <QTouchEvent>
 
@@ -38,10 +39,18 @@
 {
     Q_OBJECT
 
+    /**
+     * @brief Position of the current surface buffer, in pixels.
+     */
+    Q_PROPERTY(QPoint position READ position NOTIFY positionChanged)
+
 public:
     MirSurfaceInterface(QObject *parent = nullptr) : unity::shell::application::MirSurfaceInterface(parent) {}
     virtual ~MirSurfaceInterface() {}
 
+    virtual QPoint position() const = 0;
+    virtual void setPosition(const QPoint newPosition) = 0;
+
     virtual void setLive(bool value) = 0;
 
     virtual bool isFirstFrameDrawn() const = 0;
@@ -125,6 +134,7 @@
     void framesPosted();
     void isBeingDisplayedChanged();
     void frameDropped();
+    void positionChanged(QPoint position);
 };
 
 } // namespace qtmir

=== modified file 'miral-qt/src/modules/Unity/Application/plugin.cpp'
--- miral-qt/src/modules/Unity/Application/plugin.cpp	2016-07-26 12:45:17 +0000
+++ miral-qt/src/modules/Unity/Application/plugin.cpp	2016-07-27 16:52:34 +0000
@@ -25,6 +25,7 @@
 #include "mirsurfaceinterface.h"
 #include "mirsurfaceitem.h"
 #include "mirsurfacelistmodel.h"
+#include "windowmodel.h"
 
 // platforms/mirserver
 #include <mirsingleton.h>
@@ -94,6 +95,8 @@
                     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::WindowModel>(uri, 0, 1, "WindowModel");
     }
 
     virtual void initializeEngine(QQmlEngine *engine, const char *uri)

=== added file 'miral-qt/src/modules/Unity/Application/windowmodel.cpp'
--- miral-qt/src/modules/Unity/Application/windowmodel.cpp	1970-01-01 00:00:00 +0000
+++ miral-qt/src/modules/Unity/Application/windowmodel.cpp	2016-07-27 16:52:34 +0000
@@ -0,0 +1,119 @@
+/*
+ * 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 "windowmodel.h"
+
+#include "mirsurface.h"
+#include "surfaceobserver.h"
+
+#include <mir/scene/surface.h>
+
+// mirserver
+#include "nativeinterface.h"
+
+// Qt
+#include <QGuiApplication>
+#include <QDebug>
+
+using namespace qtmir;
+
+WindowModel::WindowModel()
+{
+
+    auto nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
+
+    if (!nativeInterface) {
+        qFatal("ERROR: Unity.Application QML plugin requires use of the 'mirserver' QPA plugin");
+    }
+
+    auto windowModel = static_cast<WindowModelInterface*>(nativeInterface->nativeResourceForIntegration("WindowModel"));
+
+    connect(windowModel, &WindowModelInterface::windowAdded, this, &WindowModel::onWindowAdded);
+    connect(windowModel, &WindowModelInterface::windowRemoved, this, &WindowModel::onWindowRemoved);
+    connect(windowModel, &WindowModelInterface::windowChanged, this, &WindowModel::onWindowChanged);
+}
+
+QHash<int, QByteArray> WindowModel::roleNames() const
+{
+    QHash<int, QByteArray> roleNames;
+    roleNames.insert(SurfaceRole, "surface");
+    return roleNames;
+}
+
+void WindowModel::onWindowAdded(const NumberedWindow window)
+{
+    qDebug() << "Window Added!" << window.index;
+    std::shared_ptr<SurfaceObserver> surfaceObserver = std::make_shared<SurfaceObserver>();
+    const auto &surface = window.windowInfo.surface;
+    SurfaceObserver::registerObserverForSurface(surfaceObserver.get(), surface.get());
+    surface->add_observer(surfaceObserver);
+
+    auto mirSurface = new MirSurface(surface, nullptr, nullptr, surfaceObserver, CreationHints());
+    beginInsertRows(QModelIndex(), window.index, window.index);
+    m_windowModel.insert(window.index, mirSurface);
+    endInsertRows();
+    Q_EMIT countChanged();
+}
+
+void WindowModel::onWindowRemoved(const unsigned int index)
+{
+    qDebug() << "Window Removed!" << index;
+    beginRemoveRows(QModelIndex(), index, index);
+    m_windowModel.remove(index);
+    endRemoveRows();
+    Q_EMIT countChanged();
+}
+
+void WindowModel::onWindowChanged(const DirtiedWindow window)
+{
+    qDebug() << "Window Change!" << window.index;
+    auto mirSurface = m_windowModel.value(window.index);
+
+    switch(window.dirtyWindowInfo) {
+    case WindowInfo::DirtyStates::Size: {
+        qDebug() << "size";
+        // Do nothing yet, it gets new size from swapped buffer for now
+    }
+    case WindowInfo::DirtyStates::Position:
+        qDebug() << "position";
+        mirSurface->setPosition(window.windowInfo.position);
+    case WindowInfo::DirtyStates::Focus:
+        qDebug() << "focus";
+        mirSurface->setFocused(window.windowInfo.focused);
+    }
+
+    QModelIndex row = index(window.index);
+    Q_EMIT dataChanged(row, row, QVector<int>() << SurfaceRole);
+}
+
+int WindowModel::rowCount(const QModelIndex &/*parent*/) const
+{
+    return m_windowModel.count();
+}
+
+QVariant WindowModel::data(const QModelIndex &index, int role) const
+{
+    if (index.row() < 0 || index.row() >= m_windowModel.count())
+        return QVariant();
+
+    if (role == SurfaceRole) {
+        MirSurfaceInterface *surface = m_windowModel.at(index.row());
+        return QVariant::fromValue(static_cast<MirSurfaceInterface*>(surface));
+    } else {
+        return QVariant();
+    }
+}
+

=== added file 'miral-qt/src/modules/Unity/Application/windowmodel.h'
--- miral-qt/src/modules/Unity/Application/windowmodel.h	1970-01-01 00:00:00 +0000
+++ miral-qt/src/modules/Unity/Application/windowmodel.h	2016-07-27 16:52:34 +0000
@@ -0,0 +1,61 @@
+/*
+ * 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 WINDOWMODEL_H
+#define WINDOWMODEL_H
+
+#include <QAbstractListModel>
+
+#include "mirsurfaceinterface.h"
+#include "windowmodelinterface.h"
+
+namespace qtmir {
+
+class WindowModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+
+public:
+    enum Roles {
+        SurfaceRole = Qt::UserRole
+    };
+
+    WindowModel();
+
+    // QAbstractItemModel methods
+    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(); }
+
+Q_SIGNALS:
+    void countChanged();
+
+private Q_SLOTS:
+    void onWindowAdded(const NumberedWindow);
+    void onWindowRemoved(const unsigned int index);
+    void onWindowChanged(const DirtiedWindow);
+
+private:
+    QVector<MirSurfaceInterface *> m_windowModel;
+};
+
+} // namespace qtmir
+#endif // WINDOWMODEL_H

=== modified file 'miral-qt/src/platforms/mirserver/mirserver.cpp'
--- miral-qt/src/platforms/mirserver/mirserver.cpp	2016-06-21 12:35:41 +0000
+++ miral-qt/src/platforms/mirserver/mirserver.cpp	2016-07-27 16:52:34 +0000
@@ -42,6 +42,7 @@
 
 // mir
 #include <mir/graphics/cursor.h>
+#include <mir/shell/shell.h>
 
 namespace mg = mir::graphics;
 namespace mo  = mir::options;
@@ -114,7 +115,7 @@
         });
 
     add_init_callback([this, &screensModel] {
-        screensModel->init(the_display(), the_compositor());
+        screensModel->init(the_display(), the_compositor(), the_shell());
     });
 
     usingHiddenCursor(*this);
@@ -192,7 +193,7 @@
 
 UsingQtMirWindowManager::UsingQtMirWindowManager(const QSharedPointer<ScreensModel> &model)
     : m_screensModel(model)
-    , m_policy(miral::set_window_managment_policy<WindowManagementPolicy>(m_screensModel))
+    , m_policy(miral::set_window_managment_policy<WindowManagementPolicy>(m_windowModel, m_screensModel))
 {
 }
 
@@ -206,6 +207,11 @@
     return m_windowManager.lock().get();
 }
 
+qtmir::WindowModelInterface *UsingQtMirWindowManager::windowModel()
+{
+    return &m_windowModel;
+}
+
 mir::shell::Shell *MirServer::shell()
 {
     std::weak_ptr<mir::shell::Shell> m_shell = the_shell();

=== modified file 'miral-qt/src/platforms/mirserver/mirserver.h'
--- miral-qt/src/platforms/mirserver/mirserver.h	2016-06-21 12:35:41 +0000
+++ miral-qt/src/platforms/mirserver/mirserver.h	2016-07-27 16:52:34 +0000
@@ -21,6 +21,7 @@
 #include <QSharedPointer>
 #include <mir/server.h>
 #include "miral/set_window_managment_policy.h"
+#include "windowmodel.h"
 
 class QtEventFeeder;
 class MirDisplayConfigurationPolicy;
@@ -70,11 +71,13 @@
     UsingQtMirWindowManager(const QSharedPointer<ScreensModel> &model);
     void operator()(mir::Server& server);
     MirWindowManager *windowManager();
+    qtmir::WindowModelInterface *windowModel();
 
 private:
     const QSharedPointer<ScreensModel> &m_screensModel;
     miral::SetWindowManagmentPolicy m_policy;
     std::weak_ptr<MirWindowManager> m_windowManager;
+    qtmir::WindowModel m_windowModel;
 };
 
 // We use virtual inheritance of mir::Server to facilitate derived classes (e.g. testing)
@@ -115,6 +118,7 @@
     using UsingQtMirSessionListener::sessionListener;
     using UsingQtMirPromptSessionListener::promptSessionListener;
     using UsingQtMirWindowManager::windowManager;
+    using UsingQtMirWindowManager::windowModel;
     mir::shell::Shell *shell();
 
     QSharedPointer<ScreensModel> screensModel() const;

=== modified file 'miral-qt/src/platforms/mirserver/qmirserver.cpp'
--- miral-qt/src/platforms/mirserver/qmirserver.cpp	2016-06-01 22:06:51 +0000
+++ miral-qt/src/platforms/mirserver/qmirserver.cpp	2016-07-27 16:52:34 +0000
@@ -121,6 +121,8 @@
             result = d->server->promptSessionListener();
         else if (resource == "WindowManager")
             result = d->server->windowManager();
+        else if (resource == "WindowModel")
+            result = d->server->windowModel();
         else if (resource == "ScreensController")
             result = screensController().data();
     }

=== modified file 'miral-qt/src/platforms/mirserver/screensmodel.cpp'
--- miral-qt/src/platforms/mirserver/screensmodel.cpp	2016-06-01 22:06:51 +0000
+++ miral-qt/src/platforms/mirserver/screensmodel.cpp	2016-07-27 16:52:34 +0000
@@ -21,10 +21,12 @@
 #include "logging.h"
 #include "mirserverintegration.h"
 #include "screen.h"
+#include "mirqtconversion.h"
 
 // Mir
 #include <mir/graphics/display.h>
 #include <mir/graphics/display_buffer.h>
+#include <mir/compositor/display_listener.h>
 
 // Qt
 #include <QScreen>
@@ -47,10 +49,12 @@
 
 // init only after MirServer has initialized - runs on MirServerThread!!!
 void ScreensModel::init(const std::shared_ptr<mir::graphics::Display> &display,
-                        const std::shared_ptr<mir::compositor::Compositor> &compositor)
+                        const std::shared_ptr<mir::compositor::Compositor> &compositor,
+                        const std::shared_ptr<mir::compositor::DisplayListener> &displayListener)
 {
     m_display = display;
     m_compositor = compositor;
+    m_displayListener = displayListener;
 
     // Use a Blocking Queued Connection to enforce synchronization of Qt GUI thread with Mir thread(s)
     // on compositor shutdown. Compositor startup can be lazy.
@@ -146,6 +150,7 @@
     // Announce new Screens to Qt
     for (auto screen : newScreenList) {
         Q_EMIT screenAdded(screen);
+        m_displayListener->add_display(qtmir::toMirRectangle(screen->geometry()));
     }
 
     // Move Windows from about-to-be-deleted Screens to new Screen
@@ -168,6 +173,7 @@
         if (!ok) {
             qCWarning(QTMIR_SCREENS) << "Failed to invoke QGuiApplication::onScreenAboutToBeRemoved(QScreen*) slot.";
         }
+        m_displayListener->remove_display(qtmir::toMirRectangle(screen->geometry()));
         Q_EMIT screenRemoved(screen); // should delete the backing Screen
     }
 

=== modified file 'miral-qt/src/platforms/mirserver/screensmodel.h'
--- miral-qt/src/platforms/mirserver/screensmodel.h	2016-06-01 22:06:51 +0000
+++ miral-qt/src/platforms/mirserver/screensmodel.h	2016-07-27 16:52:34 +0000
@@ -28,7 +28,7 @@
 
 namespace mir {
     namespace graphics { class Display; }
-    namespace compositor { class Compositor; }
+    namespace compositor { class Compositor; class DisplayListener; }
 }
 class Screen;
 class QWindow;
@@ -74,7 +74,8 @@
 public:
     // called by MirServer
     void init(const std::shared_ptr<mir::graphics::Display> &display,
-              const std::shared_ptr<mir::compositor::Compositor> &compositor);
+              const std::shared_ptr<mir::compositor::Compositor> &compositor,
+              const std::shared_ptr<mir::compositor::DisplayListener> &displayListener);
     void terminate();
 
     // override for testing purposes
@@ -91,6 +92,7 @@
 
     std::weak_ptr<mir::graphics::Display> m_display;
     std::shared_ptr<mir::compositor::Compositor> m_compositor;
+    std::shared_ptr<mir::compositor::DisplayListener> m_displayListener;
     QList<Screen*> m_screenList;
     bool m_compositing;
 };

=== modified file 'miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp'
--- miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp	2016-07-27 16:52:34 +0000
+++ miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp	2016-07-27 16:52:34 +0000
@@ -18,57 +18,53 @@
 
 #include "screensmodel.h"
 
+#include "miral/window_manager_tools.h"
 #include "miral/window_specification.h"
 
+#include "mir/scene/surface.h"
+#include <QDebug>
+
 WindowManagementPolicy::WindowManagementPolicy(miral::WindowManagerTools * const tools,
+                                               qtmir::WindowModel &windowModel,
                                                const QSharedPointer<ScreensModel> screensModel)
     : CanonicalWindowManagerPolicy(tools)
     , m_tools(tools)
+    , m_windowModel(windowModel)
     , m_eventFeeder(new QtEventFeeder(screensModel))
 {
-
-}
-
-void WindowManagementPolicy::advise_displays_updated(const Rectangles&/*displays*/)
-{
-
-}
-
+}
+
+/* Following are hooks to allow custom policy be imposed */
 miral::WindowSpecification WindowManagementPolicy::place_new_surface(
-    const miral::ApplicationInfo &/*app_info*/,
+    const miral::ApplicationInfo &app_info,
     const miral::WindowSpecification &request_parameters)
 {
-    auto parameters = request_parameters;
+    auto parameters = CanonicalWindowManagerPolicy::place_new_surface(app_info, request_parameters);
+    qDebug() << "Place surface" << parameters.top_left().value().x.as_int();
     return parameters;
 }
 
-void WindowManagementPolicy::advise_new_window(miral::WindowInfo &/*windowInfo*/)
-{
-
-}
-
-void WindowManagementPolicy::handle_window_ready(miral::WindowInfo &/*windowInfo*/)
-{
-
+void WindowManagementPolicy::handle_window_ready(miral::WindowInfo &windowInfo)
+{
+    qDebug("Window ready");
+    m_tools->select_active_window(windowInfo.window());
 }
 
 void WindowManagementPolicy::handle_modify_window(
-    miral::WindowInfo &/*windowInfo*/,
-    const miral::WindowSpecification &/*modifications*/)
-{
-
-}
-
-void WindowManagementPolicy::advise_delete_window(const miral::WindowInfo &/*windowInfo*/)
-{
-
-}
-
-void WindowManagementPolicy::advise_raise(const std::vector<miral::Window> &/*windows*/)
-{
-
-}
-
+    miral::WindowInfo &windowInfo,
+    const miral::WindowSpecification &modifications)
+{
+    qDebug("Window Modified!");
+    m_tools->modify_window(windowInfo, modifications);
+}
+
+void WindowManagementPolicy::handle_raise_window(miral::WindowInfo &windowInfo)
+{
+    qDebug("Window Raise");
+    m_tools->select_active_window(windowInfo.window());
+}
+
+/* Handle input events - here just inject them into Qt event loop for later processing */
 bool WindowManagementPolicy::handle_keyboard_event(const MirKeyboardEvent *event)
 {
     m_eventFeeder->dispatchKey(event);
@@ -87,50 +83,120 @@
     return true;
 }
 
+/* Below are notifications of window state changes */
+void WindowManagementPolicy::advise_displays_updated(const Rectangles&/*displays*/)
+{
+    qDebug("Displays updated");
+}
+
+void WindowManagementPolicy::advise_new_window(miral::WindowInfo &windowInfo)
+{
+    m_windowModel.addWindow(windowInfo);
+}
+
+void WindowManagementPolicy::advise_delete_window(const miral::WindowInfo &windowInfo)
+{
+    m_windowModel.removeWindow(windowInfo);
+}
+
+void WindowManagementPolicy::advise_raise(const std::vector<miral::Window> &windows)
+{
+    m_windowModel.raiseWindows(windows);
+}
+
 void WindowManagementPolicy::advise_new_app(miral::ApplicationInfo &/*application*/)
 {
-
+    qDebug("New App");
 }
 
 void WindowManagementPolicy::advise_delete_app(const miral::ApplicationInfo &/*application*/)
 {
-
+    qDebug("Delete App");
 }
 
 void WindowManagementPolicy::advise_state_change(const miral::WindowInfo &/*windowInfo*/, MirSurfaceState /*state*/)
 {
-
-}
-
-void WindowManagementPolicy::advise_move_to(const miral::WindowInfo &/*window_info*/, Point /*top_left*/)
-{
-
-}
-
-void WindowManagementPolicy::advise_resize(const miral::WindowInfo &/*info*/, const Size &/*newSize*/)
-{
-
-}
-
-void WindowManagementPolicy::handle_raise_window(miral::WindowInfo &/*windowInfo*/)
-{
-
-}
-
-void WindowManagementPolicy::advise_focus_lost(const miral::WindowInfo &/*info*/)
-{
-
-}
-
-void WindowManagementPolicy::advise_focus_gained(const miral::WindowInfo &/*info*/)
-{
-
+    qDebug("Window State Change");
+}
+
+void WindowManagementPolicy::advise_move_to(const miral::WindowInfo &windowInfo, Point topLeft)
+{
+    qDebug("Window move");
+    m_windowModel.moveWindow(windowInfo, topLeft);
+}
+
+void WindowManagementPolicy::advise_resize(const miral::WindowInfo &windowInfo, const Size &newSize)
+{
+    qDebug("Window Resize");
+    m_windowModel.resizeWindow(windowInfo, newSize);
+}
+
+void WindowManagementPolicy::advise_focus_lost(const miral::WindowInfo &windowInfo)
+{
+    m_windowModel.focusWindow(windowInfo, false);
+}
+
+void WindowManagementPolicy::advise_focus_gained(const miral::WindowInfo &windowInfo)
+{
+    m_windowModel.focusWindow(windowInfo, true);
 }
 
 void WindowManagementPolicy::advise_begin()
 {
+    // TODO
 }
 
 void WindowManagementPolicy::advise_end()
 {
+    // TODO
+}
+
+/* Following methods all called from the Qt GUI thread to deliver events to clients */
+void WindowManagementPolicy::deliver_keyboard_event(const MirKeyboardEvent *event,
+                                                    const std::shared_ptr<mir::scene::Surface> &surface)
+{
+    m_tools->invoke_under_lock([&surface, this]() {
+        auto windowInfo = m_tools->info_for(surface);
+        m_tools->select_active_window(windowInfo.window());
+    });
+    auto e = reinterpret_cast<MirEvent const*>(event); // naughty
+    surface->consume(e);
+}
+
+void WindowManagementPolicy::deliver_touch_event(const MirTouchEvent *event,
+                                                 const std::shared_ptr<mir::scene::Surface> &surface)
+{
+    m_tools->invoke_under_lock([&surface, this]() {
+        auto windowInfo = m_tools->info_for(surface);
+        m_tools->select_active_window(windowInfo.window());
+    });
+    auto e = reinterpret_cast<MirEvent const*>(event); // naughty
+    surface->consume(e);
+}
+
+void WindowManagementPolicy::deliver_pointer_event(const MirPointerEvent *event,
+                                                   const std::shared_ptr<mir::scene::Surface> &surface)
+{
+    m_tools->invoke_under_lock([&surface, this]() {
+        auto windowInfo = m_tools->info_for(surface);
+        m_tools->select_active_window(windowInfo.window());
+    });
+    auto e = reinterpret_cast<MirEvent const*>(event); // naughty
+    surface->consume(e);
+}
+
+/* Methods to allow Shell to request changes to the window stack */
+void WindowManagementPolicy::focus(const miral::Window window)
+{
+    m_tools->select_active_window(window);
+}
+
+void WindowManagementPolicy::resize(const miral::Window window, const Size &size)
+{
+    m_tools->place_and_size(m_tools->info_for(window), window.top_left(), size);
+}
+
+void WindowManagementPolicy::move(const miral::Window window, const Point &top_left)
+{
+    m_tools->place_and_size(m_tools->info_for(window), top_left, window.size() );
 }

=== modified file 'miral-qt/src/platforms/mirserver/windowmanagementpolicy.h'
--- miral-qt/src/platforms/mirserver/windowmanagementpolicy.h	2016-07-27 16:52:34 +0000
+++ miral-qt/src/platforms/mirserver/windowmanagementpolicy.h	2016-07-27 16:52:34 +0000
@@ -20,6 +20,7 @@
 #include "miral/canonical_window_manager.h"
 
 #include "qteventfeeder.h"
+#include "windowmodel.h"
 
 #include <QObject>
 #include <QScopedPointer>
@@ -33,9 +34,10 @@
 {
 public:
     WindowManagementPolicy(miral::WindowManagerTools * const tools,
+                           qtmir::WindowModel &windowModel,
                            const QSharedPointer<ScreensModel> screensModel);
 
-
+    // From WindowManagementPolicy
     auto place_new_surface(const miral::ApplicationInfo &app_info,
                            const miral::WindowSpecification &request_parameters)
         -> miral::WindowSpecification override;
@@ -60,17 +62,27 @@
     void advise_focus_lost(const miral::WindowInfo &info) override;
     void advise_focus_gained(const miral::WindowInfo &info) override;
     void advise_state_change(const miral::WindowInfo &info, MirSurfaceState state) override;
-    void advise_move_to(miral::WindowInfo const& window_info, Point top_left) override;
+    void advise_move_to(const miral::WindowInfo &windowInfo, Point topLeft) override;
     void advise_resize(const miral::WindowInfo &info, const Size &newSize) override;
     void advise_delete_window(const miral::WindowInfo &windowInfo) override;
     void advise_raise(std::vector<miral::Window> const& windows) override;
 
     void advise_displays_updated(const Rectangles &displays) override;
 
+    // Exposing some tools
+    void deliver_keyboard_event(const MirKeyboardEvent *event, const std::shared_ptr<mir::scene::Surface> &surface);
+    void deliver_touch_event(const MirTouchEvent *event, const std::shared_ptr<mir::scene::Surface> &surface);
+    void deliver_pointer_event(const MirPointerEvent *event, const std::shared_ptr<mir::scene::Surface> &surface);
+
+    void focus(const miral::Window window);
+    void resize(const miral::Window window, const Size &size);
+    void move(const miral::Window window, const Point &top_left);
+
 Q_SIGNALS:
 
 private:
-    const miral::WindowManagerTools * const m_tools;
+    miral::WindowManagerTools * const m_tools;
+    qtmir::WindowModel &m_windowModel;
     const QScopedPointer<QtEventFeeder> m_eventFeeder;
 };
 

=== modified file 'miral-qt/src/platforms/mirserver/windowmodel.cpp'
--- miral-qt/src/platforms/mirserver/windowmodel.cpp	2016-07-27 16:52:34 +0000
+++ miral-qt/src/platforms/mirserver/windowmodel.cpp	2016-07-27 16:52:34 +0000
@@ -32,8 +32,8 @@
 WindowModel::WindowModel()
 {
     qDebug("WindowModel::WindowModel");
-    qRegisterMetaType<NumberedWindow>();
-    qRegisterMetaType<DirtiedWindow>();
+    qRegisterMetaType<qtmir::NumberedWindow>();
+    qRegisterMetaType<qtmir::DirtiedWindow>();
 }
 
 WindowModel::~WindowModel()

=== modified file 'miral-qt/tests/framework/fake_mirsurface.cpp'
--- miral-qt/tests/framework/fake_mirsurface.cpp	2016-06-07 20:32:04 +0000
+++ miral-qt/tests/framework/fake_mirsurface.cpp	2016-07-27 16:52:34 +0000
@@ -56,6 +56,16 @@
 
 QSize FakeMirSurface::size() const { return m_size; }
 
+QPoint FakeMirSurface::position() const { return m_position; }
+
+void FakeMirSurface::setPosition(const QPoint position)
+{
+    if (m_position != position) {
+        m_position = position;
+        Q_EMIT positionChanged(position);
+    }
+}
+
 void FakeMirSurface::resize(int width, int height)
 {
     if (m_size.width() != width || m_size.height() != height) {

=== modified file 'miral-qt/tests/framework/fake_mirsurface.h'
--- miral-qt/tests/framework/fake_mirsurface.h	2016-07-26 12:45:17 +0000
+++ miral-qt/tests/framework/fake_mirsurface.h	2016-07-27 16:52:34 +0000
@@ -54,6 +54,8 @@
     Mir::Type type() const override;
     QString name() const override;
     QSize size() const override;
+    QPoint position() const override;
+    void setPosition(const QPoint position) override;
     void resize(int width, int height) override;
     void resize(const QSize &size) override;
     Mir::State state() const override;
@@ -171,6 +173,7 @@
     Mir::OrientationAngle m_orientationAngle;
     bool m_visible;
     QSize m_size;
+    QPoint m_position;
     QHash<int, bool> m_views;
     bool m_focused;
 

=== modified file 'miral-qt/tests/mirserver/ScreensModel/screensmodel_test.cpp'
--- miral-qt/tests/mirserver/ScreensModel/screensmodel_test.cpp	2016-06-21 13:38:53 +0000
+++ miral-qt/tests/mirserver/ScreensModel/screensmodel_test.cpp	2016-07-27 16:52:34 +0000
@@ -40,6 +40,7 @@
 
     ScreensModel *screensModel;
     std::shared_ptr<StubDisplay> display;
+    std::shared_ptr<StubDisplayListener> displayListener;
     std::shared_ptr<QtCompositor> compositor;
     QGuiApplication *app;
 };
@@ -51,9 +52,10 @@
 
     screensModel = new TestableScreensModel;
     display = std::make_shared<StubDisplay>();
+    displayListener = std::make_shared<StubDisplayListener>();
     compositor = std::make_shared<QtCompositor>();
 
-    static_cast<TestableScreensModel*>(screensModel)->do_init(display, compositor);
+    static_cast<TestableScreensModel*>(screensModel)->do_init(display, compositor, displayListener);
 
     int argc = 0;
     char **argv = nullptr;

=== modified file 'miral-qt/tests/mirserver/ScreensModel/stub_display.h'
--- miral-qt/tests/mirserver/ScreensModel/stub_display.h	2016-06-01 22:06:51 +0000
+++ miral-qt/tests/mirserver/ScreensModel/stub_display.h	2016-07-27 16:52:34 +0000
@@ -21,6 +21,8 @@
 #include "mock_gl_display_buffer.h"
 #include "mock_display_configuration.h"
 
+#include <mir/compositor/display_listener.h>
+
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 
@@ -99,4 +101,11 @@
     std::vector<MockGLDisplayBuffer*> m_displayBuffers;
 };
 
+class StubDisplayListener : public mir::compositor::DisplayListener
+{
+    void add_display(mir::geometry::Rectangle const& /*area*/) override {};
+
+    void remove_display(mir::geometry::Rectangle const& /*area*/) override {};
+};
+
 #endif // STUB_DISPLAY_H

=== modified file 'miral-qt/tests/mirserver/ScreensModel/testable_screensmodel.h'
--- miral-qt/tests/mirserver/ScreensModel/testable_screensmodel.h	2016-06-01 22:06:51 +0000
+++ miral-qt/tests/mirserver/ScreensModel/testable_screensmodel.h	2016-07-27 16:52:34 +0000
@@ -28,9 +28,10 @@
     }
 
     void do_init(const std::shared_ptr<mir::graphics::Display> &display,
-                 const std::shared_ptr<mir::compositor::Compositor> &compositor)
+                 const std::shared_ptr<mir::compositor::Compositor> &compositor,
+                 const std::shared_ptr<mir::compositor::DisplayListener> &displayListener)
     {
-        init(display, compositor);
+        init(display, compositor, displayListener);
     }
 
     void do_terminate() { terminate(); }