Merge lp:~nick-dedekind/qtmir/screens-api into lp:qtmir

[Nick Dedekind]

Screens API

Screens API

[lp:~nick-dedekind/qtmir/screens-api]

614. By Nick Dedekind on 2017-02-22

workspace policy

615. By Nick Dedekind on 2017-02-24

suface manager singleton

616. By Nick Dedekind on 2017-02-28

Surfaces track window changes. Better surface tracking

617. By Nick Dedekind on 2017-03-01

merged with parent

618. By Nick Dedekind on 2017-03-02

WindowNotifierObserver

619. By Nick Dedekind on 2017-03-02

signal renaming

620. By Nick Dedekind on 2017-03-02

const override

621. By Nick Dedekind on 2017-03-03

reverted to MirSurface create with NewWindow

622. By Nick Dedekind on 2017-03-10

merged with parent

623. By Nick Dedekind on 2017-03-10

removed Q_PROPERTY from qtmir::Screen

624. By Nick Dedekind on 2017-03-14

workspace controller & surface manager api

625. By Nick Dedekind on 2017-03-16

merged with parent

626. By Nick Dedekind on 2017-03-20

merged with parent

627. By Nick Dedekind on 2017-03-24

merged parent

628. By Nick Dedekind on 2017-04-03

merged with pre-req

629. By Nick Dedekind on 2017-04-03

better lttng deps

630. By Nick Dedekind on 2017-04-03

DisplayId

631. By Nick Dedekind on 2017-04-04

include def

632. By Nick Dedekind on 2017-04-04

merged with pre-req

633. By Nick Dedekind on 2017-04-05

merged pre-req

634. By Nick Dedekind on 2017-04-05

changelog update

635. By Nick Dedekind on 2017-04-06

changelog

Unmerged revisions

635. By Nick Dedekind on 2017-04-06

changelog

634. By Nick Dedekind on 2017-04-05

changelog update

633. By Nick Dedekind on 2017-04-05

merged pre-req

632. By Nick Dedekind on 2017-04-04

merged with pre-req

631. By Nick Dedekind on 2017-04-04

include def

630. By Nick Dedekind on 2017-04-03

DisplayId

629. By Nick Dedekind on 2017-04-03

better lttng deps

628. By Nick Dedekind on 2017-04-03

merged with pre-req

627. By Nick Dedekind on 2017-03-24

merged parent

626. By Nick Dedekind on 2017-03-20

merged with parent

=== modified file 'cmake/modules/UseLttngGenTp.cmake'
--- cmake/modules/UseLttngGenTp.cmake	2014-09-18 16:37:42 +0000
+++ cmake/modules/UseLttngGenTp.cmake	2017-04-06 08:50:29 +0000
@@ -21,4 +21,4 @@
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  DEPENDS "${arg_NAME}.tp"
  )
-endfunction(add_lttng_gen_tp)
\ No newline at end of file
+endfunction(add_lttng_gen_tp)

=== modified file 'debian/changelog'
--- debian/changelog	2017-04-06 08:50:28 +0000
+++ debian/changelog	2017-04-06 08:50:29 +0000
@@ -1,12 +1,14 @@
-qtmir (0.6.0ubuntu3) UNRELEASED; urgency=medium
+qtmir (0.6.0ubuntu4) UNRELEASED; urgency=medium
 
   [ Nick Dedekind ]
   * Introduced QtMir API
   * Support for multiple compositors per MirSurface
   * Support multiple screen windows & cursors with qml instantiation
   * Screen configuration API & implementation
+  * Removed Unity.Screens
+  * Support for workspaces
 
- -- Nick Dedekind <[e-mail]>  Thu, 06 Apr 2017 09:48:21 +0100
+ -- Nick Dedekind <[e-mail]>  Thu, 06 Apr 2017 09:49:24 +0100
 
 qtmir (0.5.1+17.04.20170328-0ubuntu1) zesty; urgency=medium
 

=== modified file 'demos/qml-demo-shell/CMakeLists.txt'
--- demos/qml-demo-shell/CMakeLists.txt	2017-04-06 08:50:28 +0000
+++ demos/qml-demo-shell/CMakeLists.txt	2017-04-06 08:50:29 +0000
@@ -15,6 +15,8 @@
 
 add_executable(${DEMO_SHELL}
     pointerposition.cpp
+    screenwindow.cpp
+    screens.cpp
     main.cpp
 )
 

=== removed file 'demos/qml-demo-shell/Shell.qml'
--- demos/qml-demo-shell/Shell.qml	2017-04-06 08:50:28 +0000
+++ demos/qml-demo-shell/Shell.qml	1970-01-01 00:00:00 +0000
@@ -1,171 +0,0 @@
-import QtQuick 2.4
-import Unity.Application 0.1
-import Mir.Pointer 0.1
-
-FocusScope {
-    id: root
-    focus: true
-
-    Image {
-        id: unityLogo
-        source: "UnityLogo.png"
-        fillMode: Image.PreserveAspectFit
-        anchors.centerIn: parent
-        width: 600
-        height: 600
-
-        RotationAnimation {
-            id: logoAnimation
-            target: unityLogo
-            from: 0
-            to: 359
-            duration: 3000
-            easing.type: Easing.Linear
-            loops: Animation.Infinite
-        }
-
-        MultiPointTouchArea {
-            anchors.fill: parent
-            minimumTouchPoints:1
-            maximumTouchPoints:1
-            onPressed: {
-                if (logoAnimation.paused) {
-                    logoAnimation.resume();
-                } else if (logoAnimation.running) {
-                    logoAnimation.pause();
-                } else {
-                    logoAnimation.start();
-                }
-            }
-        }
-    }
-
-
-    WindowModel {
-        id: windowModel;
-    }
-
-    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
-                visible: surface.visible
-
-                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
-                    }
-                }
-
-                Rectangle { anchors.fill: parent; z: -1; color: "black"; opacity: 0.3 }
-            }
-        }
-    }
-
-    Button {
-        anchors { right: parent.right; top: parent.top }
-        height: 30
-        width: 80
-        text: "Quit"
-        onClicked: Qt.quit()
-    }
-
-    WindowModelDebugView {
-        anchors { right: parent.right; bottom: parent.bottom }
-        model: windowModel
-    }
-
-    Text {
-        anchors { left: parent.left; bottom: parent.bottom }
-        text: "Move window: Ctrl+click\n
-Resize window: Ctrl+Right click"
-    }
-
-    Rectangle {
-        id: mousePointer
-        color: "black"
-        width: 6
-        height: 10
-        x: PointerPosition.x - window.screen.position.x
-        y: PointerPosition.y - window.screen.position.y
-    }
-
-    MouseArea {
-        anchors.fill: parent
-        acceptedButtons: Qt.LeftButton | Qt.RightButton
-        hoverEnabled: false
-        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.requestedPosition = 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;
-        }
-    }
-}

=== modified file 'demos/qml-demo-shell/main.cpp'
--- demos/qml-demo-shell/main.cpp	2017-04-06 08:50:28 +0000
+++ demos/qml-demo-shell/main.cpp	2017-04-06 08:50:29 +0000
@@ -25,6 +25,8 @@
 #include <libintl.h>
 #include "../paths.h"
 #include "pointerposition.h"
+#include "screenwindow.h"
+#include "screens.h"
 
 #include <qtmir/mirserverapplication.h>
 #include <qtmir/displayconfigurationpolicy.h>
@@ -191,6 +193,14 @@
     qmlRegisterSingletonType<PointerPosition>("Mir.Pointer", 0, 1, "PointerPosition",
         [](QQmlEngine*, QJSEngine*) -> QObject* { return PointerPosition::instance(); });
 
+    qmlRegisterType<ScreenWindow>("QtMir", 0, 1, "ScreenWindow");
+    qmlRegisterSingletonType<Screens>("QtMir", 0, 1, "Screens",
+        [](QQmlEngine*, QJSEngine*) -> QObject* {
+            static Screens* screens = new Screens();
+            return screens;
+    });
+    qmlRegisterUncreatableType<qtmir::ScreenMode>("QtMir", 0, 1, "ScreenMode", "ScreenMode is not creatable.");
+
     qmlEngine->load(::qmlDirectory() + "qml-demo-shell/qml-demo-shell.qml");
 
     int result = application->exec();

=== modified file 'demos/qml-demo-shell/qml-demo-shell.qml'
--- demos/qml-demo-shell/qml-demo-shell.qml	2017-04-06 08:50:28 +0000
+++ demos/qml-demo-shell/qml-demo-shell.qml	2017-04-06 08:50:29 +0000
@@ -1,5 +1,5 @@
 import QtQuick 2.5
-import Unity.Screens 0.1
+import QtMir 0.1
 
 Instantiator {
     id: root
@@ -11,6 +11,12 @@
         visible: true
         screen: model.screen
 
+        Binding {
+            target: model.screen
+            property: "active"
+            value: index == 0
+        }
+
         Row {
             x: 10
             y: 10

=== added file 'demos/qml-demo-shell/screens.cpp'
--- demos/qml-demo-shell/screens.cpp	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/screens.cpp	2017-04-06 08:50:29 +0000
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2016-2017 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 "screens.h"
+
+// qtmirserver
+#include <qtmir/qtmir.h>
+#include <qtmir/screens.h>
+#include <qtmir/screen.h>
+#include <QGuiApplication>
+
+// Qt
+#include <QScreen>
+#include <QWindow>
+
+Screens::Screens(QObject *parent)
+    : QAbstractListModel(parent)
+    , m_wrapped(qtmir::get_screen_model())
+{
+    if (qGuiApp->platformName() != QLatin1String("mirserver")) {
+        qCritical("Not using 'mirserver' QPA plugin. Using qGuiApp may produce unknown results.");
+    }
+
+    connect(m_wrapped.data(), &qtmir::Screens::screenAdded, this, &Screens::onScreenAdded);
+    connect(m_wrapped.data(), &qtmir::Screens::screenRemoved, this, &Screens::onScreenRemoved);
+
+    Q_FOREACH(qtmir::Screen* screen, m_wrapped->screens()) {
+        m_screenList.push_back(screen);
+    }
+}
+
+QHash<int, QByteArray> Screens::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[ScreenRole] = "screen";
+    return roles;
+}
+
+QVariant Screens::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() >= m_screenList.size()) {
+        return QVariant();
+    }
+
+    switch(role) {
+    case ScreenRole:
+        return QVariant::fromValue(m_screenList.at(index.row()));
+    } // switch
+
+    return QVariant();
+}
+
+int Screens::rowCount(const QModelIndex &) const
+{
+    return m_screenList.size();
+}
+
+void Screens::onScreenAdded(qtmir::Screen *screen)
+{
+    Q_FOREACH(auto screenWrapper, m_screenList) {
+        if (screenWrapper == screen) return;
+    }
+
+    beginInsertRows(QModelIndex(), m_screenList.count(), m_screenList.count());
+    m_screenList.push_back(screen);
+    endInsertRows();
+    Q_EMIT screenAdded(screen);
+}
+
+void Screens::onScreenRemoved(qtmir::Screen *screen)
+{
+    int index = 0;
+    QMutableListIterator<qtmir::Screen*> iter(m_screenList);
+    while(iter.hasNext()) {
+        auto screenWrapper = iter.next();
+        if (screenWrapper == screen) {
+
+            beginRemoveRows(QModelIndex(), index, index);
+            iter.remove();
+            endRemoveRows();
+
+            Q_EMIT screenRemoved(screen);
+            break;
+        }
+        index++;
+    }
+}

=== added file 'demos/qml-demo-shell/screens.h'
--- demos/qml-demo-shell/screens.h	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/screens.h	2017-04-06 08:50:29 +0000
@@ -0,0 +1,58 @@
+/*
+ * 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 UNITY_SCREENS_H
+#define UNITY_SCREENS_H
+
+#include <QAbstractListModel>
+#include <QSharedPointer>
+
+namespace qtmir
+{
+class Screen;
+class Screens;
+}
+
+class Screens : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    enum ItemRoles {
+        ScreenRole = Qt::UserRole + 1
+    };
+
+    explicit Screens(QObject *parent = 0);
+    virtual ~Screens() noexcept = default;
+
+    /* QAbstractItemModel */
+    QHash<int, QByteArray> roleNames() const override;
+    QVariant data(const QModelIndex &index, int role = ScreenRole) const override;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+Q_SIGNALS:
+    void screenAdded(qtmir::Screen* screen);
+    void screenRemoved(qtmir::Screen* screen);
+
+private Q_SLOTS:
+    void onScreenAdded(qtmir::Screen *screen);
+    void onScreenRemoved(qtmir::Screen *screen);
+
+private:
+    QList<qtmir::Screen*> m_screenList;
+    QSharedPointer<qtmir::Screens> m_wrapped;
+};
+
+#endif // SCREENS_H

=== added file 'demos/qml-demo-shell/screenwindow.cpp'
--- demos/qml-demo-shell/screenwindow.cpp	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/screenwindow.cpp	2017-04-06 08:50:29 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2016-2017 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 "screenwindow.h"
+
+// Qt
+#include <QGuiApplication>
+#include <QDebug>
+
+ScreenWindow::ScreenWindow(QQuickWindow *parent)
+    : QQuickWindow(parent)
+{
+    if (qGuiApp->platformName() != QLatin1String("mirserver")) {
+        qCritical("Not using 'mirserver' QPA plugin. Using ScreenWindow may produce unknown results.");
+    }
+}
+
+ScreenWindow::~ScreenWindow()
+{
+}
+
+qtmir::Screen *ScreenWindow::screenWrapper() const
+{
+    return m_screen.data();
+}
+
+void ScreenWindow::setScreenWrapper(qtmir::Screen *screen)
+{
+    if (m_screen != screen) {
+        m_screen = screen;
+        Q_EMIT screenWrapperChanged();
+    }
+    QQuickWindow::setScreen(screen->qscreen());
+}

=== added file 'demos/qml-demo-shell/screenwindow.h'
--- demos/qml-demo-shell/screenwindow.h	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/screenwindow.h	2017-04-06 08:50:29 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2016-2017 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 UNITY_SCREENWINDOW_H
+#define UNITY_SCREENWINDOW_H
+
+#include <QQuickWindow>
+#include <QPointer>
+
+#include "qtmir/screen.h"
+
+class ScreenAdapter;
+
+/*
+ * ScreenWindow - wrapper of QQuickWindow to enable QML to specify destination screen.
+**/
+class ScreenWindow : public QQuickWindow
+{
+    Q_OBJECT
+    Q_PROPERTY(qtmir::Screen *screen READ screenWrapper WRITE setScreenWrapper NOTIFY screenWrapperChanged)
+    Q_PROPERTY(int winId READ winId CONSTANT)
+public:
+    explicit ScreenWindow(QQuickWindow *parent = 0);
+    ~ScreenWindow();
+
+    qtmir::Screen *screenWrapper() const;
+    void setScreenWrapper(qtmir::Screen *screen);
+
+Q_SIGNALS:
+    void screenWrapperChanged();
+
+private:
+    QPointer<qtmir::Screen> m_screen;
+};
+
+#endif // UNITY_SCREENWINDOW_H

=== modified file 'include/qtmir/miral/display_configuration_storage.h'
--- include/qtmir/miral/display_configuration_storage.h	2017-04-06 08:50:28 +0000
+++ include/qtmir/miral/display_configuration_storage.h	2017-04-06 08:50:29 +0000
@@ -19,22 +19,16 @@
 #ifndef MIRAL_DISPLAY_CONFIGURATION_STORAGE_H
 #define MIRAL_DISPLAY_CONFIGURATION_STORAGE_H
 
-#include "mir/geometry/rectangle.h"
-#include "mir/optional_value.h"
-#include "mir_toolkit/common.h"
+#include <mir/geometry/rectangle.h>
+#include <mir/optional_value.h>
+#include <mir_toolkit/common.h>
 
-#include "edid.h"
+#include "display_id.h"
 
 // Prototyping namespace for later incorporation in MirAL
 namespace miral
 {
 
-struct DisplayId
-{
-    Edid edid;
-    int output_id; // helps to identify a monitor if we have two of the same.
-};
-
 struct DisplayConfigurationOptions
 {
     mir::optional_value<bool> used;
@@ -59,6 +53,6 @@
     virtual bool load(const DisplayId&, DisplayConfigurationOptions&) const = 0;
 };
 
-}
+} // namespace miral
 
 #endif // MIRAL_DISPLAY_CONFIGURATION_STORAGE_H

=== added file 'include/qtmir/miral/display_id.h'
--- include/qtmir/miral/display_id.h	1970-01-01 00:00:00 +0000
+++ include/qtmir/miral/display_id.h	2017-04-06 08:50:29 +0000
@@ -0,0 +1,23 @@
+#ifndef MIRAL_DISPLAY_ID_H
+#define MIRAL_DISPLAY_ID_H
+
+#include <mir/int_wrapper.h>
+
+#include "edid.h"
+
+namespace mir { namespace graphics { namespace detail { struct GraphicsConfOutputIdTag; } } }
+
+// Prototyping namespace for later incorporation in MirAL
+namespace miral
+{
+using OutputId = mir::IntWrapper<mir::graphics::detail::GraphicsConfOutputIdTag>;
+
+struct DisplayId
+{
+    Edid edid;
+    OutputId output_id; // helps to identify a monitor if we have two of the same.
+};
+
+} // namespace miral
+
+#endif // MIRAL_DISPLAY_ID_H

=== modified file 'include/qtmir/mirserverapplication.h'
--- include/qtmir/mirserverapplication.h	2017-04-06 08:50:28 +0000
+++ include/qtmir/mirserverapplication.h	2017-04-06 08:50:29 +0000
@@ -22,9 +22,20 @@
 // std
 #include <functional>
 
+#if defined(qApp)
+#undef qApp
+#endif
+#define qApp (static_cast<qtmir::GuiServerApplication *>(QCoreApplication::instance()))
+
+#if defined(qGuiApp)
+#undef qGuiApp
+#endif
+#define qGuiApp (static_cast<qtmir::GuiServerApplication *>(QCoreApplication::instance()))
+
 class QMirServer;
 
-namespace qtmir {
+namespace qtmir
+{
 
 class WindowModelNotifier;
 class AppNotifier;

=== added file 'include/qtmir/qtmir.h'
--- include/qtmir/qtmir.h	1970-01-01 00:00:00 +0000
+++ include/qtmir/qtmir.h	2017-04-06 08:50:29 +0000
@@ -0,0 +1,14 @@
+#ifndef QTMIR_H
+#define QTMIR_H
+
+#include <QSharedPointer>
+
+namespace qtmir
+{
+class Screens;
+
+QSharedPointer<Screens> get_screen_model();
+
+}
+
+#endif // QTMIR_H

=== added file 'include/qtmir/screen.h'
--- include/qtmir/screen.h	1970-01-01 00:00:00 +0000
+++ include/qtmir/screen.h	2017-04-06 08:50:29 +0000
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QTMIR_SCREEN_H
+#define QTMIR_SCREEN_H
+
+#include <qtmir/types.h>
+#include <qtmir/miral/display_id.h>
+
+#include <QObject>
+#include <QPointer>
+
+#include <QQmlListProperty>
+#include <QSize>
+#include <QPoint>
+
+#include <mir_toolkit/common.h>
+
+class QScreen;
+
+namespace qtmir {
+
+class ScreenMode;
+class ScreenConfiguration;
+
+class Screen : public QObject
+{
+    Q_OBJECT
+public:
+    virtual miral::DisplayId displayId() const = 0;
+    virtual bool used() const = 0;
+    virtual QString name() const = 0;
+    virtual float scale() const = 0;
+    virtual QSizeF physicalSize() const = 0;
+    virtual qtmir::FormFactor formFactor() const = 0;
+    virtual qtmir::OutputTypes outputType() const = 0;
+    virtual MirPowerMode powerMode() const = 0;
+    virtual Qt::ScreenOrientation orientation() const = 0;
+    virtual QPoint position() const = 0;
+    virtual QQmlListProperty<qtmir::ScreenMode> availableModes() = 0;
+    virtual uint currentModeIndex() const = 0;
+    virtual bool isActive() const = 0;
+    virtual void setActive(bool active) = 0;
+
+    virtual QScreen* qscreen() const = 0;
+
+    virtual ScreenConfiguration *beginConfiguration() const = 0;
+    virtual bool applyConfiguration(ScreenConfiguration *configuration) = 0;
+
+Q_SIGNALS:
+    void usedChanged();
+    void nameChanged();
+    void outputTypeChanged();
+    void scaleChanged();
+    void formFactorChanged();
+    void powerModeChanged();
+    void orientationChanged();
+    void positionChanged();
+    void currentModeIndexChanged();
+    void physicalSizeChanged();
+    void availableModesChanged();
+    void activeChanged(bool active);
+
+protected:
+    Screen(QObject* parent = 0): QObject(parent) {}
+};
+
+class ScreenMode : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal refreshRate MEMBER refreshRate CONSTANT)
+    Q_PROPERTY(QSize size MEMBER size CONSTANT)
+public:
+    ScreenMode():refreshRate(-1) {}
+    ScreenMode(qreal refreshRate, const QSize& size)
+          : refreshRate{refreshRate},size{size}
+    {}
+
+    qreal refreshRate;
+    QSize size;
+};
+
+struct ScreenConfiguration
+{
+    bool valid{false};
+    miral::OutputId id;
+
+    bool used;
+    QPoint topLeft;
+    uint32_t currentModeIndex;
+    MirPowerMode powerMode;
+    MirOrientation orientation;
+    float scale;
+    qtmir::FormFactor formFactor;
+};
+
+typedef QVector<ScreenConfiguration> ScreenConfigurationList;
+
+}
+
+Q_DECLARE_METATYPE(qtmir::Screen*)
+Q_DECLARE_METATYPE(qtmir::ScreenMode*)
+Q_DECLARE_METATYPE(qtmir::ScreenConfiguration*)
+
+Q_DECLARE_METATYPE(MirPowerMode)
+
+#endif // SCREEN_H

=== added file 'include/qtmir/screens.h'
--- include/qtmir/screens.h	1970-01-01 00:00:00 +0000
+++ include/qtmir/screens.h	2017-04-06 08:50:29 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QTMIR_SCREENS_H
+#define QTMIR_SCREENS_H
+
+#include <QObject>
+#include <QVector>
+
+class QScreen;
+
+namespace qtmir
+{
+class Screen;
+
+class Screens : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qtmir::Screen* activeScreen READ activeScreen NOTIFY activeScreenChanged)
+public:
+    Screens(QObject *parent = 0): QObject(parent) {}
+    ~Screens() = default;
+
+    virtual QVector<qtmir::Screen*> screens() const = 0;
+
+    virtual qtmir::Screen* activeScreen() const = 0;
+
+Q_SIGNALS:
+    void screenAdded(qtmir::Screen *screen);
+    void screenRemoved(qtmir::Screen *screen);
+
+    void activeScreenChanged();
+};
+
+} // namespace qtmir
+
+#endif // QTMIR_SCREENS_H

=== renamed file 'src/platforms/mirserver/screentypes.h' => 'include/qtmir/types.h'
--- src/platforms/mirserver/screentypes.h	2017-04-06 08:50:28 +0000
+++ include/qtmir/types.h	2017-04-06 08:50:29 +0000
@@ -21,11 +21,8 @@
 
 #include <QtCore/qmetatype.h>
 
-namespace mir { namespace graphics { namespace detail { struct GraphicsConfOutputIdTag; } } }
-
 namespace qtmir
 {
-using OutputId = mir::IntWrapper<mir::graphics::detail::GraphicsConfOutputIdTag>;
 
 enum OutputTypes {
     Unknown,

=== modified file 'include/qtmir/windowmanagementpolicy.h'
--- include/qtmir/windowmanagementpolicy.h	2017-04-06 08:50:28 +0000
+++ include/qtmir/windowmanagementpolicy.h	2017-04-06 08:50:29 +0000
@@ -18,7 +18,8 @@
 #define QTMIR_WINDOWMANAGEMENTPOLICY_H
 
 // miral
-#include "miral/canonical_window_manager.h"
+#include <miral/canonical_window_manager.h>
+#include <miral/workspace_policy.h>
 #include <miral/version.h>
 #if MIRAL_VERSION > MIR_VERSION_NUMBER(1,3,1)
 #include <miral/set_window_management_policy.h>
@@ -43,7 +44,8 @@
 /*
     Provides window management callbacks for window behaviour customization
  */
-class WindowManagementPolicy : public miral::CanonicalWindowManagerPolicy
+class WindowManagementPolicy : public miral::CanonicalWindowManagerPolicy,
+                               public miral::WorkspacePolicy
 {
 public:
 
@@ -77,7 +79,12 @@
     void advise_delete_window(const miral::WindowInfo &windowInfo) override;
     void advise_raise(const std::vector<miral::Window> &windows) override;
 
-    Rectangle confirm_inherited_move(miral::WindowInfo const& windowInfo, Displacement movement) override;
+    Rectangle confirm_inherited_move(const miral::WindowInfo &windowInfo, Displacement movement) override;
+
+    void advise_adding_to_workspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                    const std::vector<miral::Window> &windows) override;
+    void advise_removing_from_workspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                        const std::vector<miral::Window> &windows) override;
 
 protected:
     WindowManagementPolicy(const miral::WindowManagerTools &tools, std::shared_ptr<qtmir::WindowManagementPolicyPrivate> dd);

=== modified file 'src/common/windowmodelnotifier.h'
--- src/common/windowmodelnotifier.h	2017-03-24 11:29:56 +0000
+++ src/common/windowmodelnotifier.h	2017-04-06 08:50:29 +0000
@@ -23,6 +23,7 @@
 #include <QMutex>
 
 #include <miral/window_info.h>
+#include <miral/workspace_policy.h>
 
 // Unity API
 #include <unity/shell/application/Mir.h>
@@ -71,7 +72,7 @@
 {
     Q_OBJECT
 public:
-    WindowModelNotifier() = default;
+    WindowModelNotifier();
 
 Q_SIGNALS: // **Must used Queued Connection or else events will be out of order**
     void windowAdded(const qtmir::NewWindow &window);
@@ -83,6 +84,9 @@
     void windowFocusChanged(const miral::WindowInfo &window, bool focused);
     void windowsRaised(const std::vector<miral::Window> &windows); // results in deep copy when passed over Queued connection:(
     void windowRequestedRaise(const miral::WindowInfo &window);
+    void windowsAddedToWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows);
+    void windowsAboutToBeRemovedFromWorkspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                              const std::vector<miral::Window> &windows);
     void modificationsStarted();
     void modificationsEnded();
 
@@ -90,6 +94,26 @@
     Q_DISABLE_COPY(WindowModelNotifier)
 };
 
+class WindowNotifierObserver : public QObject
+{
+    Q_OBJECT
+public:
+    WindowNotifierObserver(const miral::Window &window);
+    virtual ~WindowNotifierObserver();
+
+    static void foreachObserverForWindow(const miral::Window &window, std::function<void(WindowNotifierObserver*)> fn);
+
+Q_SIGNALS:
+    void windowCreated();
+    void windowRemoved();
+    void windowReady();
+    void windowMoved(const QPoint &topLeft);
+    void windowResized(const QSize &size);
+    void windowStateChanged(Mir::State state);
+    void windowFocusChanged(bool focused);
+    void windowRequestedRaise();
+};
+
 } // namespace qtmir
 
 Q_DECLARE_METATYPE(qtmir::NewWindow)

=== added file 'src/common/workspacecontrollerinterface.h'
--- src/common/workspacecontrollerinterface.h	1970-01-01 00:00:00 +0000
+++ src/common/workspacecontrollerinterface.h	2017-04-06 08:50:29 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2017 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 WORKSPACECONTROLLERINTERFACE_H
+#define WORKSPACECONTROLLERINTERFACE_H
+
+#include <miral/window.h>
+
+#include <mir_toolkit/event.h>
+
+#include <QPoint>
+#include <QSize>
+
+// Unity API
+#include <unity/shell/application/Mir.h>
+
+namespace miral { class Workspace; }
+
+namespace qtmir {
+
+class WorkspaceControllerInterface {
+public:
+    WorkspaceControllerInterface() = default;
+    virtual ~WorkspaceControllerInterface() = default;
+
+    virtual void forEachWindowInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                   const std::function<void (const miral::Window &)> &callback) = 0;
+
+    virtual void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,
+                                                 const std::shared_ptr<miral::Workspace> &from) = 0;
+    virtual void moveWindowToWorkspace(const miral::Window &window,
+                                       const std::shared_ptr<miral::Workspace> &workspace) = 0;
+};
+
+} // namespace qtmir
+
+#endif // WINDOWCONTROLLERINTERFACE_H

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2017-04-06 08:50:29 +0000
@@ -1,3 +1,5 @@
+include(UseLttngGenTp)
+
 include_directories(
     ${CMAKE_SOURCE_DIR}/include
     ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
@@ -29,6 +31,12 @@
 # Needed to compile tracepoints in C99 mode.
 add_definitions(-DBYTE_ORDER=__BYTE_ORDER)
 
+# Generate tracepoints.c and .h from tracepoints.tp
+add_lttng_gen_tp(NAME tracepoints)
+add_custom_target(UnityApplication_LTTNG
+    DEPENDS tracepoints.h tracepoints.c
+)
+
 set(QMLMIRPLUGIN_SRC
     application_manager.cpp
     application.cpp
@@ -68,11 +76,12 @@
     applicationinfo.h
     taskcontroller.h
     settings_interface.h
-    )
+)
 
 add_library(unityapplicationplugin SHARED
     ${QMLMIRPLUGIN_SRC}
 )
+add_dependencies(unityapplicationplugin UnityApplication_LTTNG)
 
 # Frig for files that still rely on mirserver-dev
 string(REPLACE ";" " -I" QTMIR_ADD_MIRSERVER "-I ${MIRSERVER_INCLUDE_DIRS}")
@@ -101,10 +110,6 @@
     qtmirserver
 )
 
-# Generate tracepoints.c and .h from tracepoints.tp
-include(UseLttngGenTp)
-add_lttng_gen_tp(NAME tracepoints)
-
 
 # install
 add_qml_plugin(Unity.Application 0.1 Unity/Application TARGETS unityapplicationplugin)

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2017-03-28 17:12:54 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2017-04-06 08:50:29 +0000
@@ -120,7 +120,7 @@
 
 ApplicationManager* ApplicationManager::singleton()
 {
-    static ApplicationManager* instance;
+    static ApplicationManager* instance{nullptr};
     if (!instance) {
         instance = create();
     }

=== modified file 'src/modules/Unity/Application/mirsurface.cpp'
--- src/modules/Unity/Application/mirsurface.cpp	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Application/mirsurface.cpp	2017-04-06 08:50:29 +0000
@@ -19,8 +19,10 @@
 #include "mirsurfacelistmodel.h"
 #include "namedcursor.h"
 #include "session_interface.h"
+#include "surfacemanager.h"
 #include "timer.h"
 #include "timestamp.h"
+#include "tracepoints.h"
 
 // from common dir
 #include <debughelpers.h>
@@ -122,6 +124,33 @@
     QMap<QByteArray, Qt::CursorShape> m_cursorNameToShape;
 };
 
+class MirSurface::WindowNotifierObserverImpl : public WindowNotifierObserver
+{
+public:
+    WindowNotifierObserverImpl(MirSurface* surface, const miral::Window &window)
+        : WindowNotifierObserver(window)
+    {
+        connect(this, &WindowNotifierObserver::windowRemoved, this, [surface]() {
+            surface->setLive(false);
+        });
+        connect(this, &WindowNotifierObserver::windowReady, this, [surface]() {
+            tracepoint(qtmir, firstFrameDrawn); // MirAL decides surface ready when it swaps its first frame
+            surface->setReady();
+        });
+        connect(this, &WindowNotifierObserver::windowMoved, this, [surface](const QPoint topLeft) {
+            surface->setPosition(topLeft);
+        });
+        connect(this, &WindowNotifierObserver::windowStateChanged, this, [surface](Mir::State state) {
+            surface->updateState(state);
+        });
+        connect(this, &WindowNotifierObserver::windowFocusChanged,   this, [surface]( bool focused) {
+            surface->setFocused(focused);
+        });
+        connect(this, &WindowNotifierObserver::windowRequestedRaise, this, [surface]() {
+            surface->requestFocus();
+        });
+    }
+};
 
 MirSurface::MirSurface(NewWindow newWindowInfo,
         WindowControllerInterface* controller,
@@ -146,6 +175,7 @@
     , m_visible(newWindowInfo.windowInfo.is_visible())
     , m_live(true)
     , m_surfaceObserver(std::make_shared<SurfaceObserverImpl>())
+    , m_windowModelObserver(std::make_shared<WindowNotifierObserverImpl>(this, m_window))
     , m_size(toQSize(m_window.size()))
     , m_state(toQtState(newWindowInfo.windowInfo.state()))
     , m_shellChrome(toQtShellChrome(newWindowInfo.windowInfo.shell_chrome()))

=== modified file 'src/modules/Unity/Application/mirsurface.h'
--- src/modules/Unity/Application/mirsurface.h	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Application/mirsurface.h	2017-04-06 08:50:29 +0000
@@ -55,7 +55,7 @@
     Q_OBJECT
 
 public:
-    MirSurface(NewWindow windowInfo,
+    MirSurface(qtmir::NewWindow windowInfo,
                WindowControllerInterface *controller,
                SessionInterface *session = nullptr,
                MirSurface *parentSurface = nullptr);
@@ -263,6 +263,8 @@
 
     class SurfaceObserverImpl;
     std::shared_ptr<SurfaceObserverImpl> m_surfaceObserver;
+    class WindowNotifierObserverImpl;
+    std::shared_ptr<WindowNotifierObserverImpl> m_windowModelObserver;
 
     QPoint m_position;
     QPoint m_requestedPosition;

=== modified file 'src/modules/Unity/Application/plugin.cpp'
--- src/modules/Unity/Application/plugin.cpp	2017-01-18 21:24:15 +0000
+++ src/modules/Unity/Application/plugin.cpp	2017-04-06 08:50:29 +0000
@@ -49,6 +49,10 @@
 QObject* mirSingleton(QQmlEngine* /*engine*/, QJSEngine* /*scriptEngine*/) {
     return qtmir::Mir::instance();
 }
+
+QObject* surfaceManagerSingleton(QQmlEngine* /*engine*/, QJSEngine* /*scriptEngine*/) {
+    return qtmir::SurfaceManager::instance();
+}
 } // anonymous namespace
 
 class UnityApplicationPlugin : public QQmlExtensionPlugin {
@@ -67,6 +71,8 @@
         qRegisterMetaType<unity::shell::application::SurfaceManagerInterface*>("unity::shell::application::SurfaceManagerInterface*");
         qRegisterMetaType<MirWindowAttrib>("MirWindowAttrib");
 
+        qRegisterMetaType<std::shared_ptr<miral::Workspace>>("std::shared_ptr<miral::Workspace>");
+
         qmlRegisterUncreatableType<unity::shell::application::ApplicationManagerInterface>(
                     uri, 0, 1, "ApplicationManagerInterface", "Abstract interface. Cannot be created in QML");
         qmlRegisterSingletonType<qtmir::ApplicationManager>(
@@ -79,7 +85,7 @@
                     uri, 0, 1, "MirSurface", "MirSurface can't be instantiated from QML");
         qmlRegisterType<qtmir::MirSurfaceItem>(uri, 0, 1, "MirSurfaceItem");
         qmlRegisterSingletonType<qtmir::Mir>(uri, 0, 1, "Mir", mirSingleton);
-        qmlRegisterType<qtmir::SurfaceManager>(uri, 0, 1, "SurfaceManager");
+        qmlRegisterSingletonType<qtmir::SurfaceManager>(uri, 0, 1, "SurfaceManager", surfaceManagerSingleton);
 
         qmlRegisterType<qtmir::WindowModel>(uri, 0, 1, "WindowModel");
     }

=== modified file 'src/modules/Unity/Application/surfacemanager.cpp'
--- src/modules/Unity/Application/surfacemanager.cpp	2017-03-20 16:19:42 +0000
+++ src/modules/Unity/Application/surfacemanager.cpp	2017-04-06 08:50:29 +0000
@@ -26,6 +26,7 @@
 // common
 #include <debughelpers.h>
 #include <mirqtconversion.h>
+#include <workspacecontrollerinterface.h>
 
 // Qt
 #include <QGuiApplication>
@@ -38,6 +39,14 @@
 using namespace qtmir;
 namespace unityapi = unity::shell::application;
 
+SurfaceManager *SurfaceManager::instance()
+{
+    static SurfaceManager* instance{nullptr};
+    if (!instance) {
+        instance = new SurfaceManager;
+    }
+    return instance;
+}
 
 SurfaceManager::SurfaceManager()
 {
@@ -51,6 +60,7 @@
 
     m_sessionMap = ApplicationManager::singleton();
     m_windowController = static_cast<WindowControllerInterface*>(nativeInterface->nativeResourceForIntegration("WindowController"));
+    m_workspaceController = static_cast<WorkspaceControllerInterface*>(nativeInterface->nativeResourceForIntegration("WorkspaceController"));
 
     auto windowModel = static_cast<WindowModelNotifier*>(nativeInterface->nativeResourceForIntegration("WindowModelNotifier"));
     connectToWindowModelNotifier(windowModel);
@@ -68,31 +78,71 @@
 
 void SurfaceManager::connectToWindowModelNotifier(WindowModelNotifier *notifier)
 {
-    connect(notifier, &WindowModelNotifier::windowAdded,          this, &SurfaceManager::onWindowAdded,           Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowRemoved,        this, &SurfaceManager::onWindowRemoved,         Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowReady,          this, &SurfaceManager::onWindowReady,           Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowMoved,          this, &SurfaceManager::onWindowMoved,           Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowStateChanged,   this, &SurfaceManager::onWindowStateChanged,    Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowFocusChanged,   this, &SurfaceManager::onWindowFocusChanged,    Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowsRaised,        this, &SurfaceManager::onWindowsRaised,         Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowRequestedRaise, this, &SurfaceManager::onWindowsRequestedRaise, Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::modificationsStarted, this, &SurfaceManager::modificationsStarted,    Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::modificationsEnded,   this, &SurfaceManager::modificationsEnded,      Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowAdded,
+            this, &SurfaceManager::onWindowAdded, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::windowRemoved,
+            this, &SurfaceManager::onWindowRemoved, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::windowReady,
+            this, [this](const miral::WindowInfo &windowInfo) {
+        Q_EMIT surfaceReady(surfaceFor(windowInfo.window()));
+    }, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::windowMoved,
+            this, [this](const miral::WindowInfo &windowInfo, const QPoint &top_left) {
+        Q_EMIT surfaceMoved(surfaceFor(windowInfo.window()), top_left);
+    }, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::windowResized,
+            this, [this](const miral::WindowInfo &windowInfo, const QSize &size) {
+        Q_EMIT surfaceResized(surfaceFor(windowInfo.window()), size);
+    }, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::windowStateChanged,
+            this, [this](const miral::WindowInfo &windowInfo, Mir::State state) {
+        Q_EMIT surfaceStateChanged(surfaceFor(windowInfo.window()), state);
+    }, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::windowFocusChanged,
+            this, [this](const miral::WindowInfo &windowInfo, bool focused) {
+        Q_EMIT surfaceFocusChanged(surfaceFor(windowInfo.window()), focused);
+    }, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::windowRequestedRaise,
+            this, [this](const miral::WindowInfo &windowInfo) {
+        Q_EMIT surfaceRequestedRaise(surfaceFor(windowInfo.window()));
+    }, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::windowsRaised,
+            this, [this](const std::vector<miral::Window> &windows) {
+        Q_EMIT surfacesRaised(surfacesFor(windows));
+    }, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::windowsAddedToWorkspace,
+            this, [this](const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows) {
+        Q_EMIT surfacesAddedToWorkspace(workspace, surfacesFor(windows));
+    }, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::windowsAboutToBeRemovedFromWorkspace,
+            this, [this](const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows) {
+        Q_EMIT surfacesAboutToBeRemovedFromWorkspace(workspace, surfacesFor(windows));
+    }, Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::modificationsEnded,   this, &SurfaceManager::modificationsEnded,    Qt::QueuedConnection);
+
+    connect(notifier, &WindowModelNotifier::modificationsStarted, this, &SurfaceManager::modificationsStarted,  Qt::QueuedConnection);
 }
 
 void SurfaceManager::rememberMirSurface(MirSurface *surface)
 {
-    m_allSurfaces.append(surface);
+    surface_to_window.insert({ surface, surface->window() });
 }
 
 void SurfaceManager::forgetMirSurface(const miral::Window &window)
 {
-    for (int i = 0; i < m_allSurfaces.count(); ++i) {
-        if (m_allSurfaces[i]->window() == window) {
-            m_allSurfaces.removeAt(i);
-            return;
-        }
-    }
+    std::shared_ptr<mir::scene::Surface> msSurface = window;
+    surface_to_window.right.erase(window);
 }
 
 void SurfaceManager::onWindowAdded(const NewWindow &window)
@@ -109,7 +159,7 @@
     auto mirSession = windowInfo.window().application();
     SessionInterface* session = m_sessionMap->findSession(mirSession.get());
 
-    const auto parentSurface = find(windowInfo.parent());
+    const auto parentSurface = surfaceFor(windowInfo.parent());
     const auto surface = new MirSurface(window, m_windowController, session, parentSurface);
     rememberMirSurface(surface);
 
@@ -136,85 +186,49 @@
 void SurfaceManager::onWindowRemoved(const miral::WindowInfo &windowInfo)
 {
     DEBUG_MSG << "()";
-    MirSurface *surface = find(windowInfo);
+    MirSurface *surface = surfaceFor(windowInfo.window());
     forgetMirSurface(windowInfo.window());
-    if (surface && surface->isBeingDisplayed()) {
-        surface->setLive(false);
-    } else {
+
+    if (!surface) return;
+    Q_EMIT surfaceRemoved(surface);
+
+    if (!surface->isBeingDisplayed()) {
         delete surface;
         tracepoint(qtmir, surfaceDestroyed);
     }
 }
 
-MirSurface *SurfaceManager::find(const miral::WindowInfo &needle) const
-{
-    return find(needle.window());
-}
-
-MirSurface *SurfaceManager::find(const miral::Window &window) const
-{
-    Q_FOREACH(const auto surface, m_allSurfaces) {
-        if (surface->window() == window) {
-            return surface;
-        }
+MirSurface *SurfaceManager::surfaceFor(const miral::Window &window) const
+{
+    auto window_iterator = surface_to_window.right.find(window);
+    if(window_iterator != surface_to_window.right.end()) {
+        return window_iterator->second;
     }
     return nullptr;
 }
 
-void SurfaceManager::onWindowReady(const miral::WindowInfo &windowInfo)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        tracepoint(qtmir, firstFrameDrawn); // MirAL decides surface ready when it swaps its first frame
-        mirSurface->setReady();
-    }
-}
-
-void SurfaceManager::onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->setPosition(topLeft);
-    }
-}
-
-void SurfaceManager::onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->setFocused(focused);
-    }
-}
-
-void SurfaceManager::onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->updateState(state);
-    }
-}
-
-void SurfaceManager::onWindowsRaised(const std::vector<miral::Window> &windows)
-{
-    // sad inefficiency when crossing API boundaries (from miral to qt)
-
-    const int raiseCount = windows.size();
-
-    DEBUG_MSG << "() raiseCount = " << raiseCount;
-
-    QVector<unityapi::MirSurfaceInterface*> surfaces(raiseCount);
-    for (int i = 0; i < raiseCount; i++) {
-        auto mirSurface = find(windows[i]);
+QVector<unity::shell::application::MirSurfaceInterface *> SurfaceManager::surfacesFor(const std::vector<miral::Window> &windows) const
+{
+    QVector<unityapi::MirSurfaceInterface*> surfaces;
+    for (size_t i = 0; i < windows.size(); i++) {
+        auto mirSurface = surfaceFor(windows[i]);
         if (mirSurface) {
-            surfaces[i] = mirSurface;
+            surfaces.push_back(mirSurface);
         } else {
-            WARNING_MSG << " Could not find qml surface for " << windows[i];
+            std::shared_ptr<mir::scene::Surface> ms = windows[i];
+            WARNING_MSG << " Could not find qml surface for " << ms.get();
         }
     }
-    Q_EMIT surfacesRaised(surfaces);
+    return surfaces;
 }
 
-void SurfaceManager::onWindowsRequestedRaise(const miral::WindowInfo &windowInfo)
+miral::Window SurfaceManager::windowFor(MirSurface *surface) const
 {
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->requestFocus();
+    auto window_iterator = surface_to_window.left.find(surface);
+    if(window_iterator != surface_to_window.left.end()) {
+        return window_iterator->second;
     }
+    return miral::Window();
 }
 
 void SurfaceManager::raise(unityapi::MirSurfaceInterface *surface)
@@ -226,6 +240,32 @@
 
 void SurfaceManager::activate(unityapi::MirSurfaceInterface *surface)
 {
-    auto qtmirSurface = static_cast<qtmir::MirSurface*>(surface);
+    auto qtmirSurface = static_cast<MirSurface*>(surface);
     m_windowController->activate(qtmirSurface ? qtmirSurface->window() : miral::Window());
 }
+
+void SurfaceManager::forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                               const std::function<void(unity::shell::application::MirSurfaceInterface *)> &callback)
+{
+    m_workspaceController->forEachWindowInWorkspace(workspace, [&](const miral::Window &window) {
+        auto surface = surfaceFor(window);
+        if (surface) {
+            callback(surface);
+        }
+    });
+}
+
+void SurfaceManager::moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface *surface,
+                                            const std::shared_ptr<miral::Workspace> &workspace)
+{
+    miral::Window window = windowFor(static_cast<qtmir::MirSurface*>(surface));
+    if (window) {
+        m_workspaceController->moveWindowToWorkspace(window, workspace);
+    }
+}
+
+void SurfaceManager::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,
+                                                     const std::shared_ptr<miral::Workspace> &from)
+{
+    m_workspaceController->moveWorkspaceContentToWorkspace(to, from);
+}

=== modified file 'src/modules/Unity/Application/surfacemanager.h'
--- src/modules/Unity/Application/surfacemanager.h	2017-03-20 16:19:42 +0000
+++ src/modules/Unity/Application/surfacemanager.h	2017-04-06 08:50:29 +0000
@@ -26,6 +26,8 @@
 #include <QVector>
 #include <QLoggingCategory>
 
+#include <boost/bimap.hpp>
+
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_SURFACEMANAGER)
 
 namespace qtmir {
@@ -33,46 +35,56 @@
 class MirSurface;
 class SessionMapInterface;
 class WindowControllerInterface;
+class WorkspaceControllerInterface;
 
 class SurfaceManager : public unity::shell::application::SurfaceManagerInterface
 {
     Q_OBJECT
 
 public:
-    explicit SurfaceManager();
     SurfaceManager(WindowControllerInterface *windowController,
                    WindowModelNotifier *windowModel,
                    SessionMapInterface *sessionMap);
     virtual ~SurfaceManager() {}
 
+    static SurfaceManager *instance();
+
     void raise(unity::shell::application::MirSurfaceInterface *surface) override;
     void activate(unity::shell::application::MirSurfaceInterface *surface) override;
 
+    void forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                   const std::function<void(unity::shell::application::MirSurfaceInterface*)> &callback) override;
+    void moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface* surface,
+                                const std::shared_ptr<miral::Workspace> &workspace) override;
+    void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,
+                                         const std::shared_ptr<miral::Workspace> &from) override;
+
     // mainly for test usage
-    MirSurface* find(const miral::WindowInfo &needle) const;
+    MirSurface* surfaceFor(const miral::Window &window) const;
 
 private Q_SLOTS:
     void onWindowAdded(const qtmir::NewWindow &windowInfo);
     void onWindowRemoved(const miral::WindowInfo &windowInfo);
-    void onWindowReady(const miral::WindowInfo &windowInfo);
-    void onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft);
-    void onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state);
-    void onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused);
-    void onWindowsRaised(const std::vector<miral::Window> &windows);
-    void onWindowsRequestedRaise(const miral::WindowInfo &windowInfo);
-
 private:
+    explicit SurfaceManager();
+
     void connectToWindowModelNotifier(WindowModelNotifier *notifier);
     void rememberMirSurface(MirSurface *surface);
     void forgetMirSurface(const miral::Window &window);
-    MirSurface* find(const miral::Window &needle) const;
-
-    QVector<MirSurface*> m_allSurfaces;
+    QVector<unity::shell::application::MirSurfaceInterface*> surfacesFor(const std::vector<miral::Window> &windows) const;
+    miral::Window windowFor(MirSurface *surface) const;
 
     WindowControllerInterface *m_windowController;
+    WorkspaceControllerInterface *m_workspaceController;
     SessionMapInterface *m_sessionMap;
+
+    friend class Workspace;
+    using swbimap_t = boost::bimap<MirSurface*, miral::Window>;
+    swbimap_t surface_to_window;
 };
 
 } // namespace qtmir
 
+Q_DECLARE_METATYPE(std::shared_ptr<miral::Workspace>)
+
 #endif // QTMIR_SURFACEMANAGER_H

=== modified file 'src/modules/Unity/Application/windowmodel.cpp'
--- src/modules/Unity/Application/windowmodel.cpp	2017-01-18 21:24:15 +0000
+++ src/modules/Unity/Application/windowmodel.cpp	2017-04-06 08:50:29 +0000
@@ -52,10 +52,6 @@
 {
     connect(notifier, &WindowModelNotifier::windowAdded,        this, &WindowModel::onWindowAdded,        Qt::QueuedConnection);
     connect(notifier, &WindowModelNotifier::windowRemoved,      this, &WindowModel::onWindowRemoved,      Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowReady,        this, &WindowModel::onWindowReady,        Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowMoved,        this, &WindowModel::onWindowMoved,        Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowStateChanged, this, &WindowModel::onWindowStateChanged, Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifier::windowFocusChanged, this, &WindowModel::onWindowFocusChanged, Qt::QueuedConnection);
     connect(notifier, &WindowModelNotifier::windowsRaised,      this, &WindowModel::onWindowsRaised,      Qt::QueuedConnection);
 }
 
@@ -95,41 +91,13 @@
     Q_EMIT countChanged();
 }
 
-void WindowModel::onWindowReady(const miral::WindowInfo &windowInfo)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->setReady();
-    }
-}
-
-void WindowModel::onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->setPosition(topLeft);
-    }
-}
-
-void WindowModel::onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->setFocused(focused);
-    }
-}
-
-void WindowModel::onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state)
-{
-    if (auto mirSurface = find(windowInfo)) {
-        mirSurface->updateState(state);
-    }
-}
-
-void WindowModel::addInputMethodWindow(const NewWindow &windowInfo)
+void WindowModel::addInputMethodWindow(const NewWindow &window)
 {
     if (m_inputMethodSurface) {
         qDebug("Multiple Input Method Surfaces created, removing the old one!");
         delete m_inputMethodSurface;
     }
-    m_inputMethodSurface = new MirSurface(windowInfo, m_windowController);
+    m_inputMethodSurface = new MirSurface(window, m_windowController);
     Q_EMIT inputMethodSurfaceChanged(m_inputMethodSurface);
 }
 

=== modified file 'src/modules/Unity/Application/windowmodel.h'
--- src/modules/Unity/Application/windowmodel.h	2016-11-03 20:17:46 +0000
+++ src/modules/Unity/Application/windowmodel.h	2017-04-06 08:50:29 +0000
@@ -60,10 +60,6 @@
 private Q_SLOTS:
     void onWindowAdded(const qtmir::NewWindow &windowInfo);
     void onWindowRemoved(const miral::WindowInfo &windowInfo);
-    void onWindowReady(const miral::WindowInfo &windowInfo);
-    void onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft);
-    void onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state);
-    void onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused);
     void onWindowsRaised(const std::vector<miral::Window> &windows);
 
 private:

=== modified file 'src/modules/Unity/CMakeLists.txt'
--- src/modules/Unity/CMakeLists.txt	2015-08-20 10:16:54 +0000
+++ src/modules/Unity/CMakeLists.txt	2017-04-06 08:50:29 +0000
@@ -1,2 +1,1 @@
 add_subdirectory(Application)
-add_subdirectory(Screens)

=== removed directory 'src/modules/Unity/Screens'
=== removed file 'src/modules/Unity/Screens/CMakeLists.txt'
--- src/modules/Unity/Screens/CMakeLists.txt	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Screens/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-include_directories(
-    ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
-)
-
-include_directories(
-    SYSTEM
-    ${MIRCLIENT_INCLUDE_DIRS}
-    ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
-    ${Qt5Quick_INCLUDE_DIRS}
-    )
-
-set(SCREENSPLUGIN_SRC
-    plugin.cpp
-    screens.cpp
-    screen.cpp
-    qquickscreenwindow.cpp
-    types.h
-    )
-
-add_library(unityscreensplugin SHARED
-    ${SCREENSPLUGIN_SRC}
-)
-
-target_link_libraries(
-    unityscreensplugin
-
-    qtmirserver
-
-    Qt5::Gui
-    Qt5::Qml
-    Qt5::Quick
-)
-
-# install
-add_qml_plugin(Unity.Screens 0.1 Unity/Screens TARGETS unityscreensplugin)

=== removed file 'src/modules/Unity/Screens/plugin.cpp'
--- src/modules/Unity/Screens/plugin.cpp	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Screens/plugin.cpp	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-// Qt
-#include <QQmlExtensionPlugin>
-#include <QtQml/qqml.h>
-#include <QScreen>
-
-// local
-#include "screens.h"
-#include "screen.h"
-#include "qquickscreenwindow.h"
-
-using namespace qtmir;
-
-namespace {
-QObject* screensSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {
-    Q_UNUSED(engine);
-    Q_UNUSED(scriptEngine);
-    return new qtmir::Screens();
-}
-}
-
-
-class UnityScreensPlugin : public QQmlExtensionPlugin {
-    Q_OBJECT
-    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface/1.0")
-
-    virtual void registerTypes(const char* uri)
-    {
-        Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Screens"));
-
-        qRegisterMetaType<ScreenAdapter*>("Screen*");
-        qRegisterMetaType<ScreenMode*>("ScreenMode*");
-        qRegisterMetaType<ScreenConfig*>("ScreenConfig*");
-        qmlRegisterUncreatableType<ScreenMode>(uri, 0, 1, "ScreenMode", "ScreenMode is not creatable.");
-
-        qmlRegisterSingletonType<qtmir::Screens>(uri, 0, 1, "Screens", screensSingleton);
-        qRegisterMetaType<qtmir::FormFactor>("qtmir::FormFactor");
-
-        qmlRegisterType<qtmir::QQuickScreenWindow>(uri, 0, 1, "ScreenWindow");
-        qmlRegisterRevision<QWindow,1>(uri, 0, 1);
-    }
-};
-
-#include "plugin.moc"

=== removed file 'src/modules/Unity/Screens/qmldir'
--- src/modules/Unity/Screens/qmldir	2015-08-24 11:29:57 +0000
+++ src/modules/Unity/Screens/qmldir	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-module Unity.Screens
-plugin unityscreensplugin

=== removed file 'src/modules/Unity/Screens/qquickscreenwindow.cpp'
--- src/modules/Unity/Screens/qquickscreenwindow.cpp	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Screens/qquickscreenwindow.cpp	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "qquickscreenwindow.h"
-
-// mirserver
-#include "screen.h"
-#include "screenscontroller.h"
-#include "logging.h"
-
-// Qt
-#include <QGuiApplication>
-#include <QScreen>
-#include <qpa/qplatformnativeinterface.h>
-#include <QDebug>
-
-using namespace qtmir;
-
-#define DEBUG_MSG qCDebug(QTMIR_SCREENS).nospace() << "QQuickScreenWindow[" << (void*)this <<"]::" << __func__
-
-QQuickScreenWindow::QQuickScreenWindow(QQuickWindow *parent)
-    : QQuickWindow(parent)
-{
-    if (qGuiApp->platformName() != QLatin1String("mirserver")) {
-        qCritical("Not using 'mirserver' QPA plugin. Using ScreenWindow may produce unknown results.");
-    }
-
-    DEBUG_MSG << "()";
-}
-
-QQuickScreenWindow::~QQuickScreenWindow()
-{
-    DEBUG_MSG << "()";
-}
-
-ScreenAdapter *QQuickScreenWindow::screenWrapper() const
-{
-    return m_screen.data();
-}
-
-void QQuickScreenWindow::setScreenWrapper(ScreenAdapter *screen)
-{
-    DEBUG_MSG << "(screen=" << screen << ")";
-    if (m_screen != screen) {
-        m_screen = screen;
-        Q_EMIT screenWrapperChanged();
-    }
-    QQuickWindow::setScreen(screen->screen());
-}

=== removed file 'src/modules/Unity/Screens/qquickscreenwindow.h'
--- src/modules/Unity/Screens/qquickscreenwindow.h	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Screens/qquickscreenwindow.h	1970-01-01 00:00:00 +0000
@@ -1,51 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef QQUICKSCREENWINDOW_H
-#define QQUICKSCREENWINDOW_H
-
-#include <QQuickWindow>
-#include <QPointer>
-
-class ScreenAdapter;
-
-namespace qtmir {
-
-/*
- * QQuickScreenWindow - wrapper of QQuickWindow to enable QML to specify destination screen.
-**/
-class QQuickScreenWindow : public QQuickWindow
-{
-    Q_OBJECT
-    Q_PROPERTY(ScreenAdapter *screen READ screenWrapper WRITE setScreenWrapper NOTIFY screenWrapperChanged)
-    Q_PROPERTY(int winId READ winId CONSTANT)
-public:
-    explicit QQuickScreenWindow(QQuickWindow *parent = 0);
-    ~QQuickScreenWindow();
-
-    ScreenAdapter *screenWrapper() const;
-    void setScreenWrapper(ScreenAdapter *screen);
-
-Q_SIGNALS:
-    void screenWrapperChanged();
-
-private:
-    QPointer<ScreenAdapter> m_screen;
-};
-
-} //namespace qtmir
-
-#endif // QQUICKSCREENWINDOW_H

=== removed file 'src/modules/Unity/Screens/screen.cpp'
--- src/modules/Unity/Screens/screen.cpp	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Screens/screen.cpp	1970-01-01 00:00:00 +0000
@@ -1,213 +0,0 @@
-#include "screen.h"
-
-// qtmir
-#include "platformscreen.h"
-#include "screenscontroller.h"
-#include "nativeinterface.h"
-
-// Qt
-#include <QScreen>
-#include <QQmlEngine>
-#include <QDebug>
-#include <QGuiApplication>
-
-ScreenAdapter::ScreenAdapter(QScreen* screen, QObject* parent)
-    : QObject(parent)
-    , m_screen(screen)
-    , m_screensController(static_cast<ScreensController*>(qGuiApp->platformNativeInterface()
-                                                          ->nativeResourceForIntegration("ScreensController")))
-{
-    if (!m_screensController) {
-        qFatal("Screens Controller not initialized");
-    }
-
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (platformScreen) {
-        connect(platformScreen, &PlatformScreen::usedChanged, this, &ScreenAdapter::usedChanged);
-        connect(platformScreen, &PlatformScreen::nameChanged, this, &ScreenAdapter::nameChanged);
-        connect(platformScreen, &PlatformScreen::outputTypeChanged, this, &ScreenAdapter::outputTypeChanged);
-        connect(platformScreen, &PlatformScreen::scaleChanged, this, &ScreenAdapter::scaleChanged);
-        connect(platformScreen, &PlatformScreen::formFactorChanged, this, &ScreenAdapter::formFactorChanged);
-        connect(platformScreen, &PlatformScreen::physicalSizeChanged, this, &ScreenAdapter::physicalSizeChanged);
-        connect(platformScreen, &PlatformScreen::positionChanged, this, &ScreenAdapter::positionChanged);
-        connect(platformScreen, &PlatformScreen::activeChanged, this, &ScreenAdapter::activeChanged);
-        connect(platformScreen, &PlatformScreen::currentModeIndexChanged, this, &ScreenAdapter::currentModeIndexChanged);
-        connect(platformScreen, &PlatformScreen::availableModesChanged, this, &ScreenAdapter::updateScreenModes);
-    }
-    updateScreenModes();
-}
-
-ScreenAdapter::~ScreenAdapter()
-{
-    qDebug() << "delete screens";
-    qDeleteAll(m_modes);
-    m_modes.clear();
-}
-
-qtmir::OutputId ScreenAdapter::outputId() const
-{
-    if (!m_screen) return qtmir::OutputId(-1);
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return qtmir::OutputId(-1);
-
-    return platformScreen->outputId();
-}
-
-bool ScreenAdapter::used() const
-{
-    if (!m_screen) return false;
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return false;
-
-    return platformScreen->used();
-}
-
-QString ScreenAdapter::name() const
-{
-    if (!m_screen) return QString();
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return QString();
-
-    return platformScreen->name();
-}
-
-float ScreenAdapter::scale() const
-{
-    if (!m_screen) return 1.0;
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return 1.0;
-
-    return platformScreen->scale();
-}
-
-QSizeF ScreenAdapter::physicalSize() const
-{
-    if (!m_screen) return QSizeF();
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return QSizeF();
-
-    return platformScreen->physicalSize();
-}
-
-qtmir::FormFactor ScreenAdapter::formFactor() const
-{
-    if (!m_screen) return qtmir::FormFactorUnknown;
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return qtmir::FormFactorUnknown;
-
-    return static_cast<qtmir::FormFactor>(platformScreen->formFactor()); // needs compile time check
-}
-
-qtmir::OutputTypes ScreenAdapter::outputType() const
-{
-    if (!m_screen) return qtmir::Unknown;
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return qtmir::Unknown;
-
-    return platformScreen->outputType();
-}
-
-QPoint ScreenAdapter::position() const
-{
-    if (!m_screen) return QPoint();
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return QPoint();
-
-    return platformScreen->geometry().topLeft();
-}
-
-QQmlListProperty<ScreenMode> ScreenAdapter::availableModes()
-{
-    return QQmlListProperty<ScreenMode>(this, m_modes);
-}
-
-uint ScreenAdapter::currentModeIndex() const
-{
-    if (!m_screen) return -1;
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return -1;
-
-    return platformScreen->currentModeIndex();
-}
-
-bool ScreenAdapter::isActive() const
-{
-    if (!m_screen) return false;
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return false;
-
-    return platformScreen->isActive();
-}
-
-QScreen *ScreenAdapter::screen() const
-{
-    return m_screen.data();
-}
-
-ScreenConfig *ScreenAdapter::beginConfiguration() const
-{
-    auto newConfig = new ScreenConfig();
-    auto config = m_screensController->outputConfiguration(this->outputId());
-    *newConfig = config;
-
-    return newConfig;
-}
-
-bool ScreenAdapter::applyConfiguration(ScreenConfig *configuration)
-{
-    if (!m_screen) return false;
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return false;
-
-    return m_screensController->setOutputConfiguration(*configuration);
-}
-
-void ScreenAdapter::setActive(bool active)
-{
-    if (!m_screen) return;
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return;
-
-    platformScreen->setActive(active);
-}
-
-void ScreenAdapter::updateScreenModes()
-{
-    if (!m_screen) return;
-    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
-    if (!platformScreen) return;
-
-    qDeleteAll(m_modes);
-    m_modes.clear();
-    Q_FOREACH(auto mode, platformScreen->availableModes()) {
-        auto newMode(new ScreenMode);
-        QQmlEngine::setObjectOwnership(newMode, QQmlEngine::CppOwnership);
-        newMode->refreshRate = mode.first;
-        newMode->size = mode.second;
-        m_modes.append(newMode);
-    }
-
-    Q_EMIT availableModesChanged();
-}
-
-ScreenConfig::ScreenConfig(QObject *parent)
-    : QObject(parent)
-{
-}
-
-ScreenConfig &ScreenConfig::operator=(const CustomScreenConfiguration &other)
-{
-    if (&other == this) return *this;
-
-    valid = other.valid;
-    id = other.id;
-    used = other.used;
-    topLeft = other.topLeft;
-    currentModeIndex = other.currentModeIndex;
-    powerMode = other.powerMode;
-    orientation = other.orientation;
-    scale = other.scale;
-    formFactor = other.formFactor;
-
-    return *this;
-}

=== removed file 'src/modules/Unity/Screens/screen.h'
--- src/modules/Unity/Screens/screen.h	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Screens/screen.h	1970-01-01 00:00:00 +0000
@@ -1,99 +0,0 @@
-#ifndef SCREEN_H
-#define SCREEN_H
-
-#include "types.h"
-
-#include <QObject>
-#include <QPointer>
-#include <QQmlListProperty>
-
-#include <customscreenconfiguration.h>
-#include <screentypes.h>
-
-class QScreen;
-class ScreenConfig;
-class ScreensController;
-
-/*
- * Screen - Adapter for a QScreen exposed to qml which allows user to read screen properties,
- * as well as configure the screen properties in a transactional manner.
-**/
-class ScreenAdapter : public QObject
-{
-    Q_OBJECT
-
-    Q_PROPERTY(bool active READ isActive WRITE setActive NOTIFY activeChanged)
-
-    Q_PROPERTY(bool used READ used NOTIFY usedChanged)
-    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
-    Q_PROPERTY(qtmir::OutputTypes outputType READ outputType NOTIFY outputTypeChanged)
-    Q_PROPERTY(float scale READ scale NOTIFY scaleChanged)
-    Q_PROPERTY(qtmir::FormFactor formFactor READ formFactor NOTIFY formFactorChanged)
-    Q_PROPERTY(QPoint position READ position NOTIFY positionChanged)
-    Q_PROPERTY(uint currentModeIndex READ currentModeIndex NOTIFY currentModeIndexChanged)
-    Q_PROPERTY(QQmlListProperty<ScreenMode> availableModes READ availableModes NOTIFY availableModesChanged)
-    Q_PROPERTY(QSizeF physicalSize READ physicalSize NOTIFY physicalSizeChanged)
-
-public:
-    explicit ScreenAdapter(QScreen* screen, QObject* parent = 0);
-    ~ScreenAdapter();
-
-    qtmir::OutputId outputId() const;
-    bool used() const;
-    QString name() const;
-    float scale() const;
-    QSizeF physicalSize() const;
-    qtmir::FormFactor formFactor() const;
-    qtmir::OutputTypes outputType() const;
-    QPoint position() const;
-    QQmlListProperty<ScreenMode> availableModes();
-    uint currentModeIndex() const;
-    bool isActive() const;
-
-    QScreen *screen() const;
-
-    Q_INVOKABLE ScreenConfig *beginConfiguration() const;
-    Q_INVOKABLE bool applyConfiguration(ScreenConfig *configuration);
-
-    void setActive(bool active);
-
-Q_SIGNALS:
-    void usedChanged();
-    void nameChanged();
-    void outputTypeChanged();
-    void scaleChanged();
-    void formFactorChanged();
-    void positionChanged();
-    void currentModeIndexChanged();
-    void physicalSizeChanged();
-    void availableModesChanged();
-    void activeChanged(bool active);
-
-private Q_SLOTS:
-    void updateScreenModes();
-
-private:
-    QList<ScreenMode*> m_modes;
-    QPointer<QScreen> m_screen;
-    ScreensController *m_screensController;
-};
-
-class ScreenConfig: public QObject,
-                    public CustomScreenConfiguration
-{
-    Q_OBJECT
-    Q_PROPERTY(bool used MEMBER used)
-    Q_PROPERTY(float scale MEMBER scale)
-    Q_PROPERTY(qtmir::FormFactor formFactor MEMBER formFactor)
-    Q_PROPERTY(uint currentModeIndex MEMBER currentModeIndex)
-    Q_PROPERTY(QPoint position MEMBER topLeft)
-
-public:
-    ScreenConfig(QObject* parent = 0);
-
-    ScreenConfig &operator=(const CustomScreenConfiguration& other);
-
-    friend class ScreenAdapter;
-};
-
-#endif // SCREEN_H

=== removed file 'src/modules/Unity/Screens/screens.cpp'
--- src/modules/Unity/Screens/screens.cpp	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Screens/screens.cpp	1970-01-01 00:00:00 +0000
@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "screens.h"
-#include "screen.h"
-
-// mirserver
-#include "platformscreen.h"
-#include "logging.h"
-
-// Qt
-#include <QGuiApplication>
-#include <QScreen>
-
-Q_DECLARE_METATYPE(QScreen*)
-
-#define DEBUG_MSG qCDebug(QTMIR_SCREENS).nospace() << "Screens[" << (void*)this <<"]::" << __func__
-
-namespace qtmir {
-
-Screens::Screens(QObject *parent) :
-    QAbstractListModel(parent)
-{
-    if (qGuiApp->platformName() != QLatin1String("mirserver")) {
-        qCritical("Not using 'mirserver' QPA plugin. Using Screens may produce unknown results.");
-    }
-
-    connect(qGuiApp, &QGuiApplication::screenAdded, this, &Screens::onScreenAdded);
-    connect(qGuiApp, &QGuiApplication::screenRemoved, this, &Screens::onScreenRemoved);
-    connect(qGuiApp, &QGuiApplication::focusWindowChanged, this, &Screens::activeScreenChanged);
-
-    Q_FOREACH(QScreen* screen, QGuiApplication::screens()) {
-        m_screenList.push_back(new ScreenAdapter(screen));
-    }
-    DEBUG_MSG << "(" << m_screenList << ")";
-}
-
-QHash<int, QByteArray> Screens::roleNames() const
-{
-    QHash<int, QByteArray> roles;
-    roles[ScreenRole] = "screen";
-    return roles;
-}
-
-QVariant Screens::data(const QModelIndex &index, int role) const
-{
-    if (!index.isValid() || index.row() >= m_screenList.size()) {
-        return QVariant();
-    }
-
-    switch(role) {
-    case ScreenRole:
-        return QVariant::fromValue(m_screenList.at(index.row()));
-    } // switch
-
-    return QVariant();
-}
-
-int Screens::rowCount(const QModelIndex &) const
-{
-    return count();
-}
-
-int Screens::count() const
-{
-    return m_screenList.size();
-}
-
-QVariant Screens::activeScreen() const
-{
-    for (int i = 0; i < m_screenList.count(); i++) {
-        if (m_screenList[i]->isActive()) return i;
-    }
-    return QVariant();
-}
-
-void Screens::activateScreen(const QVariant& vindex)
-{
-    bool ok = false;
-    int index = vindex.toInt(&ok);
-    if (!ok || index < 0 || m_screenList.count() <= index) return;
-
-    auto screen = static_cast<ScreenAdapter*>(m_screenList.at(index));
-    screen->setActive(true);
-}
-
-void Screens::onScreenAdded(QScreen *screen)
-{
-    Q_FOREACH(auto screenWrapper, m_screenList) {
-        if (screenWrapper->screen() == screen) return;
-    }
-    DEBUG_MSG << "(screen=" << screen << ")";
-
-    beginInsertRows(QModelIndex(), count(), count());
-    auto screenWrapper(new ScreenAdapter(screen));
-    m_screenList.push_back(screenWrapper);
-    endInsertRows();
-    Q_EMIT screenAdded(screenWrapper);
-    Q_EMIT countChanged();
-}
-
-void Screens::onScreenRemoved(QScreen *screen)
-{
-    DEBUG_MSG << "(screen=" << screen << ")";
-
-    int index = 0;
-    QMutableListIterator<ScreenAdapter*> iter(m_screenList);
-    while(iter.hasNext()) {
-        auto screenWrapper = iter.next();
-        if (screenWrapper->screen() == screen) {
-
-            beginRemoveRows(QModelIndex(), index, index);
-            auto screenWrapper = m_screenList.takeAt(index);
-            endRemoveRows();
-
-            Q_EMIT screenRemoved(screenWrapper);
-            Q_EMIT countChanged();
-
-            iter.remove();
-            screenWrapper->deleteLater();
-            break;
-        }
-        index++;
-    }
-}
-
-} // namespace qtmir

=== removed file 'src/modules/Unity/Screens/screens.h'
--- src/modules/Unity/Screens/screens.h	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Screens/screens.h	1970-01-01 00:00:00 +0000
@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef SCREENS_H
-#define SCREENS_H
-
-#include "screentypes.h"
-
-#include <QAbstractListModel>
-
-class QScreen;
-class ScreenAdapter;
-
-namespace qtmir {
-
-class Screens : public QAbstractListModel
-{
-    Q_OBJECT
-    Q_PROPERTY(int count READ count NOTIFY countChanged)
-    Q_PROPERTY(QVariant activeScreen READ activeScreen WRITE activateScreen NOTIFY activeScreenChanged)
-
-public:
-    enum ItemRoles {
-        ScreenRole = Qt::UserRole + 1
-    };
-
-    explicit Screens(QObject *parent = 0);
-    virtual ~Screens() noexcept = default;
-
-    /* QAbstractItemModel */
-    QHash<int, QByteArray> roleNames() const override;
-    QVariant data(const QModelIndex &index, int role = ScreenRole) const override;
-    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
-
-    int count() const;
-    QVariant activeScreen() const;
-
-public Q_SLOTS:
-    void activateScreen(const QVariant& index);
-
-Q_SIGNALS:
-    void countChanged();
-    void activeScreenChanged();
-    void screenAdded(ScreenAdapter *screen);
-    void screenRemoved(ScreenAdapter *screen);
-
-private Q_SLOTS:
-    void onScreenAdded(QScreen *screen);
-    void onScreenRemoved(QScreen *screen);
-
-private:
-    QList<ScreenAdapter *> m_screenList;
-};
-
-} // namespace qtmir
-
-#endif // SCREENS_H

=== removed file 'src/modules/Unity/Screens/types.h'
--- src/modules/Unity/Screens/types.h	2017-04-06 08:50:28 +0000
+++ src/modules/Unity/Screens/types.h	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-/*
- * Copyright © 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 UNITY_SCREEN_TYPES_H
-#define UNITY_SCREEN_TYPES_H
-
-#include <QObject>
-#include <QSize>
-
-class ScreenMode : public QObject
-{
-    Q_OBJECT
-    Q_PROPERTY(qreal refreshRate MEMBER refreshRate CONSTANT)
-    Q_PROPERTY(QSize size MEMBER size CONSTANT)
-public:
-    ScreenMode():refreshRate(-1) {}
-    ScreenMode(const ScreenMode& other)
-        : QObject(nullptr),
-          refreshRate{other.refreshRate},size{other.size}
-    {}
-
-    qreal refreshRate;
-    QSize size;
-};
-
-Q_DECLARE_METATYPE(ScreenMode)
-
-#endif //UNITY_SCREEN_TYPES_H

=== modified file 'src/platforms/mirserver/CMakeLists.txt'
--- src/platforms/mirserver/CMakeLists.txt	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2017-04-06 08:50:29 +0000
@@ -2,6 +2,7 @@
 # And also not anymore as pkgconfig module since Qt 5.6.
 #pkg_check_modules(QT5PLATFORM_SUPPORT Qt5PlatformSupport REQUIRED)
 include(FindQt5PlatformSupport)
+include(UseLttngGenTp)
 
 set(QTMIRSERVER_ABI 1)
 
@@ -54,6 +55,12 @@
 # Needed to compile tracepoints in C99 mode.
 add_definitions(-DBYTE_ORDER=__BYTE_ORDER)
 
+# Generate tracepoints.c and .h from tracepoints.tp
+add_lttng_gen_tp(NAME tracepoints)
+add_custom_target(MirServer_LTTNG
+    DEPENDS tracepoints.h tracepoints.c
+)
+
 # These files will compile without mirserver-dev
 add_library(qtmirserver-nomirserver OBJECT
     ${CMAKE_SOURCE_DIR}/src/common/timestamp.cpp
@@ -67,10 +74,15 @@
     nativeinterface.cpp
     services.cpp
     windowcontroller.cpp
+    workspacecontroller.cpp
     tracepoints.c
     surfaceobserver.cpp
     initialsurfacesizes.cpp
+    screenadaptor.cpp
+    screenadaptormodel.cpp
+    qtmir.cpp
 )
+add_dependencies(qtmirserver-nomirserver MirServer_LTTNG)
 
 set_source_files_properties(tracepoints.c PROPERTIES COMPILE_FLAGS "${CMAKE_CFLAGS} -fPIC")
 
@@ -106,6 +118,7 @@
     offscreensurface.cpp
     inputdeviceobserver.cpp
     mirserverapplication.cpp
+    windowmodelnotifier.cpp
 
 # We need to run moc on these headers
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h
@@ -116,8 +129,13 @@
     ${CMAKE_SOURCE_DIR}/include/qtmir/sessionauthorizer.h
     ${CMAKE_SOURCE_DIR}/include/qtmir/windowmanagementpolicy.h
     ${CMAKE_SOURCE_DIR}/include/qtmir/displayconfigurationstorage.h
+    ${CMAKE_SOURCE_DIR}/include/qtmir/screen.h
+    ${CMAKE_SOURCE_DIR}/include/qtmir/screens.h
+    ${CMAKE_SOURCE_DIR}/include/qtmir/types.h
+    ${CMAKE_SOURCE_DIR}/include/qtmir/qtmir.h
 
     ${CMAKE_SOURCE_DIR}/src/common/windowcontrollerinterface.h
+    ${CMAKE_SOURCE_DIR}/src/common/workspacecontrollerinterface.h
     ${CMAKE_SOURCE_DIR}/src/common/windowmodelnotifier.h
     ${CMAKE_SOURCE_DIR}/src/common/appnotifier.h
 )
@@ -166,9 +184,6 @@
     @ONLY
 )
 
-include(UseLttngGenTp)
-add_lttng_gen_tp(NAME tracepoints)
-
 install(
   TARGETS qtmirserver
   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}

=== removed file 'src/platforms/mirserver/customscreenconfiguration.h'
--- src/platforms/mirserver/customscreenconfiguration.h	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/customscreenconfiguration.h	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef CUSTOMSCREENCONFIGURATION_H
-#define CUSTOMSCREENCONFIGURATION_H
-
-#include <QPoint>
-#include <QVector>
-
-#include "screentypes.h"
-#include <mir_toolkit/common.h>
-
-
-struct CustomScreenConfiguration
-{
-    bool valid{false};
-    qtmir::OutputId id;
-
-    bool used;
-    QPoint topLeft;
-    uint32_t currentModeIndex;
-    MirPowerMode powerMode;
-    MirOrientation orientation;
-    float scale;
-    qtmir::FormFactor formFactor;
-
-    // To read additional readonly state, consult the Screen
-};
-
-typedef QVector<CustomScreenConfiguration> CustomScreenConfigurationList;
-
-#endif // CUSTOMSCREENCONFIGURATION_H

=== modified file 'src/platforms/mirserver/miral/CMakeLists.txt'
--- src/platforms/mirserver/miral/CMakeLists.txt	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/miral/CMakeLists.txt	2017-04-06 08:50:29 +0000
@@ -8,6 +8,7 @@
     persist_display_config.cpp persist_display_config.h
     mirbuffer.cpp mirbuffer.h
     ${CMAKE_SOURCE_DIR}/include/qtmir/miral/display_configuration_storage.h
+    edid.cpp ${CMAKE_SOURCE_DIR}/include/qtmir/miral/display_id.h
     edid.cpp ${CMAKE_SOURCE_DIR}/include/qtmir/miral/edid.h
     display_configuration_policy.cpp ${CMAKE_SOURCE_DIR}/include/qtmir/miral/display_configuration_policy.h
 )

=== modified file 'src/platforms/mirserver/miral/persist_display_config.cpp'
--- src/platforms/mirserver/miral/persist_display_config.cpp	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/miral/persist_display_config.cpp	2017-04-06 08:50:29 +0000
@@ -179,7 +179,7 @@
             miral::DisplayId display_id;
             // FIXME - output.edid should be std::vector<uint8_t>, not std::vector<uint8_t const>
             display_id.edid.parse_data(reinterpret_cast<std::vector<uint8_t> const&>(output.edid));
-            display_id.output_id = output.id.as_value();
+            display_id.output_id = output.id;
 
             // TODO if the h/w profile (by some definition) has changed, then apply corresponding saved config (if any).
             // TODO Otherwise...
@@ -232,7 +232,7 @@
             miral::DisplayId display_id;
             // FIXME - output.edid should be std::vector<uint8_t>, not std::vector<uint8_t const>
             display_id.edid.parse_data(reinterpret_cast<std::vector<uint8_t> const&>(output.edid));
-            display_id.output_id = output.id.as_value();
+            display_id.output_id = output.id;
 
             miral::DisplayConfigurationOptions config;
 

=== modified file 'src/platforms/mirserver/mirserverapplication.cpp'
--- src/platforms/mirserver/mirserverapplication.cpp	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/mirserverapplication.cpp	2017-04-06 08:50:29 +0000
@@ -16,12 +16,14 @@
 
 #include "qtmir/mirserverapplication.h"
 #include "qmirserver.h"
+#include "qtmir/qtmir.h"
 
 #include <QDebug>
 
-namespace qtmir {
-
-namespace {
+namespace qtmir
+{
+namespace
+{
 
 QSharedPointer<QMirServer> mirServer;
 

=== modified file 'src/platforms/mirserver/platformscreen.cpp'
--- src/platforms/mirserver/platformscreen.cpp	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/platformscreen.cpp	2017-04-06 08:50:29 +0000
@@ -156,7 +156,7 @@
     , m_unityScreen(nullptr)
 {
     setMirDisplayConfiguration(screen, false);
-    DEBUG_MSG_SCREENS << "(output=" << m_outputId.as_value()
+    DEBUG_MSG_SCREENS << "(output=" << m_displayId.output_id.as_value()
                       << ", used=" << (m_used ? "true" : "false")
                       << ", geometry=" << geometry() << ")";
 
@@ -241,7 +241,13 @@
     }
 
     // Output data - each output has a unique id and corresponding type. Can be multiple cards.
-    m_outputId = screen.id;
+    m_displayId.output_id = screen.id;
+    try {
+        m_displayId.edid.parse_data(reinterpret_cast<std::vector<uint8_t> const&>(screen.edid));
+    } catch (std::runtime_error const& e) {
+        printf("Failed to parse EDID - %s\n", e.what());
+    }
+
     auto type = static_cast<qtmir::OutputTypes>(screen.type); //FIXME: need compile time check these are equivalent
     if (m_type != type) {
         m_type = type;
@@ -279,7 +285,10 @@
     m_depth = 8 * MIR_BYTES_PER_PIXEL(screen.current_format);
 
     // Power mode
-    m_powerMode = screen.power_mode;
+    if (m_powerMode != screen.power_mode) {
+        m_powerMode = screen.power_mode;
+        Q_EMIT powerModeChanged();
+    }
 
     QRect oldGeometry = m_geometry;
     // Position of screen in virtual desktop coordinate space
@@ -406,7 +415,7 @@
 
 QString PlatformScreen::name() const
 {
-    return displayTypeToString(m_type);
+    return QString("%1-%2").arg(displayTypeToString(m_type)).arg(m_displayId.output_id.as_value());
 }
 
 QWindow *PlatformScreen::topLevelAt(const QPoint &point) const

=== modified file 'src/platforms/mirserver/platformscreen.h'
--- src/platforms/mirserver/platformscreen.h	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/platformscreen.h	2017-04-06 08:50:29 +0000
@@ -28,9 +28,10 @@
 #include <mir_toolkit/common.h>
 
 // local
+#include "qtmir/types.h"
+#include "qtmir/miral/display_configuration_storage.h"
 #include "cursor.h"
 #include "screenplatformwindow.h"
-#include "screentypes.h"
 
 class QOrientationSensor;
 namespace mir {
@@ -63,7 +64,7 @@
     float scale() const { return m_scale; }
     qtmir::FormFactor formFactor() const { return m_formFactor; }
     MirPowerMode powerMode() const { return m_powerMode; }
-    qtmir::OutputId outputId() const { return m_outputId; }
+    miral::DisplayId displayId() const { return m_displayId; }
     qtmir::OutputTypes outputType() const { return m_type; }
     uint32_t currentModeIndex() const { return m_currentModeIndex; }
     bool isActive() const { return m_isActive; }
@@ -91,6 +92,8 @@
     void outputTypeChanged();
     void scaleChanged();
     void formFactorChanged();
+    void orientationChanged();
+    void powerModeChanged();
     void currentModeIndexChanged();
     void positionChanged();
     void modeChanged();
@@ -133,7 +136,7 @@
 
     mir::renderer::gl::RenderTarget *m_renderTarget;
     mir::graphics::DisplaySyncGroup *m_displayGroup;
-    qtmir::OutputId m_outputId;
+    miral::DisplayId m_displayId;
     qtmir::OutputTypes m_type;
     MirPowerMode m_powerMode;
 

=== modified file 'src/platforms/mirserver/qmirserver.cpp'
--- src/platforms/mirserver/qmirserver.cpp	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/qmirserver.cpp	2017-04-06 08:50:29 +0000
@@ -116,6 +116,8 @@
         result = d->promptSessionListener();
     else if (resource == "WindowController")
         result = d->windowController();
+    else if (resource == "WorkspaceController")
+        result = d->workspaceController();
     else if (resource == "WindowModelNotifier")
         result = d->windowModelNotifier();
     else if (resource == "ScreensController")

=== modified file 'src/platforms/mirserver/qmirserver_p.cpp'
--- src/platforms/mirserver/qmirserver_p.cpp	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/qmirserver_p.cpp	2017-04-06 08:50:29 +0000
@@ -182,6 +182,7 @@
             m_mirServerHooks,
             miral::set_window_management_policy<WrappedWindowManagementPolicy>(m_windowModelNotifier,
                                                                                m_windowController,
+                                                                               m_workspaceController,
                                                                                m_appNotifier,
                                                                                eventFeeder,
                                                                                m_windowManagementPolicy),

=== modified file 'src/platforms/mirserver/qmirserver_p.h'
--- src/platforms/mirserver/qmirserver_p.h	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/qmirserver_p.h	2017-04-06 08:50:29 +0000
@@ -31,6 +31,7 @@
 #include "screensmodel.h"
 #include "windowcontroller.h"
 #include "windowmodelnotifier.h"
+#include "workspacecontroller.h"
 #include "mirserverhooks.h"
 #include "wrappedsessionauthorizer.h"
 #include "qteventfeeder.h"
@@ -80,6 +81,9 @@
     qtmir::WindowControllerInterface *windowController() const
         { return &m_windowController; }
 
+    qtmir::WorkspaceControllerInterface *workspaceController() const
+        { return &m_workspaceController; }
+
     qtmir::DisplayConfigurationPolicyWrapper m_displayConfigurationPolicy;
     qtmir::WindowManagmentPolicyBuilder m_windowManagementPolicy;
     qtmir::BasicSetDisplayConfigurationStorage m_displayConfigurationStorage;
@@ -93,6 +97,7 @@
     mutable qtmir::AppNotifier m_appNotifier;
     mutable qtmir::WindowModelNotifier m_windowModelNotifier;
     mutable qtmir::WindowController m_windowController;
+    mutable qtmir::WorkspaceController m_workspaceController;
 };
 
 class MirServerThread : public QThread

=== added file 'src/platforms/mirserver/qtmir.cpp'
--- src/platforms/mirserver/qtmir.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/qtmir.cpp	2017-04-06 08:50:29 +0000
@@ -0,0 +1,15 @@
+#include "qtmir/qtmir.h"
+#include "screenadaptormodel.h"
+
+QWeakPointer<qtmir::Screens> weakScreenModel;
+
+QSharedPointer<qtmir::Screens> qtmir::get_screen_model()
+{
+    auto model = weakScreenModel.lock();
+    if (!model) {
+        QSharedPointer<qtmir::Screens> newModel{new ScreenAdaptorModel()};
+        weakScreenModel = model;
+        return newModel;
+    }
+    return model;
+}

=== added file 'src/platforms/mirserver/screenadaptor.cpp'
--- src/platforms/mirserver/screenadaptor.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/screenadaptor.cpp	2017-04-06 08:50:29 +0000
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2017 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 "screenadaptor.h"
+
+// qtmir
+#include "platformscreen.h"
+#include "screenscontroller.h"
+#include "nativeinterface.h"
+
+// Qt
+#include <QScreen>
+#include <QQmlEngine>
+#include <QDebug>
+#include <QGuiApplication>
+
+ScreenAdaptor::ScreenAdaptor(QScreen* screen, QObject* parent)
+    : qtmir::Screen(parent)
+    , m_screen(screen)
+    , m_screensController(static_cast<ScreensController*>(qGuiApp->platformNativeInterface()
+                                                          ->nativeResourceForIntegration("ScreensController")))
+{
+    if (!m_screensController) {
+        qFatal("Screens Controller not initialized");
+    }
+
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    connect(platformScreen, &PlatformScreen::usedChanged, this, &ScreenAdaptor::usedChanged);
+    connect(platformScreen, &PlatformScreen::nameChanged, this, &ScreenAdaptor::nameChanged);
+    connect(platformScreen, &PlatformScreen::outputTypeChanged, this, &ScreenAdaptor::outputTypeChanged);
+    connect(platformScreen, &PlatformScreen::scaleChanged, this, &ScreenAdaptor::scaleChanged);
+    connect(platformScreen, &PlatformScreen::formFactorChanged, this, &ScreenAdaptor::formFactorChanged);
+    connect(platformScreen, &PlatformScreen::powerModeChanged, this, &ScreenAdaptor::powerModeChanged);
+    connect(platformScreen, &PlatformScreen::physicalSizeChanged, this, &ScreenAdaptor::physicalSizeChanged);
+    connect(platformScreen, &PlatformScreen::positionChanged, this, &ScreenAdaptor::positionChanged);
+    connect(platformScreen, &PlatformScreen::activeChanged, this, &ScreenAdaptor::activeChanged);
+    connect(platformScreen, &PlatformScreen::currentModeIndexChanged, this, &ScreenAdaptor::currentModeIndexChanged);
+    connect(platformScreen, &PlatformScreen::availableModesChanged, this, &ScreenAdaptor::updateScreenModes);
+    connect(screen, &QScreen::orientationChanged, this, &ScreenAdaptor::orientationChanged);
+
+    updateScreenModes();
+}
+
+ScreenAdaptor::~ScreenAdaptor()
+{
+    qDeleteAll(m_modes);
+    m_modes.clear();
+}
+
+miral::DisplayId ScreenAdaptor::displayId() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->displayId();
+}
+
+bool ScreenAdaptor::used() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->used();
+}
+
+QString ScreenAdaptor::name() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->name();
+}
+
+float ScreenAdaptor::scale() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->scale();
+}
+
+QSizeF ScreenAdaptor::physicalSize() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->physicalSize();
+}
+
+qtmir::FormFactor ScreenAdaptor::formFactor() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return static_cast<qtmir::FormFactor>(platformScreen->formFactor()); // needs compile time check
+}
+
+qtmir::OutputTypes ScreenAdaptor::outputType() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->outputType();
+}
+
+MirPowerMode ScreenAdaptor::powerMode() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->powerMode();
+}
+
+Qt::ScreenOrientation ScreenAdaptor::orientation() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->orientation();
+}
+
+QPoint ScreenAdaptor::position() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->geometry().topLeft();
+}
+
+QQmlListProperty<qtmir::ScreenMode> ScreenAdaptor::availableModes()
+{
+    return QQmlListProperty<qtmir::ScreenMode>(this, m_modes);
+}
+
+uint ScreenAdaptor::currentModeIndex() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->currentModeIndex();
+}
+
+bool ScreenAdaptor::isActive() const
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    return platformScreen->isActive();
+}
+
+QScreen *ScreenAdaptor::qscreen() const
+{
+    return m_screen.data();
+}
+
+qtmir::ScreenConfiguration *ScreenAdaptor::beginConfiguration() const
+{
+    auto config = m_screensController->outputConfiguration(this->displayId().output_id);
+    return new qtmir::ScreenConfiguration(config);
+}
+
+bool ScreenAdaptor::applyConfiguration(qtmir::ScreenConfiguration *configuration)
+{
+    return m_screensController->setOutputConfiguration(*configuration);
+}
+
+void ScreenAdaptor::setActive(bool active)
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+    platformScreen->setActive(active);
+}
+
+void ScreenAdaptor::updateScreenModes()
+{
+    auto platformScreen = static_cast<PlatformScreen*>(m_screen->handle());
+
+    qDeleteAll(m_modes);
+    m_modes.clear();
+    Q_FOREACH(auto mode, platformScreen->availableModes()) {
+        auto newMode(new qtmir::ScreenMode(mode.first, mode.second));
+        QQmlEngine::setObjectOwnership(newMode, QQmlEngine::CppOwnership);
+        m_modes.append(newMode);
+    }
+
+    Q_EMIT availableModesChanged();
+}

=== added file 'src/platforms/mirserver/screenadaptor.h'
--- src/platforms/mirserver/screenadaptor.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/screenadaptor.h	2017-04-06 08:50:29 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QTMIR_SCREENADAPTOR_H
+#define QTMIR_SCREENADAPTOR_H
+
+#include "qtmir/screen.h"
+
+#include <QObject>
+#include <QPointer>
+#include <QQmlListProperty>
+
+class QScreen;
+class ScreenConfig;
+class ScreensController;
+
+class ScreenAdaptor : public qtmir::Screen
+{
+    Q_OBJECT
+public:
+    ScreenAdaptor(QScreen* screen, QObject* parent = 0);
+    ~ScreenAdaptor();
+
+    miral::DisplayId displayId() const override;
+    bool used() const override;
+    QString name() const override;
+    float scale() const override;
+    QSizeF physicalSize() const override;
+    qtmir::FormFactor formFactor() const override;
+    qtmir::OutputTypes outputType() const override;
+    MirPowerMode powerMode() const override;
+    Qt::ScreenOrientation orientation() const override;
+    QPoint position() const override;
+    QQmlListProperty<qtmir::ScreenMode> availableModes() override;
+    uint currentModeIndex() const override;
+    bool isActive() const override;
+    void setActive(bool active) override;
+
+    QScreen *qscreen() const override;
+
+    qtmir::ScreenConfiguration *beginConfiguration() const override;
+    bool applyConfiguration(qtmir::ScreenConfiguration *configuration) override;
+
+private Q_SLOTS:
+    void updateScreenModes();
+
+private:
+    QList<qtmir::ScreenMode*> m_modes;
+    QPointer<QScreen> m_screen;
+    ScreensController *m_screensController;
+};
+
+#endif // QTMIR_SCREENADAPTOR_H

=== added file 'src/platforms/mirserver/screenadaptormodel.cpp'
--- src/platforms/mirserver/screenadaptormodel.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/screenadaptormodel.cpp	2017-04-06 08:50:29 +0000
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2017 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 "screenadaptormodel.h"
+
+// mirserver
+#include "screenadaptor.h"
+#include "logging.h"
+
+// Qt
+#include <QGuiApplication>
+#include <QScreen>
+#include <QWindow>
+
+#define DEBUG_MSG qCDebug(QTMIR_SCREENS).nospace() << "Screens[" << (void*)this <<"]::" << __func__
+
+ScreenAdaptorModel::ScreenAdaptorModel(QObject *parent)
+    : qtmir::Screens(parent)
+{
+    if (qGuiApp->platformName() != QLatin1String("mirserver")) {
+        qFatal("Can't use the ScreenAdaptorModel model without using 'mirserver' QPA plugin.");
+    }
+
+    connect(qGuiApp, &QGuiApplication::screenAdded, this, &ScreenAdaptorModel::onScreenAdded);
+    connect(qGuiApp, &QGuiApplication::screenRemoved, this, &ScreenAdaptorModel::onScreenRemoved);
+    connect(qGuiApp, &QGuiApplication::focusWindowChanged, this, &ScreenAdaptorModel::activeScreenChanged);
+
+    Q_FOREACH(QScreen* screen, QGuiApplication::screens()) {
+        m_screenList.push_back(new ScreenAdaptor(screen));
+    }
+    DEBUG_MSG << "(" << m_screenList << ")";
+
+    // Register types.
+    qRegisterMetaType<qtmir::ScreenConfiguration*>("qtmir::ScreenConfiguration*");
+    qRegisterMetaType<qtmir::FormFactor>("qtmir::FormFactor");
+    qRegisterMetaType<qtmir::OutputTypes>("qtmir::OutputTypes");
+}
+
+ScreenAdaptorModel::~ScreenAdaptorModel()
+{
+    qDeleteAll(m_screenList);
+    m_screenList.clear();
+}
+
+qtmir::Screen *ScreenAdaptorModel::activeScreen() const
+{
+    QWindow* window = qGuiApp->focusWindow();
+    if (!window || !window->screen()) return nullptr;
+
+    Q_FOREACH(auto screen, m_screenList) {
+        if (screen && screen->qscreen() == window->screen()) return screen;
+    }
+    return nullptr;
+}
+
+void ScreenAdaptorModel::onScreenAdded(QScreen *qscreen)
+{
+    Q_FOREACH(auto screen, m_screenList) {
+        auto adaptor = qobject_cast<ScreenAdaptor*>(screen);
+        if (adaptor && adaptor->qscreen() == qscreen) return;
+    }
+    DEBUG_MSG << "(screen=" << qscreen << ")";
+
+    auto adaptor(new ScreenAdaptor(qscreen));
+    m_screenList.push_back(adaptor);
+    Q_EMIT screenAdded(adaptor);
+}
+
+void ScreenAdaptorModel::onScreenRemoved(QScreen *qscreen)
+{
+    DEBUG_MSG << "(screen=" << qscreen << ")";
+
+    int index = 0;
+    QMutableVectorIterator<qtmir::Screen*> iter(m_screenList);
+    while(iter.hasNext()) {
+        auto adaptor = qobject_cast<ScreenAdaptor*>(iter.next());
+        if (adaptor && adaptor->qscreen() == qscreen) {
+            Q_EMIT screenRemoved(adaptor);
+
+            iter.remove();
+            delete adaptor;
+            break;
+        }
+        index++;
+    }
+}

=== added file 'src/platforms/mirserver/screenadaptormodel.h'
--- src/platforms/mirserver/screenadaptormodel.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/screenadaptormodel.h	2017-04-06 08:50:29 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2017 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 SCREENADAPTORMODEL_H
+#define SCREENADAPTORMODEL_H
+
+#include "qtmir/screens.h"
+
+namespace qtmir
+{
+class Screen;
+}
+
+class ScreenAdaptorModel : public qtmir::Screens
+{
+public:
+    ScreenAdaptorModel(QObject* parent = 0);
+    ~ScreenAdaptorModel();
+
+    QVector<qtmir::Screen*> screens() const { return m_screenList; }
+
+    qtmir::Screen* activeScreen() const;
+
+private Q_SLOTS:
+    void onScreenAdded(QScreen *screen);
+    void onScreenRemoved(QScreen *screen);
+
+private:
+    QVector<qtmir::Screen*> m_screenList;
+};
+
+#endif // SCREENADAPTORMODEL_H

=== modified file 'src/platforms/mirserver/screenplatformwindow.cpp'
--- src/platforms/mirserver/screenplatformwindow.cpp	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/screenplatformwindow.cpp	2017-04-06 08:50:29 +0000
@@ -57,7 +57,7 @@
     DEBUG_MSG << "(window=" << window
               << ") - windowId=" << uint(m_winId)
               << ", on screen=" << platformScreen
-              << ", outputId=" << platformScreen->outputId().as_value()
+              << ", outputId=" << platformScreen->displayId().output_id.as_value()
               << ", geometry=" << screenGeometry;
 
     platformScreen->addWindow(this);
@@ -172,7 +172,7 @@
     auto platformScreen = static_cast<PlatformScreen *>(newScreen);
     Q_ASSERT(platformScreen);
     DEBUG_MSG << "(screen=" << platformScreen
-              << ", outputId=" << platformScreen->outputId().as_value() << ")";
+              << ", outputId=" << platformScreen->displayId().output_id.as_value() << ")";
 
     // Dis-associate the old screen
     if (screen()) {

=== modified file 'src/platforms/mirserver/screenscontroller.cpp'
--- src/platforms/mirserver/screenscontroller.cpp	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/screenscontroller.cpp	2017-04-06 08:50:29 +0000
@@ -36,15 +36,15 @@
 {
 }
 
-CustomScreenConfigurationList ScreensController::configuration()
+qtmir::ScreenConfigurationList ScreensController::configuration()
 {
-    CustomScreenConfigurationList list;
+    qtmir::ScreenConfigurationList list;
 
     Q_FOREACH(auto screen, m_screensModel->screens()) {
         list.append(
-            CustomScreenConfiguration {
+            qtmir::ScreenConfiguration {
                         true,
-                        screen->outputId(),
+                        screen->displayId().output_id,
                         screen->used(),
                         screen->geometry().topLeft(),
                         screen->currentModeIndex(),
@@ -57,7 +57,7 @@
     return list;
 }
 
-bool ScreensController::setConfiguration(const CustomScreenConfigurationList &newConfig)
+bool ScreensController::setConfiguration(const qtmir::ScreenConfigurationList &newConfig)
 {
     using namespace mir::geometry;
 
@@ -87,17 +87,16 @@
     return true;
 }
 
-CustomScreenConfiguration ScreensController::outputConfiguration(qtmir::OutputId outputId)
+qtmir::ScreenConfiguration ScreensController::outputConfiguration(miral::OutputId outputId)
 {
     auto displayConfiguration = m_display->configuration();
-    CustomScreenConfiguration config;
+    qtmir::ScreenConfiguration config;
 
     displayConfiguration->for_each_output(
         [&config, outputId](mg::UserDisplayConfigurationOutput &outputConfig)
         {
             if (outputConfig.id == outputId) {
                 config.valid = true;
-                config.id = outputConfig.id;
                 config.used = outputConfig.used;
                 config.topLeft = QPoint{outputConfig.top_left.x.as_int(), outputConfig.top_left.y.as_int()};
                 config.currentModeIndex = outputConfig.current_mode_index;
@@ -110,7 +109,7 @@
     return config;
 }
 
-bool ScreensController::setOutputConfiguration(const CustomScreenConfiguration &newConfig)
+bool ScreensController::setOutputConfiguration(const qtmir::ScreenConfiguration &newConfig)
 {
     using namespace mir::geometry;
     if (!newConfig.valid)

=== modified file 'src/platforms/mirserver/screenscontroller.h'
--- src/platforms/mirserver/screenscontroller.h	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/screenscontroller.h	2017-04-06 08:50:29 +0000
@@ -23,7 +23,7 @@
 #include <QVector>
 
 // local
-#include "customscreenconfiguration.h"
+#include "qtmir/screen.h"
 
 #include <memory>
 
@@ -45,11 +45,11 @@
                                const std::shared_ptr<mir::shell::DisplayConfigurationController> &controller,
                                QObject *parent = 0);
 
-    CustomScreenConfigurationList configuration();
-    bool setConfiguration(const CustomScreenConfigurationList &newConfig);
+    qtmir::ScreenConfigurationList configuration();
+    bool setConfiguration(const qtmir::ScreenConfigurationList &newConfig);
 
-    CustomScreenConfiguration outputConfiguration(qtmir::OutputId outputId);
-    bool setOutputConfiguration(const CustomScreenConfiguration &newConfig);
+    qtmir::ScreenConfiguration outputConfiguration(miral::OutputId outputId);
+    bool setOutputConfiguration(const qtmir::ScreenConfiguration &newConfig);
 
 private:
     const std::shared_ptr<ScreensModel> m_screensModel;

=== modified file 'src/platforms/mirserver/screensmodel.cpp'
--- src/platforms/mirserver/screensmodel.cpp	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/screensmodel.cpp	2017-04-06 08:50:29 +0000
@@ -190,7 +190,7 @@
 
     // Delete any old & unused Screens
     Q_FOREACH (auto screen, oldScreenList) {
-        DEBUG_MSG << "() - removed Screen with id " << screen->m_outputId.as_value()
+        DEBUG_MSG << "() - removed Screen with id " << screen->displayId().output_id.as_value()
                                << " and geometry " << screen->geometry();
 
         Q_FOREACH (ScreenPlatformWindow* window, screen->windows()) {
@@ -208,7 +208,7 @@
 
     qCDebug(QTMIR_SCREENS) << "=======================================";
     Q_FOREACH (auto screen, m_screenList) {
-        qCDebug(QTMIR_SCREENS) << screen << "- id:" << screen->m_outputId.as_value()
+        qCDebug(QTMIR_SCREENS) << screen << "- id:" << screen->displayId().output_id.as_value()
                                << "geometry:" << screen->geometry()
                                << "window:" << screen->primaryWindow()
                                << "type:" << screen->name()
@@ -273,7 +273,7 @@
 PlatformScreen* ScreensModel::findScreenWithId(const QList<PlatformScreen *> &list, const mg::DisplayConfigurationOutputId id)
 {
     Q_FOREACH (auto screen, list) {
-        if (screen->m_outputId == id) {
+        if (screen->displayId().output_id == id) {
             return screen;
         }
     }

=== modified file 'src/platforms/mirserver/screensmodel.h'
--- src/platforms/mirserver/screensmodel.h	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/screensmodel.h	2017-04-06 08:50:29 +0000
@@ -14,8 +14,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SCREENCONTROLLER_H
-#define SCREENCONTROLLER_H
+#ifndef SCREENCONFIGURATIONOBSERVER_H
+#define SCREENCONFIGURATIONOBSERVER_H
 
 #include "mirdisplayconfigurationobserver.h"
 
@@ -102,4 +102,4 @@
     bool m_compositing;
 };
 
-#endif // SCREENCONTROLLER_H
+#endif // SCREENCONFIGURATIONOBSERVER_H

=== added file 'src/platforms/mirserver/windowmodelnotifier.cpp'
--- src/platforms/mirserver/windowmodelnotifier.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/windowmodelnotifier.cpp	2017-04-06 08:50:29 +0000
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 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 "windowmodelnotifier.h"
+
+#include <QMultiHash>
+#include <QMutex>
+
+using namespace qtmir;
+
+namespace {
+
+QMultiHash<const miral::Window, WindowNotifierObserver*> windowToObserverMap;
+QMutex mutex;
+
+} // anonymous namespace
+
+WindowModelNotifier::WindowModelNotifier()
+{
+    connect(this, &WindowModelNotifier::windowAdded,                this, [](const qtmir::NewWindow &window) {
+        WindowNotifierObserver::foreachObserverForWindow(window.windowInfo.window(), [](WindowNotifierObserver* observer) {
+            Q_EMIT observer->windowCreated();
+        });
+    }, Qt::QueuedConnection);
+
+    connect(this, &WindowModelNotifier::windowRemoved,              this, [](const miral::WindowInfo &windowInfo) {
+        WindowNotifierObserver::foreachObserverForWindow(windowInfo.window(), [](WindowNotifierObserver* observer) {
+            Q_EMIT observer->windowRemoved();
+        });
+    }, Qt::QueuedConnection);
+
+    connect(this, &WindowModelNotifier::windowReady,                this, [](const miral::WindowInfo &windowInfo) {
+        WindowNotifierObserver::foreachObserverForWindow(windowInfo.window(), [](WindowNotifierObserver* observer) {
+            Q_EMIT observer->windowReady();
+        });
+    }, Qt::QueuedConnection);
+
+    connect(this, &WindowModelNotifier::windowMoved,                this, [](const miral::WindowInfo &windowInfo, const QPoint &top_left) {
+        WindowNotifierObserver::foreachObserverForWindow(windowInfo.window(), [top_left](WindowNotifierObserver* observer) {
+            Q_EMIT observer->windowMoved(top_left);
+        });
+    }, Qt::QueuedConnection);
+
+    connect(this, &WindowModelNotifier::windowResized,              this, [](const miral::WindowInfo &windowInfo, const QSize &size) {
+        WindowNotifierObserver::foreachObserverForWindow(windowInfo.window(), [size](WindowNotifierObserver* observer) {
+            Q_EMIT observer->windowResized(size);
+        });
+    }, Qt::QueuedConnection);
+
+    connect(this, &WindowModelNotifier::windowStateChanged,         this, [](const miral::WindowInfo &windowInfo, Mir::State state) {
+        WindowNotifierObserver::foreachObserverForWindow(windowInfo.window(), [state](WindowNotifierObserver* observer) {
+            Q_EMIT observer->windowStateChanged(state);
+        });
+    }, Qt::QueuedConnection);
+
+    connect(this, &WindowModelNotifier::windowFocusChanged,         this, [](const miral::WindowInfo &windowInfo, bool focused) {
+        WindowNotifierObserver::foreachObserverForWindow(windowInfo.window(), [focused](WindowNotifierObserver* observer) {
+            Q_EMIT observer->windowFocusChanged(focused);
+        });
+    }, Qt::QueuedConnection);
+
+    connect(this, &WindowModelNotifier::windowRequestedRaise,       this, [this](const miral::WindowInfo &windowInfo) {
+        WindowNotifierObserver::foreachObserverForWindow(windowInfo.window(), [](WindowNotifierObserver* observer) {
+            Q_EMIT observer->windowRequestedRaise();
+        });
+    }, Qt::QueuedConnection);
+}
+
+WindowNotifierObserver::WindowNotifierObserver(const miral::Window &window)
+{
+    QMutexLocker locker(&mutex);
+    windowToObserverMap.insert(window, this);
+}
+
+WindowNotifierObserver::~WindowNotifierObserver()
+{
+    QMutexLocker locker(&mutex);
+    QMutableHashIterator<const miral::Window, WindowNotifierObserver*> i(windowToObserverMap);
+    while (i.hasNext()) {
+        i.next();
+        if (i.value() == this) {
+            i.remove();
+            return;
+        }
+    }
+}
+
+void WindowNotifierObserver::foreachObserverForWindow(const miral::Window &window,
+                                                      std::function<void(WindowNotifierObserver*)> fn)
+{
+    QMutexLocker locker(&mutex);
+    auto observers = windowToObserverMap.values(window);
+    Q_FOREACH(auto observer, observers) {
+        fn(observer);
+    }
+}

=== added file 'src/platforms/mirserver/workspacecontroller.cpp'
--- src/platforms/mirserver/workspacecontroller.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/workspacecontroller.cpp	2017-04-06 08:50:29 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2017 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 "workspacecontroller.h"
+#include "wrappedwindowmanagementpolicy.h"
+
+using namespace qtmir;
+
+
+WorkspaceController::WorkspaceController()
+    : m_policy(nullptr)
+{
+}
+
+void WorkspaceController::forEachWindowInWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::function<void (const miral::Window &)> &callback)
+{
+    if (m_policy) {
+        m_policy->for_each_window_in_workspace(workspace, callback);
+    }
+}
+
+void WorkspaceController::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,
+                                                          const std::shared_ptr<miral::Workspace> &from)
+{
+    if (m_policy) {
+        m_policy->move_worspace_content_to_workspace(to, from);
+    }
+}
+
+void WorkspaceController::moveWindowToWorkspace(const miral::Window &window,
+                                                const std::shared_ptr<miral::Workspace> &workspace)
+{
+    if (m_policy) {
+        m_policy->move_window_to_workspace(window, workspace);
+    }
+}
+
+void WorkspaceController::setPolicy(WrappedWindowManagementPolicy * const policy)
+{
+    m_policy = policy;
+}

=== added file 'src/platforms/mirserver/workspacecontroller.h'
--- src/platforms/mirserver/workspacecontroller.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/workspacecontroller.h	2017-04-06 08:50:29 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2017 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 WORKSPACECONTROLLER_H
+#define WORKSPACECONTROLLER_H
+
+#include "workspacecontrollerinterface.h"
+
+class WrappedWindowManagementPolicy;
+
+namespace qtmir {
+
+class WorkspaceController : public qtmir::WorkspaceControllerInterface
+{
+public:
+    WorkspaceController();
+    virtual ~WorkspaceController() = default;
+
+    void forEachWindowInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                  const std::function<void (const miral::Window &)> &callback) override;
+
+    void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,
+                                         const std::shared_ptr<miral::Workspace> &from) override;
+
+    void moveWindowToWorkspace(const miral::Window &window,
+                               const std::shared_ptr<miral::Workspace> &workspace) override;
+
+    void setPolicy(WrappedWindowManagementPolicy *policy);
+
+protected:
+    WrappedWindowManagementPolicy *m_policy;
+};
+
+} // namespace qtmir
+
+#endif // WINDOWCONTROLLER_H

=== modified file 'src/platforms/mirserver/wrappedwindowmanagementpolicy.cpp'
--- src/platforms/mirserver/wrappedwindowmanagementpolicy.cpp	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/wrappedwindowmanagementpolicy.cpp	2017-04-06 08:50:29 +0000
@@ -258,6 +258,22 @@
         Q_EMIT d->m_windowModel.windowsRaised(windows);
     }
 
+    void WindowManagementPolicy::advise_adding_to_workspace(std::shared_ptr<miral::Workspace> const& workspace,
+                                                            std::vector<miral::Window> const& windows)
+    {
+        miral::WorkspacePolicy::advise_adding_to_workspace(workspace, windows);
+
+        Q_EMIT d->m_windowModel.windowsAddedToWorkspace(workspace, windows);
+    }
+
+    void WindowManagementPolicy::advise_removing_from_workspace(std::shared_ptr<miral::Workspace> const& workspace,
+                                                                std::vector<miral::Window> const& windows)
+    {
+        miral::WorkspacePolicy::advise_removing_from_workspace(workspace, windows);
+
+        Q_EMIT d->m_windowModel.windowsAboutToBeRemovedFromWorkspace(workspace, windows);
+    }
+
     Rectangle WindowManagementPolicy::confirm_inherited_move(miral::WindowInfo const& windowInfo, Displacement movement)
     {
         if (d->m_confinementRegions.isEmpty()) {
@@ -309,6 +325,7 @@
 WrappedWindowManagementPolicy::WrappedWindowManagementPolicy(const miral::WindowManagerTools &tools,
                                                qtmir::WindowModelNotifier &windowModel,
                                                qtmir::WindowController &windowController,
+                                               qtmir::WorkspaceController &workspaceController,
                                                qtmir::AppNotifier &appNotifier,
                                                const std::shared_ptr<QtEventFeeder> &eventFeeder,
                                                const qtmir::WindowManagmentPolicyBuilder &wmBuilder)
@@ -321,6 +338,7 @@
     qRegisterMetaType<std::vector<miral::Window>>();
     qRegisterMetaType<miral::ApplicationInfo>();
     windowController.setPolicy(this);
+    workspaceController.setPolicy(this);
 }
 
 /* Following are hooks to allow custom policy be imposed */
@@ -467,6 +485,18 @@
     qtmir::dispatchInputEvent(window, mir_pointer_event_input_event(event));
 }
 
+void WrappedWindowManagementPolicy::advise_adding_to_workspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                                               const std::vector<miral::Window> &windows)
+{
+    m_wrapper->advise_adding_to_workspace(workspace, windows);
+}
+
+void WrappedWindowManagementPolicy::advise_removing_from_workspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                                                   const std::vector<miral::Window> &windows)
+{
+    m_wrapper->advise_removing_from_workspace(workspace, windows);
+}
+
 void WrappedWindowManagementPolicy::activate(const miral::Window &window)
 {
     if (window) {
@@ -574,3 +604,44 @@
 
     // TODO: update window positions/sizes to respect new margins.
 }
+
+void WrappedWindowManagementPolicy::for_each_window_in_workspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                                                 std::function<void(miral::Window const&)> const& callback)
+{
+    tools.invoke_under_lock([&]() {
+        tools.for_each_window_in_workspace(workspace, callback);
+    });
+}
+
+void WrappedWindowManagementPolicy::move_worspace_content_to_workspace(const std::shared_ptr<miral::Workspace> &to,
+                                                                       const std::shared_ptr<miral::Workspace> &from)
+{
+    tools.invoke_under_lock([&]() {
+        tools.move_workspace_content_to_workspace(to, from);
+    });
+}
+
+void WrappedWindowManagementPolicy::move_window_to_workspace(const miral::Window &window,
+                                                             const std::shared_ptr<miral::Workspace> &workspace)
+{
+    tools.invoke_under_lock([&]() {
+        auto root = window;
+        auto const* info = &tools.info_for(root);
+
+        while (auto const& parent = info->parent())
+        {
+            root = parent;
+            info = &tools.info_for(root);
+        }
+
+        std::vector<std::shared_ptr<miral::Workspace>> workspaces;
+        tools.for_each_workspace_containing(root, [&](std::shared_ptr<miral::Workspace> const& from) {
+            workspaces.push_back(from);
+        });
+        for (auto wks : workspaces) {
+            tools.remove_tree_from_workspace(root, wks);
+        }
+        tools.add_tree_to_workspace(root, workspace);
+    });
+}
+

=== modified file 'src/platforms/mirserver/wrappedwindowmanagementpolicy.h'
--- src/platforms/mirserver/wrappedwindowmanagementpolicy.h	2017-04-06 08:50:28 +0000
+++ src/platforms/mirserver/wrappedwindowmanagementpolicy.h	2017-04-06 08:50:29 +0000
@@ -17,11 +17,12 @@
 #ifndef WRAPPEDWINDOWMANAGEMENTPOLICY_H
 #define WRAPPEDWINDOWMANAGEMENTPOLICY_H
 
+#include "qtmir/windowmanagementpolicy.h"
 #include "appnotifier.h"
 #include "qteventfeeder.h"
 #include "windowcontroller.h"
 #include "windowmodelnotifier.h"
-#include "qtmir/windowmanagementpolicy.h"
+#include "workspacecontroller.h"
 
 
 using namespace mir::geometry;
@@ -34,6 +35,7 @@
     WrappedWindowManagementPolicy(const miral::WindowManagerTools &tools,
                                   qtmir::WindowModelNotifier &windowModel,
                                   qtmir::WindowController &windowController,
+                                  qtmir::WorkspaceController &workspaceController,
                                   qtmir::AppNotifier &appNotifier,
                                   const std::shared_ptr<QtEventFeeder> &eventFeeder,
                                   const qtmir::WindowManagmentPolicyBuilder &wmBuilder);
@@ -68,7 +70,12 @@
     void advise_delete_window(const miral::WindowInfo &windowInfo) override;
     void advise_raise(const std::vector<miral::Window> &windows) override;
 
-    Rectangle confirm_inherited_move(miral::WindowInfo const& windowInfo, Displacement movement) override;
+    Rectangle confirm_inherited_move(const miral::WindowInfo &windowInfo, Displacement movement) override;
+
+    void advise_adding_to_workspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                    const std::vector<miral::Window> &windows) override;
+    void advise_removing_from_workspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                        const std::vector<miral::Window> &windows) override;
 
     // Methods for consumption by WindowControllerInterface
     void deliver_keyboard_event(const MirKeyboardEvent *event, const miral::Window &window);
@@ -87,6 +94,14 @@
     void set_window_confinement_regions(const QVector<QRect> &regions);
     void set_window_margins(MirWindowType windowType, const QMargins &margins);
 
+    // Methods for consumption by WorkspaceControllerInterface
+    void for_each_window_in_workspace(const std::shared_ptr<miral::Workspace> &workspace,
+                                      std::function<void(miral::Window const&)> const& callback);
+    void move_worspace_content_to_workspace(const std::shared_ptr<miral::Workspace> &to,
+                                            const std::shared_ptr<miral::Workspace> &from);
+    void move_window_to_workspace(const miral::Window &window,
+                                  const std::shared_ptr<miral::Workspace> &workspace);
+
 private:
     std::shared_ptr<qtmir::WindowManagementPolicy> m_wrapper;
 };

=== modified file 'tests/mirserver/Screen/CMakeLists.txt'
--- tests/mirserver/Screen/CMakeLists.txt	2017-04-06 08:50:28 +0000
+++ tests/mirserver/Screen/CMakeLists.txt	2017-04-06 08:50:29 +0000
@@ -5,6 +5,7 @@
 )
 
 include_directories(
+  ${CMAKE_SOURCE_DIR}/include
   ${CMAKE_SOURCE_DIR}/tests/framework
   ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
   ${CMAKE_SOURCE_DIR}/src/common

=== modified file 'tests/mirserver/ScreensModel/CMakeLists.txt'
--- tests/mirserver/ScreensModel/CMakeLists.txt	2017-04-06 08:50:28 +0000
+++ tests/mirserver/ScreensModel/CMakeLists.txt	2017-04-06 08:50:29 +0000
@@ -8,6 +8,7 @@
 )
 
 include_directories(
+  ${CMAKE_SOURCE_DIR}/include
   ${CMAKE_SOURCE_DIR}/tests/framework
   ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
   ${CMAKE_SOURCE_DIR}/src/common

=== modified file 'tests/modules/SurfaceManager/surface_manager_test.cpp'
--- tests/modules/SurfaceManager/surface_manager_test.cpp	2017-03-20 16:19:42 +0000
+++ tests/modules/SurfaceManager/surface_manager_test.cpp	2017-04-06 08:50:29 +0000
@@ -127,7 +127,7 @@
     qtApp->sendPostedEvents();
 
     // Check result
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
     EXPECT_EQ(window, mirSurface->window());
 }
@@ -147,7 +147,7 @@
     qtApp->sendPostedEvents();
 
     // Check result
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
     EXPECT_EQ(&fakeSession, mirSurface->session());
 }
@@ -171,8 +171,8 @@
     qtApp->sendPostedEvents();
 
     // Check result
-    auto childMirSurface = surfaceManager->find(childWindowInfo);
-    auto parentMirSurface = surfaceManager->find(parentWindowInfo);
+    auto childMirSurface = surfaceManager->surfaceFor(childWindow);
+    auto parentMirSurface = surfaceManager->surfaceFor(parentWindow);
     ASSERT_TRUE(childMirSurface);
     ASSERT_TRUE(parentMirSurface);
 
@@ -198,8 +198,8 @@
     qtApp->sendPostedEvents();
 
     // Check result
-    auto childMirSurface = surfaceManager->find(childWindowInfo);
-    auto parentMirSurface = surfaceManager->find(parentWindowInfo);
+    auto childMirSurface = surfaceManager->surfaceFor(childWindow);
+    auto parentMirSurface = surfaceManager->surfaceFor(parentWindow);
     ASSERT_TRUE(childMirSurface);
     ASSERT_TRUE(parentMirSurface);
 
@@ -216,7 +216,7 @@
     // Setup: add window and get corresponding MirSurface
     Q_EMIT wmNotifier.windowAdded(windowInfo);
     qtApp->sendPostedEvents();
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
 
     QSignalSpy mirSurfaceReadySpy(mirSurface, &MirSurface::ready);
@@ -240,7 +240,7 @@
     // Setup: add window and get corresponding MirSurface
     Q_EMIT wmNotifier.windowAdded(windowInfo);
     qtApp->sendPostedEvents();
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
 
     QSignalSpy mirSurfacePositionSpy(mirSurface, &MirSurface::positionChanged);
@@ -263,7 +263,7 @@
     // Setup: add window and get corresponding MirSurface
     Q_EMIT wmNotifier.windowAdded(windowInfo);
     qtApp->sendPostedEvents();
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
     ASSERT_FALSE(mirSurface->focused()); // false must be the initial state
 
@@ -289,7 +289,7 @@
     // Setup: add window and get corresponding MirSurface
     Q_EMIT wmNotifier.windowAdded(windowInfo);
     qtApp->sendPostedEvents();
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
 
     QSignalSpy mirSurfaceStateSpy(mirSurface, &MirSurface::stateChanged);
@@ -319,8 +319,8 @@
     Q_EMIT wmNotifier.windowAdded(windowInfo1);
     Q_EMIT wmNotifier.windowAdded(windowInfo2);
     qtApp->sendPostedEvents();
-    auto mirSurface1 = surfaceManager->find(windowInfo1);
-    auto mirSurface2 = surfaceManager->find(windowInfo2);
+    auto mirSurface1 = surfaceManager->surfaceFor(window1);
+    auto mirSurface2 = surfaceManager->surfaceFor(window2);
     ASSERT_TRUE(mirSurface1);
     ASSERT_TRUE(mirSurface2);
 
@@ -348,7 +348,7 @@
     // Setup: add window and get corresponding MirSurface
     Q_EMIT wmNotifier.windowAdded(windowInfo);
     qtApp->sendPostedEvents();
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
 
     QSignalSpy mirSurfaceFocusRequestedSpy(mirSurface, &MirSurface::focusRequested);
@@ -371,7 +371,7 @@
     // Setup: add window and get corresponding MirSurface
     Q_EMIT wmNotifier.windowAdded(windowInfo);
     qtApp->sendPostedEvents();
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
 
     QSignalSpy mirSurfaceDestroyedSpy(mirSurface, &QObject::destroyed);
@@ -382,7 +382,7 @@
 
     // Check result
     ASSERT_EQ(2, mirSurfaceDestroyedSpy.count()); //FIXME - should be 1
-    EXPECT_FALSE(surfaceManager->find(windowInfo));
+    EXPECT_FALSE(surfaceManager->surfaceFor(window));
 }
 
 /*
@@ -395,7 +395,7 @@
     // Setup: add window and get corresponding MirSurface
     Q_EMIT wmNotifier.windowAdded(windowInfo);
     qtApp->sendPostedEvents();
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
 
     QSignalSpy mirSurfaceDestroyedSpy(mirSurface, &QObject::destroyed);
@@ -408,7 +408,7 @@
 
     // Check result
     ASSERT_EQ(0, mirSurfaceDestroyedSpy.count());
-    EXPECT_FALSE(surfaceManager->find(windowInfo));
+    EXPECT_FALSE(surfaceManager->surfaceFor(window));
     EXPECT_FALSE(mirSurface->live());
 }
 
@@ -424,7 +424,7 @@
     // Setup: add window and get corresponding MirSurface
     Q_EMIT wmNotifier.windowAdded(windowInfo);
     qtApp->sendPostedEvents();
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
 
     QSignalSpy mirSurfaceDestroyedSpy(mirSurface, &QObject::destroyed);
@@ -458,7 +458,7 @@
     // Setup: add window and get corresponding MirSurface
     Q_EMIT wmNotifier.windowAdded(windowInfo);
     qtApp->sendPostedEvents();
-    auto mirSurface = surfaceManager->find(windowInfo);
+    auto mirSurface = surfaceManager->surfaceFor(window);
     ASSERT_TRUE(mirSurface);
     ASSERT_TRUE(mirSurface->live());