Merge lp:~nick-dedekind/qtmir/multiwindow.configuration into lp:qtmir

[Nick Dedekind]

Screen configuration

Prereq-archive: ppa:ci-train-ppa-service/ubuntu/2373

[Gerry Boland (gerboland)]

+class ScreenAdapter : public QObject
could this not inherit QScreen?

The config design is good IMO, some things cannot be declarative.

+class ScreenMode : public QObject
http://doc.qt.io/qt-5/qobject.html#Q_GADGET would be lighter.

Overall design looks good IMO.

[Gerry Boland (gerboland)]

One request: please keep a qml server demo with spinny logo that I must tap/click to start/stop. I use that lot as a quick test for input and rendering speeds.

[Nick Dedekind (nick-dedekind)]

> One request: please keep a qml server demo with spinny logo that I must
> tap/click to start/stop. I use that lot as a quick test for input and
> rendering speeds.

It didnt seem to be used so i removed it. I'm guessing you were just loading the qml file.
I've added the spinny logo to the qtmir-demo-shell.
Is this enough, or do you want the qml file to load separately?

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:620
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/674/
Executed test runs:
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build/4917/console
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/4945
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/4753/console
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=zesty/4753/console
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/4753/console
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=zesty/4753/console
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/4753/console
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=zesty/4753/console

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/674/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

620. By Nick Dedekind on 2017-04-06

changelog

619. By Nick Dedekind on 2017-04-05

merged pre-req

618. By Nick Dedekind on 2017-04-04

merged pre-req

617. By Nick Dedekind on 2017-04-03

merged pre-req

616. By Nick Dedekind on 2017-03-28

added spinny logo to shell demo

615. By Nick Dedekind on 2017-03-24

merged parent

614. By Nick Dedekind on 2017-03-20

merged with parent

613. By Nick Dedekind on 2017-03-16

merged with parent

612. By Nick Dedekind on 2017-03-13

merged parent

611. By Nick Dedekind on 2017-03-10

merged with parent

=== modified file 'debian/changelog'
--- debian/changelog	2017-04-06 08:48:51 +0000
+++ debian/changelog	2017-04-06 08:48:52 +0000
@@ -1,11 +1,12 @@
-qtmir (0.6.0ubuntu1) UNRELEASED; urgency=medium
+qtmir (0.6.0ubuntu3) 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
 
- -- Nick Dedekind <[e-mail]>  Thu, 06 Apr 2017 09:45:53 +0100
+ -- Nick Dedekind <[e-mail]>  Thu, 06 Apr 2017 09:48:21 +0100
 
 qtmir (0.5.1+17.04.20170328-0ubuntu1) zesty; urgency=medium
 

=== modified file 'demos/qml-demo-client/CMakeLists.txt'
--- demos/qml-demo-client/CMakeLists.txt	2016-06-06 18:12:07 +0000
+++ demos/qml-demo-client/CMakeLists.txt	2017-04-06 08:48:52 +0000
@@ -22,6 +22,9 @@
 
 file(GLOB QML_JS_FILES *.qml *.js *.png)
 
+add_custom_target(${DEMO_CLIENT}-qmlfiles
+                  SOURCES ${QML_JS_FILES})
+
 # install binaries
 install(TARGETS ${DEMO_CLIENT}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
@@ -35,4 +38,4 @@
 install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/${DEMO_CLIENT}.desktop
     DESTINATION ${CMAKE_INSTALL_PREFIX}/share/applications
-)
\ No newline at end of file
+)

=== modified file 'demos/qml-demo-shell/CMakeLists.txt'
--- demos/qml-demo-shell/CMakeLists.txt	2017-04-06 08:48:51 +0000
+++ demos/qml-demo-shell/CMakeLists.txt	2017-04-06 08:48:52 +0000
@@ -31,6 +31,9 @@
 
 file(GLOB QML_JS_FILES *.qml *.js *.png)
 
+add_custom_target(${DEMO_SHELL}-qmlfiles
+                  SOURCES ${QML_JS_FILES})
+
 # install binaries
 install(TARGETS ${DEMO_SHELL}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}

=== added file 'demos/qml-demo-shell/ScreenConfiguration.qml'
--- demos/qml-demo-shell/ScreenConfiguration.qml	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/ScreenConfiguration.qml	2017-04-06 08:48:52 +0000
@@ -0,0 +1,78 @@
+import QtQuick 2.0
+import Ubuntu.Components 1.3
+import Ubuntu.Components.ListItems 1.3
+
+Rectangle {
+
+    width: column.width + units.gu(2)
+    height: column.height + units.gu(2)
+
+    color: "transparent"
+    border.width: 1
+    border.color: "black"
+
+    property QtObject screen: null
+
+    Column {
+        id: column
+        anchors.centerIn: parent
+        spacing: 10
+
+        Label {
+            text: screen.name
+        }
+
+        ThinDivider {}
+
+        Column {
+            Label { text: "Used" }
+            CheckBox { id: useChecked; checked: screen.used; }
+        }
+
+        Label {
+            text: "Mode"
+        }
+
+        ItemSelector {
+            id: currentMode
+            width: units.gu(30)
+
+            model:  screen.availableModes
+
+            delegate: OptionSelectorDelegate { text: String(size.width + " x " + size.height + "    (" + refreshRate + "Hz)") }
+            selectedIndex: screen.currentModeIndex
+        }
+
+        Label {
+            text: "scale"
+        }
+
+        Slider {
+            id: slider
+            width: units.gu(30)
+            minimumValue: 1
+            maximumValue: 4
+            stepSize: 1
+            value: screen.scale
+            function formatValue(v) { return v; }
+        }
+
+        Button {
+            text: "Apply"
+            onClicked: {
+                var config = screen.beginConfiguration();
+
+                config.used = useChecked.checked;
+                config.currentModeIndex = currentMode.selectedIndex;
+                config.scale = slider.value;
+
+                screen.applyConfiguration(config);
+
+                // Fix up control bindings
+                usedChecked.checked = Qt.binding(function() { return screen.used; });
+                currentMode.selectedIndex = Qt.binding(function() { return screen.currentModeIndex; });
+                slider.value = Qt.binding(function() { return screen.scale; });
+            }
+        }
+    }
+}

=== renamed file 'demos/qml-demo-shell/windowModel.qml' => 'demos/qml-demo-shell/Shell.qml'
--- demos/qml-demo-shell/windowModel.qml	2016-11-03 20:17:46 +0000
+++ demos/qml-demo-shell/Shell.qml	2017-04-06 08:48:52 +0000
@@ -6,6 +6,41 @@
     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;
     }
@@ -69,8 +104,8 @@
         color: "black"
         width: 6
         height: 10
-        x: PointerPosition.x
-        y: PointerPosition.y
+        x: PointerPosition.x - window.screen.position.x
+        y: PointerPosition.y - window.screen.position.y
     }
 
     MouseArea {

=== removed file 'demos/qml-demo-shell/Shell.qml'
--- demos/qml-demo-shell/Shell.qml	2015-09-30 13:40:06 +0000
+++ demos/qml-demo-shell/Shell.qml	1970-01-01 00:00:00 +0000
@@ -1,182 +0,0 @@
-import QtQuick 2.4
-import Unity.Application 0.1
-
-Rectangle {
-    id: root
-
-    focus: true
-    Keys.onVolumeUpPressed: {
-        console.log("\"Volume Up\" pressed");
-    }
-    Keys.onVolumeDownPressed: {
-        console.log("\"Volume Down\" pressed");
-    }
-
-    property bool resizeModeStretch: true
-
-    gradient: Gradient {
-        GradientStop { position: 0.0; color: "lightsteelblue" }
-        GradientStop { position: 1.0; color: "pink" }
-    }
-
-    property bool thumbFriendlyBorders: false
-
-    MultiPointTouchArea {
-        anchors.fill: parent
-        mouseEnabled: false
-        onPressed: {
-            root.thumbFriendlyBorders = true;
-        }
-        onReleased: {
-            root.thumbFriendlyBorders = false;
-        }
-    }
-
-    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();
-                }
-            }
-        }
-    }
-
-    Item {
-        id: windowContainer
-        anchors.fill: root
-    }
-
-    Rectangle {
-        id: quitButton
-        width: 60
-        height: 40
-        color: "red"
-        anchors { right: parent.right; bottom: parent.bottom }
-        Text {
-            anchors.centerIn: parent
-            text: "Quit"
-        }
-        MouseArea {
-            anchors.fill: parent
-            onClicked: Qt.quit()
-        }
-    }
-
-    Rectangle {
-        id: resizeButton
-        width: 90
-        height: 40
-        color: "blue"
-        anchors { right: quitButton.left; bottom: parent.bottom }
-        Text {
-            anchors.centerIn: parent
-            text: root.resizeModeStretch ? "Stretch" : "Wait Resize"
-            color: "white"
-        }
-        MouseArea {
-            anchors.fill: parent
-            onClicked: { root.resizeModeStretch = !root.resizeModeStretch; }
-        }
-    }
-
-    Rectangle {
-        width: 40
-        height: 40
-        color: "green"
-        anchors { right: resizeButton.left; bottom: parent.bottom }
-        Text {
-            anchors.centerIn: parent
-            text: "⟳"
-            color: "white"
-            font.pixelSize: 35
-        }
-        MouseArea {
-            anchors.fill: parent
-            onClicked: { root.rotation += 180; }
-        }
-    }
-
-    Component {
-        id: windowStretchComponent
-        Window {
-            x: 50
-            y: 50
-            //width: 200
-            //height: 200
-            touchMode: root.thumbFriendlyBorders
-
-            onCloneRequested: {
-                var window = windowStretchComponent.createObject(windowContainer);
-                window.cloned = true;
-                window.surface = surface;
-            }
-        }
-    }
-
-    Component {
-        id: windowWaitResizeComponent
-        WindowBufferSized {
-            x: 50
-            y: 50
-            touchMode: root.thumbFriendlyBorders
-
-            onCloneRequested: {
-                var window = windowStretchComponent.createObject(windowContainer);
-                window.cloned = true;
-                window.surface = surface;
-            }
-        }
-    }
-
-    property var windowComponent: resizeModeStretch ? windowStretchComponent : windowWaitResizeComponent
-
-    Connections {
-        target: SurfaceManager
-        onSurfaceCreated: {
-            print("new surface", surface.name)
-
-            var window = windowComponent.createObject(windowContainer);
-            if (!window) {
-                console.warn(windowComponent.errorString());
-                return;
-            }
-
-            window.surface = surface;
-
-            openAnimation.target = window;
-            openAnimation.start();
-        }
-    }
-
-    NumberAnimation {
-        id: openAnimation
-        property: "x";
-        from: root.width; to: 10;
-        duration: 1200; easing.type: Easing.InOutQuad
-    }
-}

=== modified file 'demos/qml-demo-shell/main.cpp'
--- demos/qml-demo-shell/main.cpp	2017-04-06 08:48:51 +0000
+++ demos/qml-demo-shell/main.cpp	2017-04-06 08:48:52 +0000
@@ -17,8 +17,10 @@
 // Qt
 #include <QtQuick/QQuickView>
 #include <QtGui/QGuiApplication>
-#include <QtQml/QQmlEngine>
+#include <QtQml/QQmlApplicationEngine>
 #include <QtQml/QQmlContext>
+#include <QJsonObject>
+#include <QJsonDocument>
 #include <QDebug>
 #include <libintl.h>
 #include "../paths.h"
@@ -29,6 +31,20 @@
 #include <qtmir/sessionauthorizer.h>
 #include <qtmir/windowmanagementpolicy.h>
 #include <qtmir/displayconfigurationstorage.h>
+#include <qtmir/miral/edid.h>
+
+
+inline QString stringFromEdid(const miral::Edid& edid)
+{
+    QString str;
+    str += QString::fromStdString(edid.vendor);
+    str += QString("%1%2").arg(edid.product_code).arg(edid.serial_number);
+
+    for (int i = 0; i < 4; i++) {
+        str += QString::fromStdString(edid.descriptors[i].string_value());
+    }
+    return str;
+}
 
 struct DemoDisplayConfigurationPolicy : qtmir::DisplayConfigurationPolicy
 {
@@ -46,23 +62,80 @@
         : qtmir::WindowManagementPolicy(tools, dd)
     {}
 
+    bool handle_pointer_event(const MirPointerEvent *event) override
+    {
+        return qtmir::WindowManagementPolicy::handle_pointer_event(event);
+    }
+
     bool handle_keyboard_event(const MirKeyboardEvent *event) override
     {
-        qDebug() << "OVERRIDE qtmir::WindowManagementPolicy::handle_keyboard_event" << event;
         return qtmir::WindowManagementPolicy::handle_keyboard_event(event);
     }
 };
 
 struct DemoDisplayConfigurationStorage : miral::DisplayConfigurationStorage
 {
-    void save(const miral::DisplayId&, const miral::DisplayConfigurationOptions&) override
+    void save(const miral::DisplayId& displayId, const miral::DisplayConfigurationOptions& options) override
     {
-        qDebug() << "OVERRIDE miral::DisplayConfigurationStorage::save";
+        QFile f(stringFromEdid(displayId.edid) + ".edid");
+        qDebug() << "OVERRIDE miral::DisplayConfigurationStorage::save" << f.fileName();
+
+        QJsonObject json;
+        if (options.used.is_set()) json.insert("used", options.used.value());
+        if (options.clone_output_index.is_set()) json.insert("clone_output_index", static_cast<int>(options.clone_output_index.value()));
+        if (options.mode.is_set()) {
+            auto const& mode = options.mode.value();
+
+            QString sz(QString("%1x%2").arg(mode.size.width.as_int()).arg(mode.size.height.as_int()));
+            QJsonObject jsonMode({
+                {"size", sz},
+                {"refresh_rate", mode.refresh_rate }
+            });
+            json.insert("mode", jsonMode);
+        }
+        if (options.orientation.is_set()) json.insert("orientation", static_cast<int>(options.orientation.value()));
+        if (options.form_factor.is_set()) json.insert("form_factor", static_cast<int>(options.form_factor.value()));
+        if (options.scale.is_set()) json.insert("scale", options.scale.value());
+
+        if (f.open(QIODevice::WriteOnly)) {
+            QJsonDocument saveDoc(json);
+            f.write(saveDoc.toJson());
+        }
     }
 
-    bool load(const miral::DisplayId&, miral::DisplayConfigurationOptions&) const override
+    bool load(const miral::DisplayId& displayId, miral::DisplayConfigurationOptions& options) const override
     {
-        qDebug() << "OVERRIDE miral::DisplayConfigurationStorage::load";
+        QFile f(stringFromEdid(displayId.edid) + ".edid");
+        qDebug() << "OVERRIDE miral::DisplayConfigurationStorage::load" << f.fileName();
+
+        if (f.open(QIODevice::ReadOnly)) {
+            QByteArray saveData = f.readAll();
+            QJsonDocument loadDoc(QJsonDocument::fromJson(saveData));
+
+            QJsonObject json(loadDoc.object());
+            if (json.contains("used")) options.used = json["used"].toBool();
+            if (json.contains("clone_output_index")) options.clone_output_index = json["clone_output_index"].toInt();
+            if (json.contains("mode")) {
+                QJsonObject jsonMode = json["mode"].toObject();
+
+                if (jsonMode.contains("size") && jsonMode.contains("refresh_rate")) {
+                    QString sz(jsonMode["size"].toString());
+                    QStringList geo = sz.split("x", QString::SkipEmptyParts);
+                    if (geo.count() == 2) {
+                        miral::DisplayConfigurationOptions::DisplayMode mode;
+                        mode.size = mir::geometry::Size(geo[0].toInt(), geo[1].toInt());
+                        mode.refresh_rate = jsonMode["refresh_rate"].toDouble();
+                        options.mode = mode;
+                    }
+                }
+            }
+            if (json.contains("orientation")) options.orientation = static_cast<MirOrientation>(json["orientation"].toInt());
+            if (json.contains("form_factor")) options.form_factor = static_cast<MirFormFactor>(json["form_factor"].toInt());
+            if (json.contains("scale")) options.scale = json["form_factor"].toDouble();
+
+            return true;
+        }
+
         return false;
     }
 };
@@ -110,24 +183,17 @@
     qtmir::MirServerApplication *application;
 
     application = new qtmir::MirServerApplication(argc, (char**)argv, { displayConfig, sessionAuth, wmPolicy, displayStorage });
-    QQuickView* view = new QQuickView();
-    view->engine()->addImportPath(::qmlPluginDirectory());
-    view->setResizeMode(QQuickView::SizeRootObjectToView);
-    view->setColor("lightgray");
-    view->setTitle("Demo Shell");
+    auto qmlEngine = new QQmlApplicationEngine(application);
+    qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory() + "api-demo-shell"));
+    qmlEngine->addImportPath(::qmlPluginDirectory());
+    QObject::connect(qmlEngine, &QQmlEngine::quit, application, &QGuiApplication::quit);
 
     qmlRegisterSingletonType<PointerPosition>("Mir.Pointer", 0, 1, "PointerPosition",
         [](QQmlEngine*, QJSEngine*) -> QObject* { return PointerPosition::instance(); });
 
-    QUrl source(::qmlDirectory() + "qml-demo-shell/windowModel.qml");
-
-    view->setSource(source);
-    QObject::connect(view->engine(), SIGNAL(quit()), application, SLOT(quit()));
-
-    view->showFullScreen();
+    qmlEngine->load(::qmlDirectory() + "qml-demo-shell/qml-demo-shell.qml");
+
     int result = application->exec();
-
-    delete view;
     delete application;
 
     return result;

=== modified file 'demos/qml-demo-shell/pointerposition.cpp'
--- demos/qml-demo-shell/pointerposition.cpp	2016-11-03 20:17:46 +0000
+++ demos/qml-demo-shell/pointerposition.cpp	2017-04-06 08:48:52 +0000
@@ -52,5 +52,8 @@
 
 PointerPosition::~PointerPosition()
 {
-    qGuiApp->removeEventFilter(this);
+    // If this is a singleton the qApp probably won't exist.
+    if (qGuiApp) {
+        qGuiApp->removeEventFilter(this);
+    }
 }

=== modified file 'demos/qml-demo-shell/qml-demo-shell.qml'
--- demos/qml-demo-shell/qml-demo-shell.qml	2016-11-23 16:15:28 +0000
+++ demos/qml-demo-shell/qml-demo-shell.qml	2017-04-06 08:48:52 +0000
@@ -1,38 +1,31 @@
-import QtQuick 2.3
+import QtQuick 2.5
 import Unity.Screens 0.1
 
 Instantiator {
     id: root
 
-    property var screens: Screens{}
+    model: Screens
 
-    model: screens
     ScreenWindow {
         id: window
         visible: true
         screen: model.screen
-        Shell{ anchors.fill: parent }
-        Component.onCompleted: {
-            print("Window created for Screen", screen, screen.geometry, outputType, Screens.HDMIA, screen.devicePixelRatio)
-        }
-        Component.onDestruction: {
-            print("Window destroyed")
-        }
-        onScaleChanged: print("NOTICE: scale changed for", model.screen, "to", scale);
-        onFormFactorChanged: print("NOTICE: form factor changed for", model.screen, "to", formFactor)
-        Button {
-            anchors { left: parent.left; bottom: parent.bottom }
-            height: 100
-            width: parent.width / 2
-            text: "Scale up"
-            onClicked: window.setScaleAndFormFactor(window.scale + 0.2, Screens.FormFactorMonitor)
-        }
-        Button {
-            anchors { right: parent.right; bottom: parent.bottom }
-            height: 100
-            width: parent.width / 2
-            text: "Scale down"
-            onClicked: window.setScaleAndFormFactor(window.scale - 0.2, Screens.FormFactorTablet)
+
+        Row {
+            x: 10
+            y: 10
+            Repeater {
+                model: Screens
+                ScreenConfiguration {
+                    screen: model.screen
+                }
+            }
+        }
+
+        Shell {
+            width: parent.width
+            height: parent.height
+            z: 1
         }
     }
 }

=== modified file 'src/modules/Unity/Screens/CMakeLists.txt'
--- src/modules/Unity/Screens/CMakeLists.txt	2017-04-06 08:48:51 +0000
+++ src/modules/Unity/Screens/CMakeLists.txt	2017-04-06 08:48:52 +0000
@@ -12,7 +12,9 @@
 set(SCREENSPLUGIN_SRC
     plugin.cpp
     screens.cpp
+    screen.cpp
     qquickscreenwindow.cpp
+    types.h
     )
 
 add_library(unityscreensplugin SHARED

=== modified file 'src/modules/Unity/Screens/plugin.cpp'
--- src/modules/Unity/Screens/plugin.cpp	2017-04-06 08:48:51 +0000
+++ src/modules/Unity/Screens/plugin.cpp	2017-04-06 08:48:52 +0000
@@ -21,6 +21,7 @@
 
 // local
 #include "screens.h"
+#include "screen.h"
 #include "qquickscreenwindow.h"
 
 using namespace qtmir;
@@ -42,7 +43,10 @@
     {
         Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Screens"));
 
-        qRegisterMetaType<QScreen*>("QScreen*");
+        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");

=== modified file 'src/modules/Unity/Screens/qquickscreenwindow.cpp'
--- src/modules/Unity/Screens/qquickscreenwindow.cpp	2017-04-06 08:48:51 +0000
+++ src/modules/Unity/Screens/qquickscreenwindow.cpp	2017-04-06 08:48:52 +0000
@@ -17,6 +17,7 @@
 #include "qquickscreenwindow.h"
 
 // mirserver
+#include "screen.h"
 #include "screenscontroller.h"
 #include "logging.h"
 
@@ -36,7 +37,26 @@
     if (qGuiApp->platformName() != QLatin1String("mirserver")) {
         qCritical("Not using 'mirserver' QPA plugin. Using ScreenWindow may produce unknown results.");
     }
-    connect(this, &QWindow::screenChanged, this, &QQuickScreenWindow::screenChanged);
-
-    DEBUG_MSG << "()";
+
+    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());
 }

=== modified file 'src/modules/Unity/Screens/qquickscreenwindow.h'
--- src/modules/Unity/Screens/qquickscreenwindow.h	2017-04-06 08:48:51 +0000
+++ src/modules/Unity/Screens/qquickscreenwindow.h	2017-04-06 08:48:52 +0000
@@ -18,6 +18,9 @@
 #define QQUICKSCREENWINDOW_H
 
 #include <QQuickWindow>
+#include <QPointer>
+
+class ScreenAdapter;
 
 namespace qtmir {
 
@@ -27,14 +30,20 @@
 class QQuickScreenWindow : public QQuickWindow
 {
     Q_OBJECT
-    Q_PROPERTY(QScreen *screen READ screen WRITE setScreen NOTIFY screenChanged)
-
+    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 screenChanged(QScreen* screen);
+    void screenWrapperChanged();
 
+private:
+    QPointer<ScreenAdapter> m_screen;
 };
 
 } //namespace qtmir

=== added file 'src/modules/Unity/Screens/screen.cpp'
--- src/modules/Unity/Screens/screen.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Screens/screen.cpp	2017-04-06 08:48:52 +0000
@@ -0,0 +1,213 @@
+#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;
+}

=== added file 'src/modules/Unity/Screens/screen.h'
--- src/modules/Unity/Screens/screen.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Screens/screen.h	2017-04-06 08:48:52 +0000
@@ -0,0 +1,99 @@
+#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

=== modified file 'src/modules/Unity/Screens/screens.cpp'
--- src/modules/Unity/Screens/screens.cpp	2017-04-06 08:48:51 +0000
+++ src/modules/Unity/Screens/screens.cpp	2017-04-06 08:48:52 +0000
@@ -15,6 +15,7 @@
  */
 
 #include "screens.h"
+#include "screen.h"
 
 // mirserver
 #include "platformscreen.h"
@@ -33,14 +34,17 @@
 Screens::Screens(QObject *parent) :
     QAbstractListModel(parent)
 {
-    auto app = static_cast<QGuiApplication *>(QGuiApplication::instance());
-    if (!app) {
-        return;
-    }
-    connect(app, &QGuiApplication::screenAdded, this, &Screens::onScreenAdded);
-    connect(app, &QGuiApplication::screenRemoved, this, &Screens::onScreenRemoved);
-
-    m_screenList = QGuiApplication::screens();
+    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 << ")";
 }
 
@@ -75,31 +79,62 @@
     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)
 {
-    if (m_screenList.contains(screen))
-        return;
+    Q_FOREACH(auto screenWrapper, m_screenList) {
+        if (screenWrapper->screen() == screen) return;
+    }
     DEBUG_MSG << "(screen=" << screen << ")";
 
     beginInsertRows(QModelIndex(), count(), count());
-    m_screenList.push_back(screen);
+    auto screenWrapper(new ScreenAdapter(screen));
+    m_screenList.push_back(screenWrapper);
     endInsertRows();
-    Q_EMIT screenAdded(screen);
+    Q_EMIT screenAdded(screenWrapper);
     Q_EMIT countChanged();
 }
 
 void Screens::onScreenRemoved(QScreen *screen)
 {
-    int index = m_screenList.indexOf(screen);
-    if (index < 0)
-        return;
     DEBUG_MSG << "(screen=" << screen << ")";
 
-    beginRemoveRows(QModelIndex(), index, index);
-    m_screenList.removeAt(index);
-    endRemoveRows();
-    Q_EMIT screenRemoved(screen);
-    Q_EMIT countChanged();
+    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

=== modified file 'src/modules/Unity/Screens/screens.h'
--- src/modules/Unity/Screens/screens.h	2017-04-06 08:48:51 +0000
+++ src/modules/Unity/Screens/screens.h	2017-04-06 08:48:52 +0000
@@ -22,6 +22,7 @@
 #include <QAbstractListModel>
 
 class QScreen;
+class ScreenAdapter;
 
 namespace qtmir {
 
@@ -29,6 +30,7 @@
 {
     Q_OBJECT
     Q_PROPERTY(int count READ count NOTIFY countChanged)
+    Q_PROPERTY(QVariant activeScreen READ activeScreen WRITE activateScreen NOTIFY activeScreenChanged)
 
 public:
     enum ItemRoles {
@@ -44,18 +46,23 @@
     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 screenAdded(QScreen *screen);
-    void screenRemoved(QScreen *screen);
+    void activeScreenChanged();
+    void screenAdded(ScreenAdapter *screen);
+    void screenRemoved(ScreenAdapter *screen);
 
 private Q_SLOTS:
     void onScreenAdded(QScreen *screen);
     void onScreenRemoved(QScreen *screen);
 
 private:
-    QList<QScreen *> m_screenList;
+    QList<ScreenAdapter *> m_screenList;
 };
 
 } // namespace qtmir

=== added file 'src/modules/Unity/Screens/types.h'
--- src/modules/Unity/Screens/types.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Screens/types.h	2017-04-06 08:48:52 +0000
@@ -0,0 +1,41 @@
+/*
+ * 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:48:51 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2017-04-06 08:48:52 +0000
@@ -40,6 +40,7 @@
 
     ${Qt5Quick_INCLUDE_DIRS}
     ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
+    ${Qt5Qml_INCLUDE_DIRS}
 
     ${APPLICATION_API_INCLUDE_DIRS}
 
@@ -83,6 +84,7 @@
     qtcompositor.cpp
     displayconfigurationpolicy.cpp
     wrappedwindowmanagementpolicy.cpp
+    mirdisplayconfigurationobserver.cpp
     mirserverhooks.cpp mirserverhooks.h
     setqtcompositor.cpp setqtcompositor.h
     eventdispatch.cpp eventdispatch.h
@@ -210,6 +212,7 @@
     Qt5::DBus
     Qt5::Quick
     Qt5::Sensors
+    Qt5::Qml
 )
 
 install(TARGETS qpa-mirserver LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}/qt5/plugins/platforms")

=== modified file 'src/platforms/mirserver/cursor.h'
--- src/platforms/mirserver/cursor.h	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/cursor.h	2017-04-06 08:48:52 +0000
@@ -26,6 +26,7 @@
 
 namespace qtmir {
 
+
 class Cursor : public MirPlatformCursor
 {
     Q_OBJECT

=== modified file 'src/platforms/mirserver/customscreenconfiguration.h'
--- src/platforms/mirserver/customscreenconfiguration.h	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/customscreenconfiguration.h	2017-04-06 08:48:52 +0000
@@ -26,8 +26,10 @@
 
 struct CustomScreenConfiguration
 {
+    bool valid{false};
     qtmir::OutputId id;
 
+    bool used;
     QPoint topLeft;
     uint32_t currentModeIndex;
     MirPowerMode powerMode;

=== modified file 'src/platforms/mirserver/displayconfigurationpolicy.cpp'
--- src/platforms/mirserver/displayconfigurationpolicy.cpp	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/displayconfigurationpolicy.cpp	2017-04-06 08:48:52 +0000
@@ -80,7 +80,7 @@
     conf.for_each_output(
         [&](const mg::DisplayConfigurationOutput &output )
         {
-            if (output.connected && output.used) {
+            if (output.connected) {
                 screenCount++;
 
                 if (output.type == mg::DisplayConfigurationOutputType::lvds) {
@@ -92,7 +92,7 @@
     conf.for_each_output(
         [&](mg::UserDisplayConfigurationOutput &output)
         {
-            if (!output.connected || !output.used) {
+            if (!output.connected) {
                 return;
             }
 

=== added file 'src/platforms/mirserver/mirdisplayconfigurationobserver.cpp'
--- src/platforms/mirserver/mirdisplayconfigurationobserver.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/mirdisplayconfigurationobserver.cpp	2017-04-06 08:48:52 +0000
@@ -0,0 +1,63 @@
+/*
+ * 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 "mirdisplayconfigurationobserver.h"
+#include "logging.h"
+
+namespace mg = mir::graphics;
+namespace mf = mir::frontend;
+
+MirDisplayConfigurationObserver::MirDisplayConfigurationObserver(QObject *parent)
+    : QObject(parent)
+{
+}
+
+void MirDisplayConfigurationObserver::initial_configuration(const std::shared_ptr<const mg::DisplayConfiguration> &config)
+{
+    qCDebug(QTMIR_SCREENS) << "MirDisplayConfigurationObserver::initial_configuration";
+    Q_EMIT initialConfiguration(config);
+}
+
+void MirDisplayConfigurationObserver::configuration_applied(const std::shared_ptr<const mg::DisplayConfiguration> &config)
+{
+    qCDebug(QTMIR_SCREENS) << "MirDisplayConfigurationObserver::configuration_applied";
+    Q_EMIT configurationApplied(config);
+}
+
+void MirDisplayConfigurationObserver::base_configuration_updated(const std::shared_ptr<const mg::DisplayConfiguration> &base_config)
+{
+    qCDebug(QTMIR_SCREENS) << "MirDisplayConfigurationObserver::base_configuration_updated";
+    Q_EMIT baseConfigurationUpdated(base_config);
+}
+
+void MirDisplayConfigurationObserver::session_configuration_applied(const std::shared_ptr<mf::Session> &,
+                                                                    const std::shared_ptr<mg::DisplayConfiguration> &)
+{
+}
+
+void MirDisplayConfigurationObserver::session_configuration_removed(const std::shared_ptr<mf::Session> &)
+{
+}
+
+void MirDisplayConfigurationObserver::configuration_failed(const std::shared_ptr<const mg::DisplayConfiguration> &,
+                                                           const std::exception &)
+{
+}
+
+void MirDisplayConfigurationObserver::catastrophic_configuration_error(const std::shared_ptr<const mg::DisplayConfiguration> &,
+                                                                       const std::exception &)
+{
+}

=== added file 'src/platforms/mirserver/mirdisplayconfigurationobserver.h'
--- src/platforms/mirserver/mirdisplayconfigurationobserver.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/mirdisplayconfigurationobserver.h	2017-04-06 08:48:52 +0000
@@ -0,0 +1,56 @@
+/*
+ * 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 MIRDISPLAYCONFIGURATIONOBSERVER_H
+#define MIRDISPLAYCONFIGURATIONOBSERVER_H
+
+#include <QObject>
+
+#include <mir/graphics/display_configuration_observer.h>
+
+class MirDisplayConfigurationObserver : public QObject,
+                                        public mir::graphics::DisplayConfigurationObserver
+{
+    Q_OBJECT
+public:
+    explicit MirDisplayConfigurationObserver(QObject *parent = 0);
+
+    void initial_configuration(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& config) override;
+
+    void configuration_applied(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& config) override;
+
+    void base_configuration_updated(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& base_config) override;
+
+    void session_configuration_applied(std::shared_ptr<mir::frontend::Session> const& session,
+        std::shared_ptr<mir::graphics::DisplayConfiguration> const& config) override;
+
+    void session_configuration_removed(std::shared_ptr<mir::frontend::Session> const& session);
+
+    void configuration_failed(
+            std::shared_ptr<mir::graphics::DisplayConfiguration const> const& attempted,
+            std::exception const& error) override;
+
+    void catastrophic_configuration_error(
+            std::shared_ptr<mir::graphics::DisplayConfiguration const> const& failed_fallback,
+            std::exception const& error);
+
+Q_SIGNALS:
+    void initialConfiguration(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& config);
+    void configurationApplied(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& config);
+    void baseConfigurationUpdated(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& config);
+};
+
+#endif // MIRDISPLAYCONFIGURATIONOBSERVER_H

=== modified file 'src/platforms/mirserver/mirserverhooks.cpp'
--- src/platforms/mirserver/mirserverhooks.cpp	2017-03-13 16:49:49 +0000
+++ src/platforms/mirserver/mirserverhooks.cpp	2017-04-06 08:48:52 +0000
@@ -138,7 +138,7 @@
     throw std::logic_error("No input device hub available. Server not running?");
 }
 
-QSharedPointer<ScreensController> qtmir::MirServerHooks::createScreensController(QSharedPointer<ScreensModel> const &screensModel) const
+QSharedPointer<ScreensController> qtmir::MirServerHooks::createScreensController(std::shared_ptr<ScreensModel> const &screensModel) const
 {
     return QSharedPointer<ScreensController>(
         new ScreensController(screensModel, theMirDisplay(), self->m_mirDisplayConfigurationController.lock()));

=== modified file 'src/platforms/mirserver/mirserverhooks.h'
--- src/platforms/mirserver/mirserverhooks.h	2017-01-02 14:41:06 +0000
+++ src/platforms/mirserver/mirserverhooks.h	2017-04-06 08:48:52 +0000
@@ -45,7 +45,7 @@
     std::shared_ptr<mir::graphics::Display> theMirDisplay() const;
     std::shared_ptr<mir::input::InputDeviceHub> theInputDeviceHub() const;
 
-    QSharedPointer<ScreensController> createScreensController(QSharedPointer<ScreensModel> const &screensModel) const;
+    QSharedPointer<ScreensController> createScreensController(std::shared_ptr<ScreensModel> const &screensModel) const;
     void createInputDeviceObserver();
 
 private:

=== modified file 'src/platforms/mirserver/mirserverintegration.cpp'
--- src/platforms/mirserver/mirserverintegration.cpp	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/mirserverintegration.cpp	2017-04-06 08:48:52 +0000
@@ -138,9 +138,9 @@
     // need to create the screens before the integration initialises.
     screens->update();
 
-    QObject::connect(screens.data(), &ScreensModel::screenAdded,
+    QObject::connect(screens.get(), &ScreensModel::screenAdded,
             [this](PlatformScreen *screen) { this->screenAdded(screen); });
-    QObject::connect(screens.data(), &ScreensModel::screenRemoved,
+    QObject::connect(screens.get(), &ScreensModel::screenRemoved,
             [this](PlatformScreen *screen) {
 #if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
         delete screen;

=== modified file 'src/platforms/mirserver/platformscreen.cpp'
--- src/platforms/mirserver/platformscreen.cpp	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/platformscreen.cpp	2017-04-06 08:48:52 +0000
@@ -156,7 +156,9 @@
     , m_unityScreen(nullptr)
 {
     setMirDisplayConfiguration(screen, false);
-    DEBUG_MSG_SCREENS << "(output=" << m_outputId.as_value() << ", geometry=" << geometry() << ")";
+    DEBUG_MSG_SCREENS << "(output=" << m_outputId.as_value()
+                      << ", used=" << (m_used ? "true" : "false")
+                      << ", geometry=" << geometry() << ")";
 
     // Set the default orientation based on the initial screen dimmensions.
     m_nativeOrientation = (m_geometry.width() >= m_geometry.height())

=== modified file 'src/platforms/mirserver/qmirserver.cpp'
--- src/platforms/mirserver/qmirserver.cpp	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/qmirserver.cpp	2017-04-06 08:48:52 +0000
@@ -91,7 +91,7 @@
     return d->serverThread->isRunning();
 }
 
-QSharedPointer<ScreensModel> QMirServer::screensModel() const
+std::shared_ptr<ScreensModel> QMirServer::screensModel() const
 {
     Q_D(const QMirServer);
     return d->screensModel;

=== modified file 'src/platforms/mirserver/qmirserver.h'
--- src/platforms/mirserver/qmirserver.h	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/qmirserver.h	2017-04-06 08:48:52 +0000
@@ -56,7 +56,7 @@
     Q_SLOT void stop();
     bool isRunning() const;
 
-    QSharedPointer<ScreensModel> screensModel() const;
+    std::shared_ptr<ScreensModel> screensModel() const;
     QPlatformOpenGLContext *createPlatformOpenGLContext(QOpenGLContext *context) const;
     void *nativeResourceForIntegration(const QByteArray &resource) const;
     std::shared_ptr<qtmir::PromptSessionManager> thePromptSessionManager() const;

=== modified file 'src/platforms/mirserver/qmirserver_p.h'
--- src/platforms/mirserver/qmirserver_p.h	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/qmirserver_p.h	2017-04-06 08:48:52 +0000
@@ -56,7 +56,7 @@
 {
 public:
     QMirServerPrivate();
-    const QSharedPointer<ScreensModel> screensModel{new ScreensModel()};
+    const std::shared_ptr<ScreensModel> screensModel{new ScreensModel()};
     QSharedPointer<ScreensController> screensController;
     std::shared_ptr<QtEventFeeder> eventFeeder{new QtEventFeeder(screensModel)};
     MirServerThread *serverThread;

=== modified file 'src/platforms/mirserver/qteventfeeder.cpp'
--- src/platforms/mirserver/qteventfeeder.cpp	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/qteventfeeder.cpp	2017-04-06 08:48:52 +0000
@@ -386,7 +386,7 @@
         qRegisterMetaType<Qt::MouseButtons>("Qt::MouseButtons");
     }
 
-    void setScreensModel(const QSharedPointer<ScreensModel> &sc) override
+    void setScreensModel(const std::shared_ptr<ScreensModel> &sc) override
     {
         m_screensModel = sc;
     }
@@ -453,17 +453,17 @@
     }
 
 private:
-    QSharedPointer<ScreensModel> m_screensModel;
+    std::shared_ptr<ScreensModel> m_screensModel;
 };
 
 } // anonymous namespace
 
-QtEventFeeder::QtEventFeeder(const QSharedPointer<ScreensModel> &screensModel)
+QtEventFeeder::QtEventFeeder(const std::shared_ptr<ScreensModel> &screensModel)
     : QtEventFeeder(screensModel, new QtWindowSystem)
 {
 }
 
-QtEventFeeder::QtEventFeeder(const QSharedPointer<ScreensModel> &screensModel,
+QtEventFeeder::QtEventFeeder(const std::shared_ptr<ScreensModel> &screensModel,
                              QtEventFeeder::QtWindowSystemInterface *windowSystem)
     : mQtWindowSystem(windowSystem)
 {

=== modified file 'src/platforms/mirserver/qteventfeeder.h'
--- src/platforms/mirserver/qteventfeeder.h	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/qteventfeeder.h	2017-04-06 08:48:52 +0000
@@ -22,6 +22,8 @@
 #include <QObject>
 #include <qpa/qwindowsysteminterface.h>
 
+#include <memory>
+
 class QTouchDevice;
 class ScreensModel;
 
@@ -37,7 +39,7 @@
     class QtWindowSystemInterface {
         public:
         virtual ~QtWindowSystemInterface() {}
-        virtual void setScreensModel(const QSharedPointer<ScreensModel> &sc) = 0;
+        virtual void setScreensModel(const std::shared_ptr<ScreensModel> &sc) = 0;
         virtual QWindow* getWindowForPoint(const QPoint &point) = 0;
         virtual QWindow* focusedWindow() = 0;
         virtual void registerTouchDevice(QTouchDevice *device) = 0;
@@ -52,8 +54,8 @@
                 Qt::KeyboardModifiers mods = Qt::NoModifier) = 0;
     };
 
-    QtEventFeeder(const QSharedPointer<ScreensModel> &screensModel);
-    QtEventFeeder(const QSharedPointer<ScreensModel> &screensModel,
+    QtEventFeeder(const std::shared_ptr<ScreensModel> &screensModel);
+    QtEventFeeder(const std::shared_ptr<ScreensModel> &screensModel,
                   QtWindowSystemInterface *windowSystem);
     virtual ~QtEventFeeder();
 

=== modified file 'src/platforms/mirserver/screenscontroller.cpp'
--- src/platforms/mirserver/screenscontroller.cpp	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/screenscontroller.cpp	2017-04-06 08:48:52 +0000
@@ -25,7 +25,7 @@
 
 namespace mg = mir::graphics;
 
-ScreensController::ScreensController(const QSharedPointer<ScreensModel> &model,
+ScreensController::ScreensController(const std::shared_ptr<ScreensModel> &model,
         const std::shared_ptr<mir::graphics::Display> &display,
         const std::shared_ptr<mir::shell::DisplayConfigurationController> &controller,
         QObject *parent)
@@ -43,7 +43,9 @@
     Q_FOREACH(auto screen, m_screensModel->screens()) {
         list.append(
             CustomScreenConfiguration {
+                        true,
                         screen->outputId(),
+                        screen->used(),
                         screen->geometry().topLeft(),
                         screen->currentModeIndex(),
                         screen->powerMode(),
@@ -66,8 +68,9 @@
             [&config](mg::UserDisplayConfigurationOutput &outputConfig)
             {
                 if (config.id == outputConfig.id) {
+                    outputConfig.used = config.used;
+                    outputConfig.top_left = Point{ X{config.topLeft.x()}, Y{config.topLeft.y()}};
                     outputConfig.current_mode_index = config.currentModeIndex;
-                    outputConfig.top_left = Point{ X{config.topLeft.x()}, Y{config.topLeft.y()}};
                     outputConfig.power_mode = config.powerMode;
 //                    outputConfig.orientation = config.orientation; // disabling for now
                     outputConfig.scale = config.scale;
@@ -83,3 +86,59 @@
     m_displayConfigurationController->set_base_configuration(std::move(displayConfiguration));
     return true;
 }
+
+CustomScreenConfiguration ScreensController::outputConfiguration(qtmir::OutputId outputId)
+{
+    auto displayConfiguration = m_display->configuration();
+    CustomScreenConfiguration 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;
+                config.powerMode = outputConfig.power_mode;
+                config.orientation = outputConfig.orientation;
+                config.scale = outputConfig.scale;
+                config.formFactor = static_cast<qtmir::FormFactor>(outputConfig.form_factor);
+            }
+    });
+    return config;
+}
+
+bool ScreensController::setOutputConfiguration(const CustomScreenConfiguration &newConfig)
+{
+    using namespace mir::geometry;
+    if (!newConfig.valid)
+        return false;
+
+    auto displayConfiguration = m_display->configuration();
+
+    // FIXME - probably need to enforce some policy here.
+    // Dont disable all sreens
+
+    displayConfiguration->for_each_output(
+        [newConfig](mg::UserDisplayConfigurationOutput &outputConfig)
+        {
+            if (outputConfig.id == newConfig.id) {
+                outputConfig.used = newConfig.used;
+                outputConfig.top_left = Point{ X{newConfig.topLeft.x()}, Y{newConfig.topLeft.y()}};
+                outputConfig.current_mode_index = newConfig.currentModeIndex;
+                outputConfig.power_mode = newConfig.powerMode;
+//              outputConfig.orientation = newConfig.orientation; // disabling for now
+                outputConfig.scale = newConfig.scale;
+                outputConfig.form_factor = static_cast<MirFormFactor>(newConfig.formFactor);
+            }
+        });
+
+    if (!displayConfiguration->valid()) {
+        return false;
+    }
+
+    m_displayConfigurationController->set_base_configuration(std::move(displayConfiguration));
+    return true;
+}

=== modified file 'src/platforms/mirserver/screenscontroller.h'
--- src/platforms/mirserver/screenscontroller.h	2016-11-03 20:17:46 +0000
+++ src/platforms/mirserver/screenscontroller.h	2017-04-06 08:48:52 +0000
@@ -40,7 +40,7 @@
     Q_OBJECT
 
 public:
-    explicit ScreensController(const QSharedPointer<ScreensModel> &model,
+    explicit ScreensController(const std::shared_ptr<ScreensModel> &model,
                                const std::shared_ptr<mir::graphics::Display> &display,
                                const std::shared_ptr<mir::shell::DisplayConfigurationController> &controller,
                                QObject *parent = 0);
@@ -48,8 +48,11 @@
     CustomScreenConfigurationList configuration();
     bool setConfiguration(const CustomScreenConfigurationList &newConfig);
 
+    CustomScreenConfiguration outputConfiguration(qtmir::OutputId outputId);
+    bool setOutputConfiguration(const CustomScreenConfiguration &newConfig);
+
 private:
-    const QSharedPointer<ScreensModel> m_screensModel;
+    const std::shared_ptr<ScreensModel> m_screensModel;
     const std::shared_ptr<mir::graphics::Display> m_display;
     const std::shared_ptr<mir::shell::DisplayConfigurationController> m_displayConfigurationController;
 };

=== modified file 'src/platforms/mirserver/screensmodel.cpp'
--- src/platforms/mirserver/screensmodel.cpp	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/screensmodel.cpp	2017-04-06 08:48:52 +0000
@@ -41,7 +41,7 @@
 #define DEBUG_MSG qCDebug(QTMIR_SCREENS).nospace() << "ScreensModel[" << this <<"]::" << __func__
 
 ScreensModel::ScreensModel(QObject *parent)
-    : QObject(parent)
+    : MirDisplayConfigurationObserver(parent)
     , m_compositing(false)
 {
     DEBUG_MSG << "()";
@@ -65,6 +65,9 @@
             this, &ScreensModel::onCompositorStarting);
     connect(qtCompositor, &QtCompositor::stopping,
             this, &ScreensModel::onCompositorStopping, Qt::BlockingQueuedConnection);
+
+    connect(this, &MirDisplayConfigurationObserver::configurationApplied,
+            this, &ScreensModel::update, Qt::BlockingQueuedConnection);
 }
 
 // terminate before shutting down the Mir server, or else liable to deadlock with the blocking connection above
@@ -110,7 +113,7 @@
 
     displayConfig->for_each_output(
         [this, &oldScreenList, &newScreenList, &windowMoveList](const mg::DisplayConfigurationOutput &output) {
-            if (output.used && output.connected) {
+            if (output.connected) {
                 PlatformScreen *screen = findScreenWithId(oldScreenList, output.id);
                 if (screen) { // we've already set up this display before
 
@@ -141,6 +144,14 @@
                     newScreenList.append(screen);
                     m_screenList.append(screen);
                 }
+
+                if (!output.used) {
+                    Q_FOREACH (ScreenPlatformWindow* window, screen->windows()) {
+                        if (window->window() && window->isExposed()) {
+                            window->window()->hide();
+                        }
+                    }
+                }
             }
         }
     );
@@ -229,9 +240,9 @@
 void ScreensModel::startRenderer()
 {
     Q_FOREACH (const auto screen, m_screenList) {
-        // Only set windows exposed on displays which are turned on, as the GL context Mir provided
+        // Only set windows exposed on displays which are used and turned on, as the GL context Mir provided
         // is invalid in that situation
-        if (screen->powerMode() == mir_power_mode_on) {
+        if (screen->used() && screen->powerMode() == mir_power_mode_on) {
             Q_FOREACH (ScreenPlatformWindow* window, screen->windows()) {
                 window->setExposed(true);
             }
@@ -247,6 +258,7 @@
 void ScreensModel::haltRenderer()
 {
     Q_FOREACH (const auto screen, m_screenList) {
+
         Q_FOREACH (ScreenPlatformWindow* window, screen->windows()) {
             window->setExposed(false);
         }

=== modified file 'src/platforms/mirserver/screensmodel.h'
--- src/platforms/mirserver/screensmodel.h	2017-04-06 08:48:51 +0000
+++ src/platforms/mirserver/screensmodel.h	2017-04-06 08:48:52 +0000
@@ -17,6 +17,8 @@
 #ifndef SCREENCONTROLLER_H
 #define SCREENCONTROLLER_H
 
+#include "mirdisplayconfigurationobserver.h"
+
 #include <QObject>
 #include <QPoint>
 
@@ -54,7 +56,7 @@
  * All other methods must be called on the Qt GUI thread.
  */
 
-class ScreensModel : public QObject
+class ScreensModel : public MirDisplayConfigurationObserver
 {
     Q_OBJECT
 public:

=== modified file 'src/platforms/mirserver/setqtcompositor.cpp'
--- src/platforms/mirserver/setqtcompositor.cpp	2016-11-03 20:17:46 +0000
+++ src/platforms/mirserver/setqtcompositor.cpp	2017-04-06 08:48:52 +0000
@@ -25,8 +25,9 @@
 // mir
 #include <mir/server.h>
 #include <mir/shell/shell.h>
+#include <mir/observer_registrar.h>
 
-qtmir::SetQtCompositor::SetQtCompositor(QSharedPointer<ScreensModel> const& screensModel) :
+qtmir::SetQtCompositor::SetQtCompositor(std::shared_ptr<ScreensModel> const& screensModel) :
     m_screensModel{screensModel}
 {
 }
@@ -44,6 +45,7 @@
         {
             if (auto const compositor = m_compositor.lock())
             {
+                server.the_display_configuration_observer_registrar()->register_interest(m_screensModel);
                 m_screensModel->init(server.the_display(), compositor, server.the_shell());
             }
             else

=== modified file 'src/platforms/mirserver/setqtcompositor.h'
--- src/platforms/mirserver/setqtcompositor.h	2016-11-03 20:17:46 +0000
+++ src/platforms/mirserver/setqtcompositor.h	2017-04-06 08:48:52 +0000
@@ -34,12 +34,12 @@
 class SetQtCompositor
 {
 public:
-    explicit SetQtCompositor(QSharedPointer<ScreensModel> const& screensModel);
+    explicit SetQtCompositor(std::shared_ptr<ScreensModel> const& screensModel);
 
     void operator()(mir::Server& server);
 
 private:
-    QSharedPointer<ScreensModel> const m_screensModel;
+    std::shared_ptr<ScreensModel> const m_screensModel;
     std::weak_ptr<QtCompositor> m_compositor;
 };
 }

=== modified file 'tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h'
--- tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2017-04-06 08:48:51 +0000
+++ tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2017-04-06 08:48:52 +0000
@@ -19,13 +19,13 @@
 #define MOCK_QTWINDOWSYSTEM_H
 
 #include <qteventfeeder.h>
+#include <QGuiApplication>
 #include <QWindow>
 
 class MockQtWindowSystem : public QtEventFeeder::QtWindowSystemInterface {
 public:
     MOCK_CONST_METHOD0(ready, bool());
-    MOCK_METHOD1(setScreensModel, void(const QSharedPointer<ScreensModel> &));
-    MOCK_METHOD1(getWindowForPoint, QWindow*(const QPoint &point));
+    MOCK_METHOD1(setScreensModel, void(const std::shared_ptr<ScreensModel> &));
     MOCK_METHOD0(lastWindow, QWindow*());
     MOCK_METHOD0(focusedWindow, QWindow*());
     // ignores the last parameter count, due to parameter limit in gmock
@@ -51,8 +51,6 @@
     MOCK_METHOD5(handleTouchEvent, void(QWindow *window, ulong timestamp, QTouchDevice *device,
             const QList<struct QWindowSystemInterface::TouchPoint> &points,
             Qt::KeyboardModifiers mods));
-    MOCK_METHOD5(handleMouseEvent, void(ulong timestamp, QPointF relative, QPointF absolute, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers));
-    MOCK_METHOD4(handleWheelEvent, void(ulong timestamp, QPointF absolute, QPoint angleDelta, Qt::KeyboardModifiers modifiers));
 
     ~MockQtWindowSystem()
     {
@@ -64,6 +62,12 @@
         m_devices << device;
     }
 
+    QWindow* getWindowForPoint(const QPoint&)
+    {
+        auto windows = qApp->topLevelWindows();
+        return windows.isEmpty() ? nullptr : windows.first();
+    }
+
     QVector<QTouchDevice*> m_devices;
 };
 

=== modified file 'tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp'
--- tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2017-04-06 08:48:51 +0000
+++ tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2017-04-06 08:48:52 +0000
@@ -79,7 +79,7 @@
 void QtEventFeederTest::SetUp()
 {
     mockWindowSystem = new MockQtWindowSystem;
-    auto screens = QSharedPointer<ScreensModel>();
+    auto screens = std::shared_ptr<ScreensModel>();
 
     ASSERT_TRUE(mockWindowSystem->m_devices.count() == 0);
 
@@ -104,9 +104,6 @@
 
 void QtEventFeederTest::setIrrelevantMockWindowSystemExpectations()
 {
-    EXPECT_CALL(*mockWindowSystem, getWindowForPoint(_))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(window));
     EXPECT_CALL(*mockWindowSystem, focusedWindow())
         .Times(AnyNumber())
         .WillRepeatedly(Return(window));