Merge lp:~gerboland/miral/add-interactivity-to-WM into lp:miral

[Gerry Boland]

[miral-qt] Refactor out MirSurfaceManager and replace with qtmir::WindowModel. Add WindowController which enables window move & resize.

- MirSurfaceManager managed lifetimes of MirSurfaces. With MirAL, this responsibility must move to the WindowModel. Will fully remove MirSurfaceManager in a later MP (commented out for now).
- WindowController allows shell to control the window manager
- MirSurface refactored to wrap miral::WindowInfo which has nearly all the info it needs, and given access to the WindowController.
- redid the signal/slot interface between mirserver::WindowModel and qtmir::WindowModel to reduce the amount of traffic and better reflect the miral API.
- mir::shell::Shell no longer exported in the top-level MirServer class.

[Alan Griffiths (alan-griffiths)]

With Vivid+Overlay/clang I need:

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-function"
Q_DECLARE_OPERATORS_FOR_FLAGS(DirtyStates)
#pragma clang diagnostic pop

[Alan Griffiths (alan-griffiths)]

/home/alan/display_server/miral/miral-qt/tests/modules/Application/application_test.cpp:287:35: error: allocating an object of abstract class type 'qtmir::FakeMirSurface'
    FakeMirSurface *surface = new FakeMirSurface;
                                  ^
/home/alan/display_server/miral/miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h:52:18: note: unimplemented pure virtual method 'requestPosition' in 'FakeMirSurface'
    virtual void requestPosition(const QPoint newPosition) = 0;
                 ^
/home/alan/display_server/miral/miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h:121:18: note: unimplemented pure virtual method 'setShellChrome' in 'FakeMirSurface'
    virtual void setShellChrome(Mir::ShellChrome shellChrome) = 0;
                 ^

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

Possibly not new with this MP, but after starting "qml-demo-shell --x11-displays 648x480" and running mir_demo_client_egltriangle to try move/resize the server crashed when I closed the client.

[Gerry Boland (gerboland)]

That's what I get for leaving NO_TESTS=1 set!

I've made whatever tests that should be workable compile - they fail still. Other tests I've not updated until the functionality they rely on has been restored.

On your crash find, I cannot reproduce it here. Could you grab me a backtrace?

[Alan Griffiths (alan-griffiths)]

Crash seems fairly consistent. If it matters, this is g++/yakkety:

Program terminated with signal SIGSEGV, Segmentation fault.
#0 0x00007fdbe02508fb in qtmir::MirSurface::updateTexture (this=0x55d46b5f13a0)
    at /home/alan/display_server/miral0/miral-qt/src/modules/Unity/Application/mirsurface.cpp:406
406 auto renderables = window->generate_renderables(userId);
[Current thread is 1 (Thread 0x7fdbce4d5700 (LWP 9694))]
(gdb) bt
#0 0x00007fdbe02508fb in qtmir::MirSurface::updateTexture (this=0x55d46b5f13a0)
    at /home/alan/display_server/miral0/miral-qt/src/modules/Unity/Application/mirsurface.cpp:406
#1 0x00007fdbe025bf81 in qtmir::MirSurfaceItem::updatePaintNode (
    this=0x55d46b418ac0, oldNode=0x7fdbc4569bd0)
    at /home/alan/display_server/miral0/miral-qt/src/modules/Unity/Application/mirsurfaceitem.cpp:226
#2 0x00007fdc011132c8 in QQuickWindowPrivate::updateDirtyNode(QQuickItem*) ()
   from /usr/lib/x86_64-linux-gnu/libQt5Quick.so.5
#3 0x00007fdc01113b3b in QQuickWindowPrivate::updateDirtyNodes() ()
   from /usr/lib/x86_64-linux-gnu/libQt5Quick.so.5
#4 0x00007fdc01113cb0 in QQuickWindowPrivate::syncSceneGraph() ()
   from /usr/lib/x86_64-linux-gnu/libQt5Quick.so.5
#5 0x00007fdc010e4d53 in ?? () from /usr/lib/x86_64-linux-gnu/libQt5Quick.so.5
#6 0x00007fdc010e5f95 in ?? () from /usr/lib/x86_64-linux-gnu/libQt5Quick.so.5
#7 0x00007fdc010eb07c in ?? () from /usr/lib/x86_64-linux-gnu/libQt5Quick.so.5
#8 0x00007fdc001d77be in ?? () from /usr/lib/x86_64-linux-gnu/libQt5Core.so.5
#9 0x00007fdbff2ab70a in start_thread (arg=0x7fdbce4d5700) at pthread_create.c:333
#10 0x00007fdbff8d06ad in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:109

[Alan Griffiths (alan-griffiths)]

On balance I think it better to land this "wiring" than to try to perfect it first.

~~~~

+#include "miral/window_info.h"

Once MirAL supports everything we need we intend to separate the Qt use of MirAL from the project. So I'd be inclined to use <> includes for miral headers.

~~~~

I see this a few times: "static_cast<std::shared_ptr<mir::scene::Surface>>(m_windowInfo.window);" but I don't see why you use the cast operator. Ideally we don't want Qt to use mir::xxx::Yyy, so is this just a tag to review later?

review: Approve

[Alan Griffiths (alan-griffiths)]

> With Vivid+Overlay/clang I need:
>
> #pragma clang diagnostic push
> #pragma clang diagnostic ignored "-Wunused-function"
> Q_DECLARE_OPERATORS_FOR_FLAGS(DirtyStates)
> #pragma clang diagnostic pop

Oh g++ errors on these. We need something like:

#if defined(__clang__)

review: Needs Fixing

[lp:~gerboland/miral/add-interactivity-to-WM]

266. By Gerry Boland on 2016-08-12

ifdef the clang workaround

[Gerry Boland (gerboland)]

Done. Your g++/clang++ are more fussy than mine on xenial!

[Alan Griffiths (alan-griffiths)]

+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-function"
+Q_DECLARE_OPERATORS_FOR_FLAGS(DirtyStates)
+#pragma clang diagnostic pop
+#endif

Do you really mean we only need Q_DECLARE_OPERATORS_FOR_FLAGS() with clang? Maybe we just don't need it?

review: Needs Fixing

[lp:~gerboland/miral/add-interactivity-to-WM]

267. By Gerry Boland on 2016-08-12

The | operator for QFlags not actually needed - yet! Remove, add back only when I need it

[Gerry Boland (gerboland)]

> +#if defined(__clang__)
> +#pragma clang diagnostic push
> +#pragma clang diagnostic ignored "-Wunused-function"
> +Q_DECLARE_OPERATORS_FOR_FLAGS(DirtyStates)
> +#pragma clang diagnostic pop
> +#endif
>
> Do you really mean we only need Q_DECLARE_OPERATORS_FOR_FLAGS() with clang?
> Maybe we just don't need it?

Quite right, it's not needed until I start combining flags with the | operator. I've removed it entirely

[Alan Griffiths (alan-griffiths)]

There's an orphaned comment but WTF

review: Approve

[lp:~gerboland/miral/add-interactivity-to-WM]

268. By Gerry Boland on 2016-08-12

remove defunkt comment

=== modified file 'miral-qt/demos/qml-demo-shell/windowModel.qml'
--- miral-qt/demos/qml-demo-shell/windowModel.qml	2016-07-27 12:37:01 +0000
+++ miral-qt/demos/qml-demo-shell/windowModel.qml	2016-08-12 12:04:26 +0000
@@ -2,37 +2,116 @@
 import Unity.Application 0.1
 
 FocusScope {
+    id: root
     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
-                }
-            }
+    Item {
+        id: windowViewContainer
+        anchors.fill: parent
+
+        Repeater {
+            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
+                    }
+                }
+            }
+        }
+    }
+
+    Button {
+        anchors { right: parent.right; bottom: parent.bottom }
+        height: 30
+        width: 80
+        text: "Quit"
+        onClicked: Qt.quit()
+    }
+
+    Text {
+        anchors { left: parent.left; bottom: parent.bottom }
+        text: "Move window: Ctrl+click\n
+Resize window: Ctrl+Right click"
+    }
+
+    MouseArea {
+        anchors.fill: parent
+        acceptedButtons: Qt.LeftButton | Qt.RightButton
+        property variant window: null
+        property int initialWindowXPosition
+        property int initialWindowYPosition
+        property int initialWindowWidth
+        property int initialWindowHeight
+        property int initialMouseXPosition
+        property int initialMouseYPosition
+        property var action
+
+        function moveWindowBy(window, delta) {
+            window.surface.requestPosition(Qt.point(initialWindowXPosition + delta.x,
+                                                    initialWindowYPosition + delta.y))
+        }
+        function resizeWindowBy(window, delta) {
+            window.surface.resize(Qt.size(initialWindowWidth + delta.x,
+                                          initialWindowHeight + delta.y))
+        }
+
+        onPressed: {
+            if (mouse.modifiers & Qt.ControlModifier) {
+                window = windowViewContainer.childAt(mouse.x, mouse.y)
+                if (!window) return;
+
+                if (mouse.button == Qt.LeftButton) {
+                    initialWindowXPosition = window.surface.position.x
+                    initialWindowYPosition = window.surface.position.y
+                    action = moveWindowBy
+                } else if (mouse.button == Qt.RightButton) {
+                    initialWindowHeight = window.surface.size.height
+                    initialWindowWidth = window.surface.size.width
+                    action = resizeWindowBy
+                }
+                initialMouseXPosition = mouse.x
+                initialMouseYPosition = mouse.y
+            } else {
+                mouse.accepted = false
+            }
+        }
+
+        onPositionChanged: {
+            if (!window) {
+                mouse.accepted = false
+                return
+            }
+            action(window, Qt.point(mouse.x - initialMouseXPosition, mouse.y - initialMouseYPosition))
+        }
+
+        onReleased: {
+            if (!window) {
+                mouse.accepted = false
+                return
+            }
+            action(window, Qt.point(mouse.x - initialMouseXPosition, mouse.y - initialMouseYPosition))
+            window = null;
         }
     }
 }
 
=== added file 'miral-qt/src/common/windowcontrollerinterface.h'
--- miral-qt/src/common/windowcontrollerinterface.h	1970-01-01 00:00:00 +0000
+++ miral-qt/src/common/windowcontrollerinterface.h	2016-08-12 12:04:26 +0000
@@ -0,0 +1,53 @@
+/*
+ * 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 WINDOWCONTROLLERINTERFACE_H
+#define WINDOWCONTROLLERINTERFACE_H
+
+#include "miral/window.h"
+
+#include "mir_toolkit/event.h"
+
+#include <QPoint>
+#include <QSize>
+
+namespace qtmir {
+
+class MirSurface;
+
+class WindowControllerInterface {
+public:
+    WindowControllerInterface() = default;
+    virtual ~WindowControllerInterface() = default;
+
+    // focus() asks Mir to bring particular window to the front and recommend to shell that it be focused
+    virtual void focus (const miral::Window &window) = 0;
+    // setActiveFocus() is how shell notifies Mir/application that a window actually has input focus
+    virtual void setActiveFocus(const miral::Window &window, const bool activeFocus) = 0;
+
+    virtual void resize(const miral::Window &window, const QSize &size) = 0;
+    virtual void move  (const miral::Window &window, const QPoint &topLeft) = 0;
+
+    virtual void setState(const miral::Window &window, const MirSurfaceState state) = 0;
+
+    virtual void deliverKeyboardEvent(const miral::Window &window, const MirKeyboardEvent *event) = 0;
+    virtual void deliverTouchEvent   (const miral::Window &window, const MirTouchEvent *event) = 0;
+    virtual void deliverPointerEvent (const miral::Window &window, const MirPointerEvent *event) = 0;
+};
+
+} // namespace qtmir
+
+#endif // WINDOWCONTROLLERINTERFACE_H
 
=== modified file 'miral-qt/src/common/windowmodelinterface.h'
--- miral-qt/src/common/windowmodelinterface.h	2016-07-27 17:41:48 +0000
+++ miral-qt/src/common/windowmodelinterface.h	2016-08-12 12:04:26 +0000
@@ -22,35 +22,39 @@
 #include <QPoint>
 #include <QVector>
 
-#include <mir/scene/surface.h>
+#include "miral/window_info.h"
 
 namespace qtmir {
 
-// miral::WindowInfo contains all the metadata the WindowManager{,Policy} needs. However the
-// WindowModel only needs a read-only subset of this data, which is what the struct is for.
-struct WindowInfo {
-    QSize size;
-    QPoint position;
-    bool focused;
-    const std::shared_ptr<mir::scene::Surface> surface;
-
-    enum class DirtyStates {
-        Size = 1,
-        Position = 2,
-        Focus = 4
-    };
-};
-
-// We assign each Window with an index which corresponds to the position it has in the window stack.
-struct NumberedWindow {
-    unsigned int index;
-    WindowInfo windowInfo;
-};
-
-struct DirtiedWindow {
-    unsigned int index;
-    WindowInfo windowInfo;
-    WindowInfo::DirtyStates dirtyWindowInfo;
+// miral::WindowInfo missing a default constructor, needed by MOC. Need to wrap it instead
+class WindowInfo {
+public:
+    WindowInfo() = default;
+    WindowInfo(const miral::WindowInfo &windowInfo)
+      : window(windowInfo.window())
+      , name(windowInfo.name())
+      , type(windowInfo.type())
+      , state(windowInfo.state())
+      , restoreRect(windowInfo.restore_rect())
+      , parent(windowInfo.parent())
+      , children(windowInfo.children())
+      , minWidth(windowInfo.min_width())
+      , minHeight(windowInfo.min_height())
+      , maxWidth(windowInfo.max_width())
+      , maxHeight(windowInfo.max_height())
+    {}
+
+    miral::Window window;
+    mir::optional_value<std::string> name;
+    MirSurfaceType type;
+    MirSurfaceState state;
+    mir::geometry::Rectangle restoreRect;
+    miral::Window parent;
+    std::vector<miral::Window> children;
+    mir::geometry::Width minWidth;
+    mir::geometry::Height minHeight;
+    mir::geometry::Width maxWidth;
+    mir::geometry::Height maxHeight;
 };
 
 
@@ -62,9 +66,12 @@
     virtual ~WindowModelInterface() = default;
 
 Q_SIGNALS:
-    void windowAdded(const qtmir::NumberedWindow);
+    void windowAdded(const qtmir::WindowInfo, const unsigned int index);
     void windowRemoved(const unsigned int index);
-    void windowChanged(const qtmir::DirtiedWindow);
+    void windowMoved(const QPoint topLeft, const unsigned int index);
+    void windowResized(const QSize size, const unsigned int index);
+    void windowFocused(const unsigned int index);
+    void windowInfoChanged(const qtmir::WindowInfo, const unsigned int index);
 
 private:
     Q_DISABLE_COPY(WindowModelInterface)
@@ -72,7 +79,6 @@
 
 } // namespace qtmir
 
-Q_DECLARE_METATYPE(qtmir::NumberedWindow)
-Q_DECLARE_METATYPE(qtmir::DirtiedWindow)
+Q_DECLARE_METATYPE(qtmir::WindowInfo)
 
 #endif // WINDOWMODELINTERFACE_H
 
=== modified file 'miral-qt/src/modules/Unity/Application/mirsurface.cpp'
--- miral-qt/src/modules/Unity/Application/mirsurface.cpp	2016-07-27 12:42:21 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurface.cpp	2016-08-12 12:04:26 +0000
@@ -177,34 +177,38 @@
     return ev;
 }
 
+enum class DirtyState {
+    Clean = 0,
+    Name = 1 << 1,
+    Type = 1 << 2,
+    State = 1 << 3,
+    RestoreRect = 1 << 4,
+    Children = 1 << 5,
+    MinSize = 1 << 6,
+    MaxSize = 1 << 7,
+};
+Q_DECLARE_FLAGS(DirtyStates, DirtyState)
+
 } // namespace {
 
-MirSurface::MirSurface(std::shared_ptr<mir::scene::Surface> surface,
-        SessionInterface* session,
-        mir::shell::Shell* shell,
-        std::shared_ptr<SurfaceObserver> observer,
-        const CreationHints &creationHints)
+MirSurface::MirSurface(WindowInfo windowInfo,
+        WindowControllerInterface* controller,
+        std::shared_ptr<SurfaceObserver> observer)
     : MirSurfaceInterface()
-    , m_surface(surface)
-    , m_session(session)
-    , m_shell(shell)
+    , m_windowInfo(windowInfo)
+    , m_controller(controller)
     , m_firstFrameDrawn(false)
     , m_orientationAngle(Mir::Angle0)
     , m_textureUpdated(false)
     , m_currentFrameNumber(0)
     , m_live(true)
+    , m_position(toQPoint(windowInfo.window.top_left()))
+    , m_size(toQSize(windowInfo.window.size()))
     , m_shellChrome(Mir::NormalChrome)
 {
     DEBUG_MSG << "()";
 
-    m_position = toQPoint(surface->top_left());
-    m_minimumWidth = creationHints.minWidth;
-    m_minimumHeight = creationHints.minHeight;
-    m_maximumWidth = creationHints.maxWidth;
-    m_maximumHeight = creationHints.maxHeight;
-    m_widthIncrement = creationHints.widthIncrement;
-    m_heightIncrement = creationHints.heightIncrement;
-    m_shellChrome = creationHints.shellChrome;
+    //m_shellChrome = creationHints.shellChrome; TODO - where will this come from now?
 
     m_surfaceObserver = observer;
     if (observer) {
@@ -212,12 +216,6 @@
         connect(observer.get(), &SurfaceObserver::attributeChanged, this, &MirSurface::onAttributeChanged);
         connect(observer.get(), &SurfaceObserver::nameChanged, this, &MirSurface::nameChanged);
         connect(observer.get(), &SurfaceObserver::cursorChanged, this, &MirSurface::setCursor);
-        connect(observer.get(), &SurfaceObserver::minimumWidthChanged, this, &MirSurface::setMinimumWidth);
-        connect(observer.get(), &SurfaceObserver::minimumHeightChanged, this, &MirSurface::setMinimumHeight);
-        connect(observer.get(), &SurfaceObserver::maximumWidthChanged, this, &MirSurface::setMaximumWidth);
-        connect(observer.get(), &SurfaceObserver::maximumHeightChanged, this, &MirSurface::setMaximumHeight);
-        connect(observer.get(), &SurfaceObserver::widthIncrementChanged, this, &MirSurface::setWidthIncrement);
-        connect(observer.get(), &SurfaceObserver::heightIncrementChanged, this, &MirSurface::setHeightIncrement);
         connect(observer.get(), &SurfaceObserver::shellChromeChanged, this, [&](MirShellChrome shell_chrome) {
             setShellChrome(static_cast<Mir::ShellChrome>(shell_chrome));
         });
@@ -225,7 +223,7 @@
         observer->setListener(this);
     }
 
-    connect(session, &QObject::destroyed, this, &MirSurface::onSessionDestroyed);
+    //connect(session, &QObject::destroyed, this, &MirSurface::onSessionDestroyed); // TODO try using Shared pointer for lifecycle
 
     connect(&m_frameDropperTimer, &QTimer::timeout,
             this, &MirSurface::dropPendingBuffer);
@@ -256,7 +254,8 @@
     Q_ASSERT(m_views.isEmpty());
 
     QMutexLocker locker(&m_mutex);
-    m_surface->remove_observer(m_surfaceObserver);
+//    auto const &window = static_cast<std::shared_ptr<mir::scene::Surface>>(m_windowInfo.window);
+//    window->remove_observer(m_surfaceObserver); // FIXME - window null at this stage!
 
     delete m_closeTimer;
 
@@ -298,7 +297,7 @@
 
 Mir::Type MirSurface::type() const
 {
-    switch (m_surface->type()) {
+    switch (m_windowInfo.type) {
     case mir_surface_type_normal:
         return Mir::NormalType;
 
@@ -337,7 +336,8 @@
 
     const void* const userId = (void*)123;  // TODO: Multimonitor support
 
-    int framesPending = m_surface->buffers_ready_for_compositor(userId);
+    auto const &window = static_cast<std::shared_ptr<mir::scene::Surface>>(m_windowInfo.window);
+    int framesPending = window->buffers_ready_for_compositor(userId);
     if (framesPending > 0) {
         m_textureUpdated = false;
 
@@ -398,10 +398,11 @@
     }
 
     const void* const userId = (void*)123;
-    auto renderables = m_surface->generate_renderables(userId);
+    auto const &window = static_cast<std::shared_ptr<mir::scene::Surface>>(m_windowInfo.window);
+    auto renderables = window->generate_renderables(userId);
 
     if (renderables.size() > 0 &&
-            (m_surface->buffers_ready_for_compositor(userId) > 0 || !texture->hasBuffer())
+            (window->buffers_ready_for_compositor(userId) > 0 || !texture->hasBuffer())
         ) {
         // Avoid holding two buffers for the compositor at the same time. Thus free the current
         // before acquiring the next
@@ -409,7 +410,7 @@
         texture->setBuffer(renderables[0]->buffer());
         ++m_currentFrameNumber;
 
-        if (texture->textureSize() != m_size) {
+        if (texture->textureSize() != size()) {
             m_size = texture->textureSize();
             QMetaObject::invokeMethod(this, "emitSizeChanged", Qt::QueuedConnection);
         }
@@ -417,7 +418,7 @@
         m_textureUpdated = true;
     }
 
-    if (m_surface->buffers_ready_for_compositor(userId) > 0) {
+    if (window->buffers_ready_for_compositor(userId) > 0) {
         // restart the frame dropper to give MirSurfaceItems enough time to render the next frame.
         // queued since the timer lives in a different thread
         QMetaObject::invokeMethod(&m_frameDropperTimer, "start", Qt::QueuedConnection);
@@ -436,7 +437,8 @@
 {
     QMutexLocker locker(&m_mutex);
     const void* const userId = (void*)123;
-    return m_surface->buffers_ready_for_compositor(userId);
+    auto const &window = static_cast<std::shared_ptr<mir::scene::Surface>>(m_windowInfo.window);
+    return window->buffers_ready_for_compositor(userId);
 }
 
 void MirSurface::setFocused(bool value)
@@ -479,10 +481,10 @@
 
     if (m_activelyFocusedViews.isEmpty()) {
         DEBUG_MSG << "() unfocused";
-        m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_focus, mir_surface_unfocused);
+        m_controller->setActiveFocus(m_windowInfo.window, false);
     } else {
         DEBUG_MSG << "() focused";
-        m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_focus, mir_surface_focused);
+        m_controller->setActiveFocus(m_windowInfo.window, true);
     }
 
     m_neverSetSurfaceFocus = false;
@@ -500,22 +502,21 @@
     Q_EMIT closeRequested();
     m_closeTimer->start();
 
-    if (m_surface) {
-        m_surface->request_client_surface_close();
+    if (m_windowInfo.window) {
+        auto const &window = static_cast<std::shared_ptr<mir::scene::Surface>>(m_windowInfo.window);
+        window->request_client_surface_close();
     }
 }
 
 void MirSurface::resize(int width, int height)
 {
-    int mirWidth = m_surface->size().width.as_int();
-    int mirHeight = m_surface->size().height.as_int();
+    auto const &window = m_windowInfo.window;
 
-    bool mirSizeIsDifferent = width != mirWidth || height != mirHeight;
+    bool mirSizeIsDifferent = width != m_size.width() || height != m_size.height();
 
     if (clientIsRunning() && mirSizeIsDifferent) {
-        mir::geometry::Size newMirSize(width, height);
-        m_surface->resize(newMirSize);
-        DEBUG_MSG << " old (" << mirWidth << "," << mirHeight << ")"
+        m_controller->resize(window, QSize(width, height));
+        DEBUG_MSG << " old (" << m_size.width() << "," << m_size.height() << ")"
                   << ", new (" << width << "," << height << ")";
     }
 }
@@ -525,6 +526,27 @@
     return m_position;
 }
 
+void MirSurface::setPosition(const QPoint newPosition)
+{
+    if (m_position != newPosition) {
+        m_position = newPosition;
+        Q_EMIT positionChanged(newPosition);
+    }
+}
+
+void MirSurface::requestPosition(const QPoint newPosition)
+{
+    m_controller->move(m_windowInfo.window, newPosition);
+}
+
+void MirSurface::setSize(const QSize newSize)
+{
+    if (m_size != newSize) {
+        m_size = newSize;
+        Q_EMIT sizeChanged(newSize);
+    }
+}
+
 QSize MirSurface::size() const
 {
     return m_size;
@@ -532,7 +554,7 @@
 
 Mir::State MirSurface::state() const
 {
-    switch (m_surface->state()) {
+    switch (m_windowInfo.state) {
     case mir_surface_state_unknown:
         return Mir::UnknownState;
     case mir_surface_state_restored:
@@ -587,8 +609,9 @@
         return;
     }
 
-    if (m_surface) {
-        m_surface->set_orientation(mirOrientation);
+    if (m_windowInfo.window) {
+        auto const &window = static_cast<std::shared_ptr<mir::scene::Surface>>(m_windowInfo.window);
+        window->set_orientation(mirOrientation);
     }
 
     Q_EMIT orientationAngleChanged(angle);
@@ -596,12 +619,15 @@
 
 QString MirSurface::name() const
 {
-    return QString::fromStdString(m_surface->name());
+    if (!m_windowInfo.name.is_set()) {
+        return QStringLiteral();
+    }
+    return QString::fromStdString(m_windowInfo.name.value());
 }
 
 void MirSurface::setState(Mir::State qmlState)
 {
-    int mirState;
+    MirSurfaceState mirState;
 
     switch (qmlState) {
     default:
@@ -638,7 +664,7 @@
         break;
     }
 
-    m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_state, mirState);
+    m_controller->setState(m_windowInfo.window, mirState);
 }
 
 void MirSurface::setLive(bool value)
@@ -660,69 +686,79 @@
 
 bool MirSurface::visible() const
 {
-    return m_surface->query(mir_surface_attrib_visibility) == mir_surface_visibility_exposed;
+    //return m_windowInfo->query(mir_surface_attrib_visibility) == mir_surface_visibility_exposed;
+    return true; //FIXME
 }
-
+#include <mir_toolkit/event.h>
 void MirSurface::mousePressEvent(QMouseEvent *event)
 {
     auto ev = makeMirEvent(event, mir_pointer_action_button_down);
-    m_surface->consume(ev.get());
+    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
+    m_controller->deliverPointerEvent(m_windowInfo.window, ev1);
     event->accept();
 }
 
 void MirSurface::mouseMoveEvent(QMouseEvent *event)
 {
     auto ev = makeMirEvent(event, mir_pointer_action_motion);
-    m_surface->consume(ev.get());
+    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
+    m_controller->deliverPointerEvent(m_windowInfo.window, ev1);
     event->accept();
 }
 
 void MirSurface::mouseReleaseEvent(QMouseEvent *event)
 {
     auto ev = makeMirEvent(event, mir_pointer_action_button_up);
-    m_surface->consume(ev.get());
+    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
+    m_controller->deliverPointerEvent(m_windowInfo.window, ev1);
     event->accept();
 }
 
 void MirSurface::hoverEnterEvent(QHoverEvent *event)
 {
     auto ev = makeMirEvent(event, mir_pointer_action_enter);
-    m_surface->consume(ev.get());
+    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
+    m_controller->deliverPointerEvent(m_windowInfo.window, ev1);
     event->accept();
 }
 
 void MirSurface::hoverLeaveEvent(QHoverEvent *event)
 {
     auto ev = makeMirEvent(event, mir_pointer_action_leave);
-    m_surface->consume(ev.get());
+    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
+    m_controller->deliverPointerEvent(m_windowInfo.window, ev1);
     event->accept();
 }
 
 void MirSurface::hoverMoveEvent(QHoverEvent *event)
 {
     auto ev = makeMirEvent(event, mir_pointer_action_motion);
-    m_surface->consume(ev.get());
+    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
+    m_controller->deliverPointerEvent(m_windowInfo.window, ev1);
     event->accept();
 }
 
 void MirSurface::wheelEvent(QWheelEvent *event)
 {
     auto ev = makeMirEvent(event);
-    m_surface->consume(ev.get());
+    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
+    m_controller->deliverPointerEvent(m_windowInfo.window, ev1);
     event->accept();
 }
 
 void MirSurface::keyPressEvent(QKeyEvent *qtEvent)
 {
     auto ev = makeMirEvent(qtEvent);
-    m_surface->consume(ev.get());
+    auto ev1 = reinterpret_cast<MirKeyboardEvent const*>(ev.get());
+    m_controller->deliverKeyboardEvent(m_windowInfo.window, ev1);
     qtEvent->accept();
 }
 
 void MirSurface::keyReleaseEvent(QKeyEvent *qtEvent)
 {
     auto ev = makeMirEvent(qtEvent);
-    m_surface->consume(ev.get());
+    auto ev1 = reinterpret_cast<MirKeyboardEvent const*>(ev.get());
+    m_controller->deliverKeyboardEvent(m_windowInfo.window, ev1);
     qtEvent->accept();
 }
 
@@ -732,7 +768,8 @@
                             ulong timestamp)
 {
     auto ev = makeMirEvent(mods, touchPoints, touchPointStates, timestamp);
-    m_surface->consume(ev.get());
+    auto ev1 = reinterpret_cast<MirTouchEvent const*>(ev.get());
+    m_controller->deliverTouchEvent(m_windowInfo.window, ev1);
 }
 
 bool MirSurface::clientIsRunning() const
@@ -865,7 +902,9 @@
         return;
     }
 
-    m_surface->set_keymap(MirInputDeviceId(), "", layout.toStdString(), variant.toStdString(), "");
+    auto const &window = static_cast<std::shared_ptr<mir::scene::Surface>>(m_windowInfo.window);
+
+    window->set_keymap(MirInputDeviceId(), "", layout.toStdString(), variant.toStdString(), "");
 }
 
 QCursor MirSurface::cursor() const
@@ -905,6 +944,52 @@
     return result;
 }
 
+void MirSurface::updateWindowInfo(const WindowInfo &windowInfo)
+{
+    qDebug() << "MirSurface::updateWindowInfo";
+    // Need to compare the new windowInfo instance with the existing one to figure out what changed
+    DirtyStates dirt = DirtyState::Clean;
+
+    if (windowInfo.name != m_windowInfo.name) {
+        dirt &= DirtyState::Name; qDebug("Name changed");
+    }
+    if (windowInfo.type != m_windowInfo.type) {
+        dirt &= DirtyState::Type; qDebug("Type changed");
+    }
+    if (windowInfo.state != m_windowInfo.state) {
+        dirt &= DirtyState::State; qDebug("State changed");
+    }
+    if (windowInfo.restoreRect != m_windowInfo.restoreRect) {
+        dirt &= DirtyState::RestoreRect; qDebug("RestoreRect changed");
+    }
+    if (windowInfo.children != m_windowInfo.children) {
+        dirt &= DirtyState::Children; qDebug("Children changed");
+    }
+    if (windowInfo.minWidth != m_windowInfo.minWidth
+            && windowInfo.minHeight != m_windowInfo.minHeight) {
+        dirt &= DirtyState::MinSize; qDebug("MinSize changed");
+    }
+    if (windowInfo.maxWidth != m_windowInfo.maxWidth
+            && windowInfo.maxHeight != m_windowInfo.maxHeight) {
+        dirt &= DirtyState::MaxSize; qDebug("MaxHeight changed");
+    }
+
+    if (dirt | DirtyState::Clean) {
+        return;
+    }
+    m_windowInfo = windowInfo;
+
+    if (dirt | DirtyState::Name) {
+        Q_EMIT nameChanged(name());
+    }
+    if (dirt | DirtyState::Type) {
+        Q_EMIT typeChanged(type());
+    }
+    if (dirt | DirtyState::State) {
+        Q_EMIT stateChanged(state());
+    }
+}
+
 void MirSurface::setCursor(const QCursor &cursor)
 {
     DEBUG_MSG << "(" << qtCursorShapeToStr(cursor.shape()) << ")";
@@ -915,80 +1000,32 @@
 
 int MirSurface::minimumWidth() const
 {
-    return m_minimumWidth;
+    return m_windowInfo.minWidth.as_int();
 }
 
 int MirSurface::minimumHeight() const
 {
-    return m_minimumHeight;
+    return m_windowInfo.minHeight.as_int();
 }
 
 int MirSurface::maximumWidth() const
 {
-    return m_maximumWidth;
+    return m_windowInfo.maxWidth.as_int();
 }
 
 int MirSurface::maximumHeight() const
 {
-    return m_maximumHeight;
+    return m_windowInfo.maxHeight.as_int();
 }
 
 int MirSurface::widthIncrement() const
 {
-    return m_widthIncrement;
+    return 0; //TODO
 }
 
 int MirSurface::heightIncrement() const
 {
-    return m_heightIncrement;
-}
-
-void MirSurface::setMinimumWidth(int value)
-{
-    if (value != m_minimumWidth) {
-        m_minimumWidth = value;
-        Q_EMIT minimumWidthChanged(value);
-    }
-}
-
-void MirSurface::setMinimumHeight(int value)
-{
-    if (value != m_minimumHeight) {
-        m_minimumHeight = value;
-        Q_EMIT minimumHeightChanged(value);
-    }
-}
-
-void MirSurface::setMaximumWidth(int value)
-{
-    if (value != m_maximumWidth) {
-        m_maximumWidth = value;
-        Q_EMIT maximumWidthChanged(value);
-    }
-}
-
-void MirSurface::setMaximumHeight(int value)
-{
-    if (value != m_maximumHeight) {
-        m_maximumHeight = value;
-        Q_EMIT maximumHeightChanged(value);
-    }
-}
-
-void MirSurface::setWidthIncrement(int value)
-{
-    if (value != m_widthIncrement) {
-        m_widthIncrement = value;
-        Q_EMIT widthIncrementChanged(value);
-    }
-}
-
-void MirSurface::setHeightIncrement(int value)
-{
-    if (value != m_heightIncrement) {
-        m_heightIncrement = value;
-        Q_EMIT heightIncrementChanged(value);
-    }
+    return 0; //TODO
 }
 
 bool MirSurface::focused() const
@@ -1021,16 +1058,7 @@
 
     m_closingState = CloseOverdue;
 
-    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);
+    //m_session->session()->destroy_surface(m_windowInfo); TODO use WindowManagerTools::ask_client_to_close(window)
 }
 
 void MirSurface::setCloseTimer(AbstractTimer *timer)
 
=== modified file 'miral-qt/src/modules/Unity/Application/mirsurface.h'
--- miral-qt/src/modules/Unity/Application/mirsurface.h	2016-07-27 12:05:20 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurface.h	2016-08-12 12:04:26 +0000
@@ -31,17 +31,11 @@
 
 #include "mirbuffersgtexture.h"
 #include "session.h"
-
-// mirserver
-#include "creationhints.h"
-
+#include "windowcontrollerinterface.h"
+#include "windowmodelinterface.h"
 // mir
 #include <mir_toolkit/common.h>
 
-namespace mir {
-namespace shell { class Shell; }
-namespace scene {class Surface; }
-}
 
 class SurfaceObserver;
 
@@ -54,11 +48,9 @@
     Q_OBJECT
 
 public:
-    MirSurface(std::shared_ptr<mir::scene::Surface> surface,
-            SessionInterface* session,
-            mir::shell::Shell *shell,
-            std::shared_ptr<SurfaceObserver> observer,
-            const CreationHints &);
+    MirSurface(WindowInfo windowInfo,
+               WindowControllerInterface *controller,
+               std::shared_ptr<SurfaceObserver> observer);
     virtual ~MirSurface();
 
     ////
@@ -70,10 +62,10 @@
 
     QSize size() const override;
     void resize(int width, int height) override;
-    void resize(const QSize &size) override { resize(size.width(), size.height()); }
+    Q_INVOKABLE void resize(const QSize &size) override { resize(size.width(), size.height()); }
 
     QPoint position() const override;
-    void setPosition(const QPoint newPosition) override;
+    Q_INVOKABLE void requestPosition(const QPoint newPosition) override;
 
     Mir::State state() const override;
     void setState(Mir::State qmlState) override;
@@ -159,6 +151,9 @@
 
     ////
     // Own API
+    void setPosition(const QPoint newPosition);
+    void setSize(const QSize newSize);
+    void updateWindowInfo(const WindowInfo &windowInfo);
 
     // useful for tests
     void setCloseTimer(AbstractTimer *timer);
@@ -166,12 +161,6 @@
 public Q_SLOTS:
     void onCompositorSwappedBuffers() override;
 
-    void setMinimumWidth(int) override;
-    void setMinimumHeight(int) override;
-    void setMaximumWidth(int) override;
-    void setMaximumHeight(int) override;
-    void setWidthIncrement(int) override;
-    void setHeightIncrement(int) override;
     void setShellChrome(Mir::ShellChrome shellChrome) override;
 
 private Q_SLOTS:
@@ -191,9 +180,9 @@
     void applyKeymap();
     void updateActiveFocus();
 
-    std::shared_ptr<mir::scene::Surface> m_surface;
+    WindowInfo m_windowInfo;
     QPointer<SessionInterface> m_session;
-    mir::shell::Shell *const m_shell;
+    WindowControllerInterface *const m_controller;
     bool m_firstFrameDrawn;
 
     //FIXME -  have to save the state as Mir has no getter for it (bug:1357429)
@@ -226,13 +215,6 @@
     QCursor m_cursor;
     Mir::ShellChrome m_shellChrome;
 
-    int m_minimumWidth{0};
-    int m_minimumHeight{0};
-    int m_maximumWidth{0};
-    int m_maximumHeight{0};
-    int m_widthIncrement{0};
-    int m_heightIncrement{0};
-
     QRect m_inputBounds;
 
     bool m_focused{false};
 
=== modified file 'miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h'
--- miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h	2016-07-27 12:05:20 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h	2016-08-12 12:04:26 +0000
@@ -49,7 +49,7 @@
     virtual ~MirSurfaceInterface() {}
 
     virtual QPoint position() const = 0;
-    virtual void setPosition(const QPoint newPosition) = 0;
+    virtual void requestPosition(const QPoint newPosition) = 0;
 
     virtual void setLive(bool value) = 0;
 
@@ -118,12 +118,6 @@
 public Q_SLOTS:
     virtual void onCompositorSwappedBuffers() = 0;
 
-    virtual void setMinimumWidth(int) = 0;
-    virtual void setMinimumHeight(int) = 0;
-    virtual void setMaximumWidth(int) = 0;
-    virtual void setMaximumHeight(int) = 0;
-    virtual void setWidthIncrement(int) = 0;
-    virtual void setHeightIncrement(int) = 0;
     virtual void setShellChrome(Mir::ShellChrome shellChrome) = 0;
 
 Q_SIGNALS:
 
=== modified file 'miral-qt/src/modules/Unity/Application/mirsurfacemanager.cpp'
--- miral-qt/src/modules/Unity/Application/mirsurfacemanager.cpp	2016-06-01 22:06:51 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurfacemanager.cpp	2016-08-12 12:04:26 +0000
@@ -97,45 +97,45 @@
 
 void MirSurfaceManager::onSessionCreatedSurface(const mir::scene::Session *mirSession,
                                                 const std::shared_ptr<mir::scene::Surface> &surface,
-                                                const std::shared_ptr<SurfaceObserver> &observer,
+                                                const std::shared_ptr<SurfaceObserver> &/*observer*/,
                                                 qtmir::CreationHints creationHints)
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::onSessionCreatedSurface - mirSession=" << mirSession
                             << "surface=" << surface.get() << "surface.name=" << surface->name().c_str()
                             << "creationHints=" << creationHints.toString();
 
-    SessionInterface* session = m_sessionManager->findSession(mirSession);
-    auto qmlSurface = new MirSurface(surface, session, m_shell, observer, creationHints);
-    {
-        QMutexLocker lock(&m_mutex);
-        m_mirSurfaceToQmlSurfaceHash.insert(surface.get(), qmlSurface);
-    }
-
-    if (session)
-        session->registerSurface(qmlSurface);
-
-    if (qmlSurface->type() == Mir::InputMethodType) {
-        m_inputMethodSurface = qmlSurface;
-        Q_EMIT inputMethodSurfaceChanged();
-    }
-
-    // Only notify QML of surface creation once it has drawn its first frame.
-    connect(qmlSurface, &MirSurfaceInterface::firstFrameDrawn, this, [=]() {
-        tracepoint(qtmir, firstFrameDrawn);
-        Q_EMIT surfaceCreated(qmlSurface);
-    });
-
-    // clean up after MirSurface is destroyed
-    connect(qmlSurface, &QObject::destroyed, this, [&](QObject *obj) {
-        auto qmlSurface = static_cast<MirSurfaceInterface*>(obj);
-        {
-            QMutexLocker lock(&m_mutex);
-            m_mirSurfaceToQmlSurfaceHash.remove(m_mirSurfaceToQmlSurfaceHash.key(qmlSurface));
-        }
-
-        tracepoint(qtmir, surfaceDestroyed);
-    });
-    tracepoint(qtmir, surfaceCreated);
+//    SessionInterface* session = m_sessionManager->findSession(mirSession);
+//    auto qmlSurface = new MirSurface(surface, session, m_shell, observer, creationHints);
+//    {
+//        QMutexLocker lock(&m_mutex);
+//        m_mirSurfaceToQmlSurfaceHash.insert(surface.get(), qmlSurface);
+//    }
+
+//    if (session)
+//        session->registerSurface(qmlSurface);
+
+//    if (qmlSurface->type() == Mir::InputMethodType) {
+//        m_inputMethodSurface = qmlSurface;
+//        Q_EMIT inputMethodSurfaceChanged();
+//    }
+
+//    // Only notify QML of surface creation once it has drawn its first frame.
+//    connect(qmlSurface, &MirSurfaceInterface::firstFrameDrawn, this, [=]() {
+//        tracepoint(qtmir, firstFrameDrawn);
+//        Q_EMIT surfaceCreated(qmlSurface);
+//    });
+
+//    // clean up after MirSurface is destroyed
+//    connect(qmlSurface, &QObject::destroyed, this, [&](QObject *obj) {
+//        auto qmlSurface = static_cast<MirSurfaceInterface*>(obj);
+//        {
+//            QMutexLocker lock(&m_mutex);
+//            m_mirSurfaceToQmlSurfaceHash.remove(m_mirSurfaceToQmlSurfaceHash.key(qmlSurface));
+//        }
+
+//        tracepoint(qtmir, surfaceDestroyed);
+//    });
+//    tracepoint(qtmir, surfaceCreated);
 }
 
 void MirSurfaceManager::onSessionDestroyingSurface(const mir::scene::Session *session,
@@ -144,27 +144,27 @@
     qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::onSessionDestroyingSurface - session=" << session
                             << "surface=" << surface.get() << "surface.name=" << surface->name().c_str();
 
-    MirSurfaceInterface* qmlSurface = nullptr;
-    {
-        QMutexLocker lock(&m_mutex);
-        auto it = m_mirSurfaceToQmlSurfaceHash.find(surface.get());
-        if (it != m_mirSurfaceToQmlSurfaceHash.end()) {
-            qmlSurface = it.value();
-            m_mirSurfaceToQmlSurfaceHash.erase(it);
-        } else {
-            qCritical() << "MirSurfaceManager::onSessionDestroyingSurface: unable to find MirSurface corresponding"
-                        << "to surface=" << surface.get() << "surface.name=" << surface->name().c_str();
-            return;
-        }
-    }
-
-    if (qmlSurface->type() == Mir::InputMethodType) {
-        m_inputMethodSurface = nullptr;
-        Q_EMIT inputMethodSurfaceChanged();
-    }
-
-    qmlSurface->setLive(false);
-    Q_EMIT surfaceDestroyed(qmlSurface);
+//    MirSurfaceInterface* qmlSurface = nullptr;
+//    {
+//        QMutexLocker lock(&m_mutex);
+//        auto it = m_mirSurfaceToQmlSurfaceHash.find(surface.get());
+//        if (it != m_mirSurfaceToQmlSurfaceHash.end()) {
+//            qmlSurface = it.value();
+//            m_mirSurfaceToQmlSurfaceHash.erase(it);
+//        } else {
+//            qCritical() << "MirSurfaceManager::onSessionDestroyingSurface: unable to find MirSurface corresponding"
+//                        << "to surface=" << surface.get() << "surface.name=" << surface->name().c_str();
+//            return;
+//        }
+//    }
+
+//    if (qmlSurface->type() == Mir::InputMethodType) {
+//        m_inputMethodSurface = nullptr;
+//        Q_EMIT inputMethodSurfaceChanged();
+//    }
+
+//    qmlSurface->setLive(false);
+//    Q_EMIT surfaceDestroyed(qmlSurface);
 }
 
 MirSurfaceInterface* MirSurfaceManager::inputMethodSurface() const
 
=== modified file 'miral-qt/src/modules/Unity/Application/windowmodel.cpp'
--- miral-qt/src/modules/Unity/Application/windowmodel.cpp	2016-07-27 12:05:20 +0000
+++ miral-qt/src/modules/Unity/Application/windowmodel.cpp	2016-08-12 12:04:26 +0000
@@ -31,8 +31,8 @@
 using namespace qtmir;
 
 WindowModel::WindowModel()
+    : m_focusedWindow(nullptr)
 {
-
     auto nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
 
     if (!nativeInterface) {
@@ -40,10 +40,14 @@
     }
 
     auto windowModel = static_cast<WindowModelInterface*>(nativeInterface->nativeResourceForIntegration("WindowModel"));
+    m_windowController = static_cast<WindowControllerInterface*>(nativeInterface->nativeResourceForIntegration("WindowController"));
 
-    connect(windowModel, &WindowModelInterface::windowAdded, this, &WindowModel::onWindowAdded);
-    connect(windowModel, &WindowModelInterface::windowRemoved, this, &WindowModel::onWindowRemoved);
-    connect(windowModel, &WindowModelInterface::windowChanged, this, &WindowModel::onWindowChanged);
+    connect(windowModel, &WindowModelInterface::windowAdded,       this, &WindowModel::onWindowAdded);
+    connect(windowModel, &WindowModelInterface::windowRemoved,     this, &WindowModel::onWindowRemoved);
+    connect(windowModel, &WindowModelInterface::windowMoved,       this, &WindowModel::onWindowMoved);
+    connect(windowModel, &WindowModelInterface::windowResized,     this, &WindowModel::onWindowResized);
+    connect(windowModel, &WindowModelInterface::windowFocused,     this, &WindowModel::onWindowFocused);
+    connect(windowModel, &WindowModelInterface::windowInfoChanged, this, &WindowModel::onWindowInfoChanged);
 }
 
 QHash<int, QByteArray> WindowModel::roleNames() const
@@ -53,17 +57,18 @@
     return roleNames;
 }
 
-void WindowModel::onWindowAdded(const NumberedWindow window)
+void WindowModel::onWindowAdded(const WindowInfo windowInfo, const unsigned int index)
 {
-    qDebug() << "Window Added!" << window.index;
+    qDebug() << "Window Added!" << index;
     std::shared_ptr<SurfaceObserver> surfaceObserver = std::make_shared<SurfaceObserver>();
-    const auto &surface = window.windowInfo.surface;
+
+    const auto &surface = static_cast<std::shared_ptr<mir::scene::Surface>>(windowInfo.window);
     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);
+    auto mirSurface = new MirSurface(windowInfo, m_windowController, surfaceObserver);
+    beginInsertRows(QModelIndex(), index, index);
+    m_windowModel.insert(index, mirSurface);
     endInsertRows();
     Q_EMIT countChanged();
 }
@@ -77,25 +82,34 @@
     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);
+void WindowModel::onWindowMoved(const QPoint topLeft, const unsigned int index)
+{
+    auto mirSurface = static_cast<MirSurface *>(m_windowModel.value(index));
+    mirSurface->setPosition(topLeft);
+}
+
+void WindowModel::onWindowResized(const QSize size, const unsigned int index)
+{
+    auto mirSurface = static_cast<MirSurface *>(m_windowModel.value(index));
+    mirSurface->setSize(size);
+}
+
+void WindowModel::onWindowFocused(const unsigned int index)
+{
+    auto mirSurface = static_cast<MirSurface *>(m_windowModel.value(index));
+    if (m_focusedWindow && m_focusedWindow != mirSurface) {
+        m_focusedWindow->setFocused(false);
+    }
+    mirSurface->setFocused(true);
+    m_focusedWindow = mirSurface;
+}
+
+void WindowModel::onWindowInfoChanged(const WindowInfo windowInfo, const unsigned int pos)
+{
+    auto mirSurface = static_cast<MirSurface *>(m_windowModel.value(pos));
+    mirSurface->updateWindowInfo(windowInfo);
+
+    QModelIndex row = index(pos);
     Q_EMIT dataChanged(row, row, QVector<int>() << SurfaceRole);
 }
 
 
=== modified file 'miral-qt/src/modules/Unity/Application/windowmodel.h'
--- miral-qt/src/modules/Unity/Application/windowmodel.h	2016-07-27 11:48:55 +0000
+++ miral-qt/src/modules/Unity/Application/windowmodel.h	2016-08-12 12:04:26 +0000
@@ -24,6 +24,8 @@
 
 namespace qtmir {
 
+class WindowControllerInterface;
+
 class WindowModel : public QAbstractListModel
 {
     Q_OBJECT
@@ -49,12 +51,17 @@
     void countChanged();
 
 private Q_SLOTS:
-    void onWindowAdded(const NumberedWindow);
+    void onWindowAdded(const WindowInfo windowInfo, const unsigned int index);
     void onWindowRemoved(const unsigned int index);
-    void onWindowChanged(const DirtiedWindow);
+    void onWindowMoved(const QPoint topLeft, const unsigned int index);
+    void onWindowResized(const QSize size, const unsigned int index);
+    void onWindowFocused(const unsigned int index);
+    void onWindowInfoChanged(const WindowInfo windowInfo, const unsigned int index);
 
 private:
     QVector<MirSurfaceInterface *> m_windowModel;
+    WindowControllerInterface *m_windowController;
+    MirSurfaceInterface* m_focusedWindow;
 };
 
 } // namespace qtmir
 
=== modified file 'miral-qt/src/platforms/mirserver/CMakeLists.txt'
--- miral-qt/src/platforms/mirserver/CMakeLists.txt	2016-07-28 13:37:17 +0000
+++ miral-qt/src/platforms/mirserver/CMakeLists.txt	2016-08-12 12:04:26 +0000
@@ -79,12 +79,14 @@
     ubuntutheme.cpp
     clipboard.cpp
     creationhints.cpp
+    windowcontroller.cpp
     windowmanagementpolicy.cpp
     windowmodel.cpp
     tracepoints.c
 # We need to run moc on these headers
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h
+    ${MIRAL_QT_SOURCE_DIR}/src/common/windowcontrollerinterface.h
     ${MIRAL_QT_SOURCE_DIR}/src/common/windowmodelinterface.h
     )
 
 
=== modified file 'miral-qt/src/platforms/mirserver/mirserver.cpp'
--- miral-qt/src/platforms/mirserver/mirserver.cpp	2016-07-28 13:37:17 +0000
+++ miral-qt/src/platforms/mirserver/mirserver.cpp	2016-08-12 12:04:26 +0000
@@ -192,7 +192,7 @@
 
 UsingQtMirWindowManager::UsingQtMirWindowManager(const QSharedPointer<ScreensModel> &model)
     : m_screensModel(model)
-    , m_policy(miral::set_window_managment_policy<WindowManagementPolicy>(m_windowModel, m_screensModel))
+    , m_policy(miral::set_window_managment_policy<WindowManagementPolicy>(m_windowModel, m_windowController, m_screensModel))
 {
 }
 
@@ -206,10 +206,9 @@
     return &m_windowModel;
 }
 
-mir::shell::Shell *MirServer::shell()
+qtmir::WindowControllerInterface *UsingQtMirWindowManager::windowController()
 {
-    std::weak_ptr<mir::shell::Shell> m_shell = the_shell();
-    return m_shell.lock().get();
+    return &m_windowController;
 }
 
 QSharedPointer<ScreensModel> MirServer::screensModel() const
 
=== modified file 'miral-qt/src/platforms/mirserver/mirserver.h'
--- miral-qt/src/platforms/mirserver/mirserver.h	2016-07-28 13:37:17 +0000
+++ miral-qt/src/platforms/mirserver/mirserver.h	2016-08-12 12:04:26 +0000
@@ -22,6 +22,7 @@
 #include <mir/server.h>
 #include "miral/set_window_managment_policy.h"
 #include "windowmodel.h"
+#include "windowcontroller.h"
 
 class QtEventFeeder;
 class MirDisplayConfigurationPolicy;
@@ -70,10 +71,12 @@
     UsingQtMirWindowManager(const QSharedPointer<ScreensModel> &model);
     void operator()(mir::Server& server);
     qtmir::WindowModelInterface *windowModel();
+    qtmir::WindowControllerInterface *windowController();
 
 private:
     const QSharedPointer<ScreensModel> &m_screensModel;
     miral::SetWindowManagmentPolicy m_policy;
+    qtmir::WindowController m_windowController;
     qtmir::WindowModel m_windowModel;
 };
 
@@ -92,7 +95,6 @@
 
     Q_PROPERTY(SessionAuthorizer* sessionAuthorizer READ sessionAuthorizer CONSTANT)
     Q_PROPERTY(SessionListener* sessionListener READ sessionListener CONSTANT)
-    Q_PROPERTY(mir::shell::Shell* shell READ shell CONSTANT)
     Q_PROPERTY(PromptSessionListener* promptSessionListener READ promptSessionListener CONSTANT)
 
 public:
@@ -115,7 +117,7 @@
     using UsingQtMirSessionListener::sessionListener;
     using UsingQtMirPromptSessionListener::promptSessionListener;
     using UsingQtMirWindowManager::windowModel;
-    mir::shell::Shell *shell();
+    using UsingQtMirWindowManager::windowController;
 
     QSharedPointer<ScreensModel> screensModel() const;
 
 
=== modified file 'miral-qt/src/platforms/mirserver/qmirserver.cpp'
--- miral-qt/src/platforms/mirserver/qmirserver.cpp	2016-07-28 13:37:17 +0000
+++ miral-qt/src/platforms/mirserver/qmirserver.cpp	2016-08-12 12:04:26 +0000
@@ -113,12 +113,12 @@
     if (d->server) {
         if (resource == "SessionAuthorizer")
             result = d->server->sessionAuthorizer();
-        else if (resource == "Shell")
-            result = d->server->shell();
         else if (resource == "SessionListener")
             result = d->server->sessionListener();
         else if (resource == "PromptSessionListener")
             result = d->server->promptSessionListener();
+        else if (resource == "WindowController")
+            result = d->server->windowController();
         else if (resource == "WindowModel")
             result = d->server->windowModel();
         else if (resource == "ScreensController")
 
=== added file 'miral-qt/src/platforms/mirserver/windowcontroller.cpp'
--- miral-qt/src/platforms/mirserver/windowcontroller.cpp	1970-01-01 00:00:00 +0000
+++ miral-qt/src/platforms/mirserver/windowcontroller.cpp	2016-08-12 12:04:26 +0000
@@ -0,0 +1,85 @@
+/*
+ * 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 "windowcontroller.h"
+
+#include "windowmanagementpolicy.h"
+#include "mirqtconversion.h"
+
+using namespace qtmir;
+
+
+WindowController::WindowController()
+    : m_policy(nullptr)
+{
+}
+
+void WindowController::focus(const miral::Window &window)
+{
+    if (m_policy) {
+        m_policy->focus(window);
+    }
+}
+
+void WindowController::resize(const miral::Window &window, const QSize &size)
+{
+    if (m_policy) {
+        m_policy->resize(window, toMirSize(size));
+    }
+}
+
+void WindowController::move(const miral::Window &window, const QPoint &topLeft)
+{
+    if (m_policy) {
+        m_policy->move(window, toMirPoint(topLeft));
+    }
+}
+
+void WindowController::setActiveFocus(const miral::Window &/*window*/, const bool /*activeFocus*/)
+{
+
+}
+
+void WindowController::setState(const miral::Window &/*window*/, const MirSurfaceState /*state*/)
+{
+
+}
+
+void WindowController::deliverKeyboardEvent(const miral::Window &window, const MirKeyboardEvent *event)
+{
+    if (m_policy) {
+        m_policy->deliver_keyboard_event(event, window);
+    }
+}
+
+void WindowController::deliverTouchEvent(const miral::Window &window, const MirTouchEvent *event)
+{
+    if (m_policy) {
+        m_policy->deliver_touch_event(event, window);
+    }
+}
+
+void WindowController::deliverPointerEvent(const miral::Window &window, const MirPointerEvent *event)
+{
+    if (m_policy) {
+        m_policy->deliver_pointer_event(event, window);
+    }
+}
+
+void WindowController::setPolicy(WindowManagementPolicy * const policy)
+{
+    m_policy = policy;
+}
 
=== added file 'miral-qt/src/platforms/mirserver/windowcontroller.h'
--- miral-qt/src/platforms/mirserver/windowcontroller.h	1970-01-01 00:00:00 +0000
+++ miral-qt/src/platforms/mirserver/windowcontroller.h	2016-08-12 12:04:26 +0000
@@ -0,0 +1,51 @@
+/*
+ * 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 WINDOWCONTROLLER_H
+#define WINDOWCONTROLLER_H
+
+#include "windowcontrollerinterface.h"
+
+class WindowManagementPolicy;
+
+namespace qtmir {
+
+class WindowController : public WindowControllerInterface
+{
+public:
+    WindowController();
+    virtual ~WindowController() = default;
+
+    void focus (const miral::Window &window) override;
+    void resize(const miral::Window &window, const QSize &size) override;
+    void move  (const miral::Window &window, const QPoint &topLeft) override;
+
+    void setActiveFocus(const miral::Window &window, const bool activeFocus) override;
+    void setState(const miral::Window &window, const MirSurfaceState state) override;
+
+    void deliverKeyboardEvent(const miral::Window &window, const MirKeyboardEvent *event) override;
+    void deliverTouchEvent   (const miral::Window &window, const MirTouchEvent *event) override;
+    void deliverPointerEvent (const miral::Window &window, const MirPointerEvent *event) override;
+
+    void setPolicy(WindowManagementPolicy *policy);
+
+protected:
+    WindowManagementPolicy *m_policy;
+};
+
+} // namespace qtmir
+
+#endif // WINDOWCONTROLLER_H
 
=== modified file 'miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp'
--- miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp	2016-08-10 11:48:02 +0000
+++ miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp	2016-08-12 12:04:26 +0000
@@ -26,12 +26,14 @@
 
 WindowManagementPolicy::WindowManagementPolicy(const miral::WindowManagerTools &tools,
                                                qtmir::WindowModel &windowModel,
+                                               qtmir::WindowController &windowController,
                                                const QSharedPointer<ScreensModel> screensModel)
     : CanonicalWindowManagerPolicy(tools)
     , m_tools(tools)
     , m_windowModel(windowModel)
     , m_eventFeeder(new QtEventFeeder(screensModel))
 {
+    windowController.setPolicy(this);
 }
 
 /* Following are hooks to allow custom policy be imposed */
@@ -46,7 +48,7 @@
 
 void WindowManagementPolicy::handle_window_ready(miral::WindowInfo &windowInfo)
 {
-    qDebug("Window ready");
+    qDebug("Window Ready");
     m_tools.select_active_window(windowInfo.window());
 }
 
@@ -85,6 +87,7 @@
 
 void WindowManagementPolicy::advise_new_window(const miral::WindowInfo &windowInfo)
 {
+    // TODO: attach surface observer here
     m_windowModel.addWindow(windowInfo);
 }
 
@@ -115,13 +118,13 @@
 
 void WindowManagementPolicy::advise_move_to(const miral::WindowInfo &windowInfo, Point topLeft)
 {
-    qDebug("Window move");
+    qDebug("Window Moved to (%d, %d)", topLeft.x.as_int(), topLeft.y.as_int());
     m_windowModel.moveWindow(windowInfo, topLeft);
 }
 
 void WindowManagementPolicy::advise_resize(const miral::WindowInfo &windowInfo, const Size &newSize)
 {
-    qDebug("Window Resize");
+    qDebug("Window Resized to %dx%d", newSize.width.as_int(), newSize.height.as_int());
     m_windowModel.resizeWindow(windowInfo, newSize);
 }
 
@@ -147,35 +150,60 @@
 
 /* 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)
+                                                    const miral::Window &window)
 {
-    m_tools.invoke_under_lock([&surface, this]() {
-        auto windowInfo = m_tools.info_for(surface);
-        m_tools.select_active_window(windowInfo.window());
+    m_tools.invoke_under_lock([&window, this]() {
+        m_tools.select_active_window(window);
     });
     auto e = reinterpret_cast<MirEvent const*>(event); // naughty
-    surface->consume(e);
+
+    if (auto surface = std::weak_ptr<mir::scene::Surface>(window).lock()) {
+        surface->consume(e);
+    }
 }
 
 void WindowManagementPolicy::deliver_touch_event(const MirTouchEvent *event,
-                                                 const std::shared_ptr<mir::scene::Surface> &surface)
+                                                 const miral::Window &window)
 {
-    m_tools.invoke_under_lock([&surface, this]() {
-        auto windowInfo = m_tools.info_for(surface);
-        m_tools.select_active_window(windowInfo.window());
+    m_tools.invoke_under_lock([&window, this]() {
+        m_tools.select_active_window(window);
     });
     auto e = reinterpret_cast<MirEvent const*>(event); // naughty
-    surface->consume(e);
+
+    if (auto surface = std::weak_ptr<mir::scene::Surface>(window).lock()) {
+        surface->consume(e);
+    }
 }
 
 void WindowManagementPolicy::deliver_pointer_event(const MirPointerEvent *event,
-                                                   const std::shared_ptr<mir::scene::Surface> &surface)
+                                                   const miral::Window &window)
 {
-    m_tools.invoke_under_lock([&surface, this]() {
-        auto windowInfo = m_tools.info_for(surface);
-        m_tools.select_active_window(windowInfo.window());
+    m_tools.invoke_under_lock([&window, this]() {
+        m_tools.select_active_window(window);
     });
     auto e = reinterpret_cast<MirEvent const*>(event); // naughty
-    surface->consume(e);
-}
-
+
+    if (auto surface = std::weak_ptr<mir::scene::Surface>(window).lock()) {
+        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)
+{
+    miral::WindowSpecification modifications;
+    modifications.size() = size;
+    m_tools.modify_window(m_tools.info_for(window), modifications);
+}
+
+void WindowManagementPolicy::move(const miral::Window &window, const Point topLeft)
+{
+    miral::WindowSpecification modifications;
+    modifications.top_left() = topLeft;
+    m_tools.modify_window(m_tools.info_for(window), modifications);
+}
 
=== modified file 'miral-qt/src/platforms/mirserver/windowmanagementpolicy.h'
--- miral-qt/src/platforms/mirserver/windowmanagementpolicy.h	2016-08-10 11:48:02 +0000
+++ miral-qt/src/platforms/mirserver/windowmanagementpolicy.h	2016-08-12 12:04:26 +0000
@@ -20,9 +20,9 @@
 #include "miral/canonical_window_manager.h"
 
 #include "qteventfeeder.h"
+#include "windowcontroller.h"
 #include "windowmodel.h"
 
-#include <QObject>
 #include <QScopedPointer>
 #include <QSize>
 
@@ -30,11 +30,12 @@
 
 class ScreensModel;
 
-class WindowManagementPolicy : public QObject, public miral::CanonicalWindowManagerPolicy
+class WindowManagementPolicy : public miral::CanonicalWindowManagerPolicy
 {
 public:
     WindowManagementPolicy(const miral::WindowManagerTools &tools,
                            qtmir::WindowModel &windowModel,
+                           qtmir::WindowController &windowController,
                            const QSharedPointer<ScreensModel> screensModel);
 
     // From WindowManagementPolicy
@@ -65,12 +66,16 @@
     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;
-
-    // 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 advise_raise(const std::vector<miral::Window> &windows) override;
+
+    // Methods for consumption by WindowControllerInterface
+    void deliver_keyboard_event(const MirKeyboardEvent *event, const miral::Window &window);
+    void deliver_touch_event   (const MirTouchEvent *event,    const miral::Window &window);
+    void deliver_pointer_event (const MirPointerEvent *event,  const miral::Window &window);
+
+    void focus (const miral::Window &window);
+    void resize(const miral::Window &window, const Size size);
+    void move  (const miral::Window &window, const Point topLeft);
 
 Q_SIGNALS:
 
 
=== modified file 'miral-qt/src/platforms/mirserver/windowmodel.cpp'
--- miral-qt/src/platforms/mirserver/windowmodel.cpp	2016-08-05 09:54:43 +0000
+++ miral-qt/src/platforms/mirserver/windowmodel.cpp	2016-08-12 12:04:26 +0000
@@ -32,8 +32,7 @@
 WindowModel::WindowModel()
 {
     qDebug("WindowModel::WindowModel");
-    qRegisterMetaType<qtmir::NumberedWindow>();
-    qRegisterMetaType<qtmir::DirtiedWindow>();
+    qRegisterMetaType<qtmir::WindowInfo>();
 }
 
 WindowModel::~WindowModel()
@@ -47,12 +46,7 @@
     auto stackPosition = static_cast<unsigned int>(m_windowStack.count());
     m_windowStack.push_back(windowInfo.window()); // ASSUMPTION: Mir should tell us where in stack
 
-    QSize size = toQSize(windowInfo.window().size());
-    QPoint position = toQPoint(windowInfo.window().top_left());
-
-    WindowInfo info{ size, position, false, windowInfo.window() };
-    NumberedWindow window{ stackPosition, info };
-    Q_EMIT windowAdded(window);
+    Q_EMIT windowAdded(windowInfo, stackPosition);
 }
 
 void WindowModel::removeWindow(const miral::WindowInfo &windowInfo)
@@ -76,13 +70,11 @@
         return;
     }
     auto upos = static_cast<unsigned int>(pos);
-    m_focusedWindowIndex = upos;
-    QSize size = toQSize(windowInfo.window().size());
-    QPoint position = toQPoint(windowInfo.window().top_left());
 
-    WindowInfo info{ size, position, focus, windowInfo.window() };
-    DirtiedWindow window{ upos, info, WindowInfo::DirtyStates::Focus};
-    Q_EMIT windowChanged(window);
+    if (focus && m_focusedWindowIndex != upos) {
+        m_focusedWindowIndex = upos;
+        Q_EMIT windowFocused(upos);
+    }
 }
 
 void WindowModel::moveWindow(const miral::WindowInfo &windowInfo, mir::geometry::Point topLeft)
@@ -93,13 +85,9 @@
         return;
     }
     auto upos = static_cast<unsigned int>(pos);
-    const bool focused = (m_focusedWindowIndex == upos);
-    QSize size = toQSize(windowInfo.window().size());
-    QPoint position = toQPoint(topLeft);
 
-    WindowInfo info{ size, position, focused, windowInfo.window() };
-    DirtiedWindow window{ upos, info, WindowInfo::DirtyStates::Position};
-    Q_EMIT windowChanged(window);
+    // Note: windowInfo.window() is in the state before the move
+    Q_EMIT windowMoved(toQPoint(topLeft), upos);
 }
 
 void WindowModel::resizeWindow(const miral::WindowInfo &windowInfo, mir::geometry::Size newSize)
@@ -110,13 +98,9 @@
         return;
     }
     auto upos = static_cast<unsigned int>(pos);
-    const bool focused = (m_focusedWindowIndex == upos);
-    QSize size = toQSize(newSize);
-    QPoint position = toQPoint(windowInfo.window().top_left());
 
-    WindowInfo info{ size, position, focused, windowInfo.window() };
-    DirtiedWindow window{ upos, info, WindowInfo::DirtyStates::Size};
-    Q_EMIT windowChanged(window);
+    // Note: windowInfo.window() is in the state before the resize
+    Q_EMIT windowResized(toQSize(newSize), upos);
 }
 
 void WindowModel::raiseWindows(const std::vector<miral::Window> &/*windows*/)
 
=== modified file 'miral-qt/tests/framework/fake_mirsurface.cpp'
--- miral-qt/tests/framework/fake_mirsurface.cpp	2016-07-27 12:05:20 +0000
+++ miral-qt/tests/framework/fake_mirsurface.cpp	2016-08-12 12:04:26 +0000
@@ -58,11 +58,11 @@
 
 QPoint FakeMirSurface::position() const { return m_position; }
 
-void FakeMirSurface::setPosition(const QPoint position)
+void FakeMirSurface::requestPosition(const QPoint newPosition)
 {
-    if (m_position != position) {
-        m_position = position;
-        Q_EMIT positionChanged(position);
+    if (m_position != newPosition) {
+        m_position = newPosition;
+        Q_EMIT positionChanged(newPosition);
     }
 }
 
@@ -192,6 +192,8 @@
 
 void FakeMirSurface::onCompositorSwappedBuffers() {}
 
+void FakeMirSurface::setShellChrome(Mir::ShellChrome /*shellChrome*/) {}
+
 void FakeMirSurface::drawFirstFrame()
 {
     if (!m_isFirstFrameDrawn) {
 
=== modified file 'miral-qt/tests/framework/fake_mirsurface.h'
--- miral-qt/tests/framework/fake_mirsurface.h	2016-07-27 12:05:20 +0000
+++ miral-qt/tests/framework/fake_mirsurface.h	2016-08-12 12:04:26 +0000
@@ -54,8 +54,6 @@
     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;
@@ -93,6 +91,9 @@
     ////
     // qtmir.MirSurfaceInterface
 
+    QPoint position() const override;
+    void requestPosition(const QPoint newPosition) override;
+
     bool isFirstFrameDrawn() const override;
     void stopFrameDropper() override;
     void startFrameDropper() override;
@@ -112,7 +113,7 @@
 
     void setFocused(bool focus) override;
 
-    void setViewActiveFocus(qintptr, bool) override {};
+    void setViewActiveFocus(qintptr, bool) override {}
     bool activeFocus() const override { return false; }
 
     void mousePressEvent(QMouseEvent *) override;
@@ -141,13 +142,7 @@
 public Q_SLOTS:
     void onCompositorSwappedBuffers() override;
 
-    void setMinimumWidth(int) {}
-    void setMinimumHeight(int) {}
-    void setMaximumWidth(int) {}
-    void setMaximumHeight(int) {}
-    void setWidthIncrement(int) {}
-    void setHeightIncrement(int) {}
-    void setShellChrome(Mir::ShellChrome) override {}
+    void setShellChrome(Mir::ShellChrome shellChrome) override;
 
     ////
     // Test API from now on
 
=== modified file 'miral-qt/tests/modules/SurfaceManager/CMakeLists.txt'
--- miral-qt/tests/modules/SurfaceManager/CMakeLists.txt	2016-06-07 20:32:04 +0000
+++ miral-qt/tests/modules/SurfaceManager/CMakeLists.txt	2016-08-12 12:04:26 +0000
@@ -1,14 +1,16 @@
 set(
   MIR_SURFACE_MANAGER_TEST_SOURCES
-  mirsurfaceitem_test.cpp
+#  mirsurfaceitem_test.cpp #FIXME - reinstate these tests when functionality there
   mirsurface_test.cpp
   ${MIRAL_QT_SOURCE_DIR}/src/common/debughelpers.cpp
 )
 
 include_directories(
+  ${MIRAL_QT_SOURCE_DIR}/src/common
   ${MIRAL_QT_SOURCE_DIR}/src/modules
   ${MIRAL_QT_SOURCE_DIR}/src/platforms/mirserver
   ${MIRAL_QT_SOURCE_DIR}/tests/framework
+  ${CMAKE_SOURCE_DIR}/include/miral   #FIXME
   ${MIRSERVER_INCLUDE_DIRS}
   ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
 )
 
=== modified file 'miral-qt/tests/modules/SurfaceManager/mirsurface_test.cpp'
--- miral-qt/tests/modules/SurfaceManager/mirsurface_test.cpp	2016-06-07 20:32:04 +0000
+++ miral-qt/tests/modules/SurfaceManager/mirsurface_test.cpp	2016-08-12 12:04:26 +0000
@@ -24,22 +24,24 @@
 #include <QTest>
 #include <QSignalSpy>
 
+// src/common
+#include "windowmodelinterface.h"
+
 // the test subject
 #include <Unity/Application/mirsurface.h>
 
 #include <Unity/Application/timer.h>
 
 // tests/framework
-#include <fake_session.h>
 #include <mock_mir_session.h>
-#include <mock_shell.h>
 #include <mock_surface.h>
 
 // tests/modules/common
 #include <surfaceobserver.h>
 
-// mirserver
-#include <creationhints.h>
+// miral
+#include "window.h"
+#include "window_info.h"
 
 using namespace qtmir;
 
@@ -54,8 +56,6 @@
         // We don't want the logging spam cluttering the test results
         QLoggingCategory::setFilterRules(QStringLiteral("qtmir.surfaces=false"));
     }
-
-    NiceMock<mir::shell::MockShell> m_mockShell;
 };
 
 TEST_F(MirSurfaceTest, UpdateTextureBeforeDraw)
@@ -64,22 +64,23 @@
     char* argv[0];
     QCoreApplication qtApp(argc, argv); // app for deleteLater event
 
-    auto fakeSession = new FakeSession();
+    auto const fakeSession = std::make_shared<ms::MockSession>();
     auto mockSurface = std::make_shared<NiceMock<ms::MockSurface>>();
+    miral::Window mockWindow(fakeSession, mockSurface);
+    miral::WindowInfo mockWindowInfo(mockWindow, {});
+    QScopedPointer<WindowInfo> windowInfo(new WindowInfo(mockWindowInfo));
+
     auto surfaceObserver = std::make_shared<SurfaceObserver>();
 
     EXPECT_CALL(*mockSurface.get(),buffers_ready_for_compositor(_))
         .WillRepeatedly(Return(1));
 
-    MirSurface *surface = new MirSurface(mockSurface, fakeSession, &m_mockShell, surfaceObserver, CreationHints());
+    MirSurface surface(mockWindowInfo, nullptr, surfaceObserver);
     surfaceObserver->frame_posted(1, mir::geometry::Size{1,1});
 
-    QSignalSpy spyFrameDropped(surface, SIGNAL(frameDropped()));
+    QSignalSpy spyFrameDropped(&surface, SIGNAL(frameDropped()));
     QTest::qWait(300);
     ASSERT_TRUE(spyFrameDropped.count() > 0);
-
-    delete fakeSession;
-    delete surface;
 }
 
 
@@ -89,28 +90,31 @@
     char* argv[0];
     QCoreApplication qtApp(argc, argv); // app for deleteLater event
 
-    auto fakeSession = new FakeSession();
+    auto const fakeSession = std::make_shared<NiceMock<ms::MockSession>>();
     auto mockSurface = std::make_shared<NiceMock<ms::MockSurface>>();
-
-    MirSurface *surface = new MirSurface(mockSurface, fakeSession, &m_mockShell, nullptr, CreationHints());
+    miral::Window mockWindow(fakeSession, mockSurface);
+    miral::WindowInfo mockWindowInfo(mockWindow, {});
+    QScopedPointer<WindowInfo> windowInfo(new WindowInfo(mockWindowInfo));
+    auto surfaceObserver = std::make_shared<SurfaceObserver>();
+
+    MirSurface surface(mockWindowInfo, nullptr, surfaceObserver);
+
     bool surfaceDeleted = false;
-    QObject::connect(surface, &QObject::destroyed, surface, [&surfaceDeleted](){ surfaceDeleted = true; });
+    QObject::connect(&surface, &QObject::destroyed, &surface, [&surfaceDeleted](){ surfaceDeleted = true; });
 
     qintptr view1 = (qintptr)1;
     qintptr view2 = (qintptr)2;
 
-    surface->registerView(view1);
-    surface->registerView(view2);
-    surface->setLive(false);
+    surface.registerView(view1);
+    surface.registerView(view2);
+    surface.setLive(false);
     EXPECT_FALSE(surfaceDeleted);
 
-    surface->unregisterView(view1);
-    surface->unregisterView(view2);
+    surface.unregisterView(view1);
+    surface.unregisterView(view2);
 
     QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
     EXPECT_TRUE(surfaceDeleted);
-
-    delete fakeSession;
 }
 
 
@@ -120,62 +124,63 @@
     char* argv[0];
     QCoreApplication qtApp(argc, argv); // app for deleteLater event
 
-    auto fakeSession = new FakeSession();
+    auto const fakeSession = std::make_shared<ms::MockSession>();
     auto mockSurface = std::make_shared<NiceMock<ms::MockSurface>>();
-
-    MirSurface *surface = new MirSurface(mockSurface, fakeSession, &m_mockShell, nullptr, CreationHints());
+    miral::Window mockWindow(fakeSession, mockSurface);
+    miral::WindowInfo mockWindowInfo(mockWindow, {});
+    QScopedPointer<WindowInfo> windowInfo(new WindowInfo(mockWindowInfo));
+    auto surfaceObserver = std::make_shared<SurfaceObserver>();
+
+    MirSurface surface(mockWindowInfo, nullptr, surfaceObserver);
+
     bool surfaceDeleted = false;
-    QObject::connect(surface, &QObject::destroyed, surface, [&surfaceDeleted](){ surfaceDeleted = true; });
+    QObject::connect(&surface, &QObject::destroyed, &surface, [&surfaceDeleted](){ surfaceDeleted = true; });
 
     qintptr view1 = (qintptr)1;
     qintptr view2 = (qintptr)2;
 
-    surface->registerView(view1);
-    surface->registerView(view2);
+    surface.registerView(view1);
+    surface.registerView(view2);
 
-    surface->unregisterView(view1);
-    surface->unregisterView(view2);
+    surface.unregisterView(view1);
+    surface.unregisterView(view2);
 
     QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
     EXPECT_FALSE(surfaceDeleted);
-
-    delete fakeSession;
-    delete surface;
 }
 
 /*
  * Test that a surface whose client fails to comply with a close request will eventually get destroyed.
  */
-TEST_F(MirSurfaceTest, failedSurfaceCloseEventualyDestroysSurface)
+TEST_F(MirSurfaceTest, failedSurfaceCloseEventuallyDestroysSurface)
 {
-    const pid_t pid = 1234;
-    const char appId[] = "test-app";
-
     int argc = 0;
     char* argv[0];
     QCoreApplication qtApp(argc, argv); // app for deleteLater event
 
-    auto fakeSession = new FakeSession();
-    auto mirSession = std::make_shared<mir::scene::MockSession>(appId, pid);
-    fakeSession->setSession(mirSession);
-
+    auto const mockSession = std::make_shared<NiceMock<ms::MockSession>>();
     auto mockSurface = std::make_shared<NiceMock<ms::MockSurface>>();
-
-    MirSurface *surface = new MirSurface(mockSurface, fakeSession, &m_mockShell, nullptr, CreationHints());
+    miral::Window mockWindow(mockSession, mockSurface);
+    miral::WindowInfo mockWindowInfo(mockWindow, {});
+    QScopedPointer<WindowInfo> windowInfo(new WindowInfo(mockWindowInfo));
+    auto surfaceObserver = std::make_shared<SurfaceObserver>();
+
+    MirSurface surface(mockWindowInfo, nullptr, surfaceObserver);
+
     bool surfaceDeleted = false;
-    QObject::connect(surface, &QObject::destroyed, surface, [&surfaceDeleted](){ surfaceDeleted = true; });
+    QObject::connect(&surface, &QObject::destroyed, &surface, [&surfaceDeleted](){ surfaceDeleted = true; });
 
     QSharedPointer<FakeTimeSource> fakeTimeSource(new FakeTimeSource);
     QPointer<FakeTimer> fakeTimer(new FakeTimer(fakeTimeSource));
-    surface->setCloseTimer(fakeTimer.data()); // surface takes ownership of the timer
+    surface.setCloseTimer(fakeTimer.data()); // surface takes ownership of the timer
 
     qintptr view = (qintptr)1;
-    surface->registerView(view);
+    surface.registerView(view);
 
-    EXPECT_CALL(*mirSession.get(), destroy_surface(An<const std::weak_ptr<mir::scene::Surface> &>()))
+    EXPECT_CALL(*mockSession.get(), destroy_surface(An<const std::weak_ptr<ms::Surface> &>()))
         .Times(1);
 
-    surface->close();
+    surface.close();
 
     if (fakeTimer->isRunning()) {
         // Simulate that closeTimer has timed out.
@@ -184,8 +189,6 @@
     }
 
     // clean up
-    surface->setLive(false);
-    surface->unregisterView(view);
-    delete surface;
-    delete fakeSession;
+    surface.setLive(false);
+    surface.unregisterView(view);
 }