Merge lp:~dandrader/qtmir/surfaceItemFillMode into lp:qtmir

[Daniel d'Andrada]

Add MirSurfaceItem.fillMode and ensure items and buffer are in sync

Ensure that by the time we enter the phase of updating the scene graph, all qml items are up to date regarding the size of the buffer about to be rendered.

NB: This rendering scheme needs triple buffering to work.

* Are there any related MPs required for this MP to build/function as expected? Please list.

https://code.launchpad.net/~dandrader/unity-api/surfaceItemFillMode/+merge/274446
https://code.launchpad.net/~dandrader/unity8/noStretchOnResize/+merge/274447
* Did you perform an exploratory manual test run of your code change and any related functionality?

Yes

* If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?

Not applicable

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:370
http://jenkins.qa.ubuntu.com/job/qtmir-ci/412/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/145/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/145/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/412/rebuild

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

Glad to have helped. This isn't the first time someone has told me I'm wrong and then they went ahead and copied my code :)

[Gerry Boland (gerboland)]

What's the use-case of this fillMode? The crop ability might have use in the spread? But it's not a proper solution for the stretched frames issue on rotation.

[Daniel d'Andrada (dandrader)]

On 18/09/15 08:02, Gerry Boland wrote:
> What's the use-case of this fillMode? The crop ability might have use in the spread? But it's not a proper solution for the stretched frames issue on rotation.

Resize untiy8-dash in desktop mode on a Nexus device and you'll see.

[Michael Zanetti (mzanetti)]

Code looks ok, but as noticed on the related unity8 branch, I'm not sure if this is the proper place to calculate the innerRect stuff. It has the effect that it makes window content and window decoration/shadow go out of sync.

review: Needs Information

[Daniel d'Andrada (dandrader)]

On 23/09/2015 07:32, Michael Zanetti wrote:
> Review: Needs Information
>
> Code looks ok, but as noticed on the related unity8 branch, I'm not sure if this is the proper place to calculate the innerRect stuff. It has the effect that it makes window content and window decoration/shadow go out of sync.

They're two separate things. fillMode is there to ensure that you never
see a stretched surface even if the MirSurfaceItem size doesn't match
it. See it as yet another MirSurface feature that shells (unity8) can
take and use it on their UI/interaction designs.

What unity8 *does with it* is another thing. That shadow "going out of
sync" is a crude implementation or that unity7 window resize mode where
the window is not resize live, but you drag a translucent orang bounding
rect of it and only on release does the window get committed to that
bounding rect size (or actually a hint for the possibility doing the same).

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:389
http://jenkins.qa.ubuntu.com/job/qtmir-ci/517/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/213/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/213/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/95/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/250/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/250/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/95/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/517/rebuild

review: Needs Fixing (continuous-integration)

[lp:~dandrader/qtmir/surfaceItemFillMode]

387. By Albert Astals Cid on 2015-10-21

Don't search for the element again

Approved by: Gerry Boland, PS Jenkins bot

388. By Daniel d'Andrada on 2015-10-21

Shell draws its own cursor using the new Cursor QML element
Approved by: Lukáš Tinkl, Gerry Boland

389. By Gerry Boland on 2015-10-21

Initial multimonitor support - react correctly to Mir DisplayConfiguration changes.

On Mir DisplayConfiguration changes, QtMir now correctly:
1. blocks Mir until it has stopped all renderers and has their GL contexts released
2. reads the new DisplayConfiguration, matches any existing ScreenWindows to new DisplayBuffers should they change (as Mir may destroy and create it on us)
3. restarts all renderers

This also solves shutdown crash issues due to raciness of mir destroying the GL context backing the shell's QWindow before its renderer had stopped.

Add Unity.Screens qml module to advertise current screen state to QML. Fixes: #1436735, #1488831, #1488863
Approved by: Daniel d'Andrada

390. By Michał Sawicz on 2015-10-21

MirSurfaceItem: Survive holding a surface with an empty texture

Survive having a surface whose texture holds no mir buffer at all.
Instead of crashing in such situation we simply don't render it.
Approved by: Gerry Boland

391. By Michał Sawicz on 2015-10-21

Improve multimonitor support

* Removed magic:
 - Don't automagically select the screen where a window will be show.
   Let shell decide.
 - Don't automagically focus a window. Let shell handle it.

* Let shell know when a screen is about to be removed so that it has
  the opportunity to move or destroy a window in it before it's too late.
  - Added QGuiApplication::onScreenAboutToBeRemoved

* Added logging to key events
Approved by: Michał Sawicz

392. By Alan Griffiths on 2015-10-21

Opaquify MirWindowManager to control visibility of upcoming Window Management work
Approved by: Gerry Boland, PS Jenkins bot

393. By Lukáš Tinkl on 2015-10-21

React to surface modifications (window caption)
Approved by: Daniel d'Andrada

394. By Nick Dedekind on 2015-10-21

Removed the manipulation of the CMAKE_INSTALL_PREFIX from debian/rules
Approved by: Gerry Boland

395. By Nick Dedekind on 2015-10-21

Added touch performance tracing and test.
Approved by: Gerry Boland

396. By Lukáš Tinkl on 2015-10-21

Implement support for mouse wheel events; correctly pass around buttons Fixes: #1497091
Approved by: Gerry Boland

397. By Gerry Boland on 2015-10-21

Workaround for AutoPilot input coordinate positioning being outside screen geometry

398. By CI Train Bot Account on 2015-10-21

Releasing 0.4.6+15.10.20151021-0ubuntu1

399. By Michał Sawicz on 2015-11-02

Clean up packaging and fix autopkgtest on armhf
Approved by: Gerry Boland

400. By Michael Terry on 2015-11-02

Support new isTouchApp property to ApplicationInfoInterface and move lifecycle policy logic out of qtmir.

Now that qtmir won't decide policy for suspending anymore, we don't need all the lifecycleException handling in qtmir either. That can move to unity8.

But since the GSettings key for that was registered under the qtmir namespace (and there's no technical reason to migrate settings), I left the schema and classes dealing with GSettings alone, for future use.

401. By Nick Dedekind on 2015-11-02

Support server->client visibility change to stop rendering (lp:#1475678) Fixes: #1475678
Approved by: Daniel d'Andrada

402. By Alan Griffiths on 2015-11-02

Test harness for MirWindowManager (in preparation for more intelligent window management)
Approved by: Gerry Boland

403. By Nick Dedekind on 2015-11-02

Hand Qt millisecond timestamps rather than nanosecond. Fixes: #1510571, #1511076, #1511711
Approved by: Gerry Boland

404. By CI Train Bot Account on 2015-11-02

Releasing 0.4.6+16.04.20151102-0ubuntu1

405. By Nick Dedekind on 2015-11-10

Reverted occlusion detection (lp#1514556) Fixes: #1514556

406. By CI Train Bot Account on 2015-11-10

Releasing 0.4.6+16.04.20151110-0ubuntu1

407. By Gerry Boland on 2015-11-12

Fix armhf builds on Xenial by using -std=gnu99 instead of c99

Fixes this FTBFS on xenial:

In file included from /usr/include/lttng/tracepoint-rcu.h:26:0,
                 from /usr/include/lttng/tracepoint.h:29,
                 from /home/phablet/dev/projects/qtmir/qtmir/BUILD-xen/src/platforms/mirserver/tracepoints.h:10,
                 from /home/phablet/dev/projects/qtmir/qtmir/BUILD-xen/src/platforms/mirserver/tracepoints.c:7:
/usr/include/urcu/arch/generic.h: In function ‘caa_get_cycles’:
/usr/include/urcu/arch/generic.h:165:6: error: ‘CLOCK_MONOTONIC’ undeclared (first use in this function)
  if (caa_unlikely(clock_gettime(CLOCK_MONOTONIC, &ts)))
      ^
/usr/include/urcu/arch/generic.h:165:6: note: each undeclared identifier is reported only once for each function it appears in

Strictly should compile code with -std=gnu99 instead of -std=c99 to have the identifiers SIGEV_SIGNAL, sigeventStruct, and CLOCK_MONOTONIC available. These identifiers are declared when _POSIX_C_SOURCE is set to a value >= 199309L, which is the case with -std=gnu99. I could also have used -D_POSIX_C_SOURCE=199309L -std=c99 or have the macro defined in source code.

Did not impact wily as libuctu only started looking for CLOCK_MONOTONIC in Xenial release.
Approved by: Daniel d'Andrada

408. By CI Train Bot Account on 2015-11-12

Releasing 0.4.6+16.04.20151112-0ubuntu1

409. By Nick Dedekind on 2015-11-13

Update surface textures when dropping frames. Fixes: #1515356
Approved by: Gerry Boland

410. By CI Train Bot Account on 2015-11-13

Releasing 0.4.6+16.04.20151113-0ubuntu1

411. By Gerry Boland on 2015-11-19

Fix use of uninitialized variable
Approved by: Daniel d'Andrada, PS Jenkins bot

412. By Albert Astals Cid on 2015-11-19

Enable Efficient String Construction by default

See http://blog.qt.io/blog/2011/06/13/string-concatenation-with-qstringbuilder/
Approved by: Gerry Boland, PS Jenkins bot

413. By Michał Sawicz on 2015-11-19

Build with clang (tests/gmock fails and is unfixable on our side i'd say)
Approved by: Gerry Boland

414. By Gerry Boland on 2015-11-19

Use pid_t for PIDs.
Approved by: Daniel d'Andrada, PS Jenkins bot

415. By Loïc Molinari on 2015-11-19

Ensured Mir surface items with size less than or equal to zero are not rendered, as it's usually done for standard QtQuick items.
Approved by: Gerry Boland

416. By Nick Dedekind on 2015-11-19

Fix a crash when dropping a surface frame before Qt draws a surface item. Fixes: #1517139
Approved by: Gerry Boland

417. By CI Train Bot Account on 2015-11-19

Releasing 0.4.6+16.04.20151119-0ubuntu1

418. By Daniel d'Andrada on 2015-11-25

Implemented support for cursors set by client surfaces
Approved by: Lukáš Tinkl

419. By Gerry Boland on 2015-11-25

Manage frameSwapped signal/slot connection with MirSurface more strictly to avoid crash.

Direct Signal/slot connections across thread boundaries incur the same risks as any cross-thread calls. While connect/disconnect are thread safe methods, it is possible for a slot to be called while the slot owner is being deconstructed - and so not yet disconnected.

So watch for the Item's window change signal and disconnect signal immediately. Also move slot ownership to MirSurfaceItem to auto-disconnect more aggressively.
 Fixes: #1517571
Approved by: Daniel d'Andrada

420. By Daniel d'Andrada on 2015-11-25

Forward Mir mouse wheel events to the shell cursor Fixes: #1497091
Approved by: Lukáš Tinkl

421. By Daniel d'Andrada on 2015-11-25

Revert revision 415

The commit "Ensured Mir surface items with size less than or equal to zero are not rendered,
as it's usually done for standard QtQuick items." caused a regression.

MirSurface.size was being kept uninitialized, as QSize(-1,-1).

422. By CI Train Bot Account on 2015-11-25

Releasing 0.4.6+16.04.20151125-0ubuntu1

423. By Timo Jyrinki on 2015-12-01

Rebuild against Qt 5.5.1.

424. By Daniel d'Andrada on 2015-12-04

merge lp:~nick-dedekind/qtmir/polite-close

425. By Daniel d'Andrada on 2015-12-04

Add MirSurfaceItem.fillMode

426. By Daniel d'Andrada on 2015-12-04

Fix bad merge of polite-close

Unmerged revisions

426. By Daniel d'Andrada on 2015-12-04

Fix bad merge of polite-close

425. By Daniel d'Andrada on 2015-12-04

Add MirSurfaceItem.fillMode

424. By Daniel d'Andrada on 2015-12-04

merge lp:~nick-dedekind/qtmir/polite-close

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-10-16 17:43:47 +0000
+++ CMakeLists.txt	2015-10-16 17:43:47 +0000
@@ -60,9 +60,9 @@
 
 find_package(Threads REQUIRED)
 
-pkg_check_modules(MIRSERVER mirserver>=0.16 REQUIRED)
-pkg_check_modules(MIRCLIENT mirclient>=0.16 REQUIRED)
-pkg_check_modules(MIRRENDERERGLDEV mir-renderer-gl-dev>=0.16 REQUIRED)
+pkg_check_modules(MIRSERVER mirserver>=0.17 REQUIRED)
+pkg_check_modules(MIRCLIENT mirclient>=0.17 REQUIRED)
+pkg_check_modules(MIRRENDERERGLDEV mir-renderer-gl-dev>=0.17 REQUIRED)
 
 pkg_check_modules(GLIB glib-2.0 REQUIRED)
 pkg_check_modules(PROCESS_CPP process-cpp REQUIRED)

=== renamed file 'demos/qml-demo-shell/qml-demo-shell.qml' => 'demos/qml-demo-shell/Shell.qml'
=== added file 'demos/qml-demo-shell/qml-demo-shell.qml'
--- demos/qml-demo-shell/qml-demo-shell.qml	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/qml-demo-shell.qml	2015-10-16 17:43:47 +0000
@@ -0,0 +1,19 @@
+import QtQuick 2.3
+import QtQuick.Window 2.2 as QQW
+import Unity.Screens 0.1
+
+Instantiator {
+    id: root
+
+    property var screens: Screens{}
+
+    model: screens
+    QQW.Window {
+        id: window
+        visible: true
+        Shell{ anchors.fill: parent }
+        Component.onCompleted: {
+            print("HEY", screen, screen.geometry, outputType, Screens.HDMIA)
+        }
+    }
+}

=== modified file 'src/common/debughelpers.cpp'
--- src/common/debughelpers.cpp	2015-08-27 16:10:20 +0000
+++ src/common/debughelpers.cpp	2015-10-16 17:43:47 +0000
@@ -223,7 +223,7 @@
 {
     const int pointerCount = mir_touch_event_point_count(event);
 
-    QString string("MirTouchInputEvent(");
+    QString string("MirTouchEvent(");
 
     for (int i = 0; i < pointerCount; ++i) {
 
@@ -265,3 +265,32 @@
         break;
     }
 }
+
+namespace {
+const char *mirKeyboardActionToString(MirKeyboardAction keyboardAction)
+{
+    switch (keyboardAction)
+    {
+    case mir_keyboard_action_up:
+        return "up";
+    case mir_keyboard_action_down:
+        return "down";
+    case mir_keyboard_action_repeat:
+        return "repeat";
+    default:
+        return "???";
+        break;
+    }
+}
+}
+
+QString mirKeyboardEventToString(MirKeyboardEvent const* event)
+{
+    MirKeyboardAction keyboardAction = mir_keyboard_event_action(event);
+
+    xkb_keysym_t keyCode = mir_keyboard_event_key_code(event);
+
+    return QString("MirKeyboardEvent(action=%1,key_code=0x%2)")
+        .arg(mirKeyboardActionToString(keyboardAction))
+        .arg(keyCode, 4, 16, QLatin1Char('0'));
+}

=== modified file 'src/common/debughelpers.h'
--- src/common/debughelpers.h	2015-08-27 16:10:20 +0000
+++ src/common/debughelpers.h	2015-10-16 17:43:47 +0000
@@ -38,6 +38,7 @@
 
 QString mirPointerEventToString(MirPointerEvent const* event);
 QString mirTouchEventToString(MirTouchEvent const* event);
+QString mirKeyboardEventToString(MirKeyboardEvent const* event);
 const char *mirTouchActionToString(MirTouchAction touchAction);
 
 #endif // UBUNTUGESTURES_DEBUG_HELPER_H

=== modified file 'src/modules/Unity/Application/mirbuffersgtexture.cpp'
--- src/modules/Unity/Application/mirbuffersgtexture.cpp	2015-09-17 16:46:37 +0000
+++ src/modules/Unity/Application/mirbuffersgtexture.cpp	2015-10-16 17:43:47 +0000
@@ -21,6 +21,9 @@
 #include <mir/geometry/size.h>
 #include <mir/renderer/gl/texture_source.h>
 
+// mirserver
+#include <logging.h>
+
 namespace mg = mir::geometry;
 namespace mrg = mir::renderer::gl;
 
@@ -59,6 +62,11 @@
     m_width = size.width.as_int();
 }
 
+bool MirBufferSGTexture::hasBuffer() const
+{
+    return !!m_mirBuffer;
+}
+
 int MirBufferSGTexture::textureId() const
 {
     return m_textureId;
@@ -71,19 +79,29 @@
 
 bool MirBufferSGTexture::hasAlphaChannel() const
 {
-    return m_mirBuffer->pixel_format() == mir_pixel_format_abgr_8888
-        || m_mirBuffer->pixel_format() == mir_pixel_format_argb_8888;
+    if (hasBuffer()) {
+        return m_mirBuffer->pixel_format() == mir_pixel_format_abgr_8888
+            || m_mirBuffer->pixel_format() == mir_pixel_format_argb_8888;
+    } else {
+        qCWarning(QTMIR_SURFACES) << "MirBufferSGTexture: hasAlphaChannel() called but there's no mir buffer to query";
+        return false;
+    }
 }
 
 void MirBufferSGTexture::bind()
 {
-    glBindTexture(GL_TEXTURE_2D, m_textureId);
-    updateBindOptions(true/* force */);
-
-    auto const texture_source =
-        dynamic_cast<mrg::TextureSource*>(m_mirBuffer->native_buffer_base());
-    if (!texture_source)
-        throw std::logic_error("Buffer does not support GL rendering");
-
-    texture_source->gl_bind_to_texture();
+    if (hasBuffer()) {
+        glBindTexture(GL_TEXTURE_2D, m_textureId);
+        updateBindOptions(true/* force */);
+
+        auto const texture_source =
+            dynamic_cast<mrg::TextureSource*>(m_mirBuffer->native_buffer_base());
+        if (!texture_source)
+            throw std::logic_error("Buffer does not support GL rendering");
+
+        texture_source->gl_bind_to_texture();
+    } else {
+        qCWarning(QTMIR_SURFACES) << "MirBufferSGTexture: bind() called but there's no mir buffer to bind to";
+        glBindTexture(GL_TEXTURE_2D, 0);
+    }
 }

=== modified file 'src/modules/Unity/Application/mirbuffersgtexture.h'
--- src/modules/Unity/Application/mirbuffersgtexture.h	2015-08-31 09:51:28 +0000
+++ src/modules/Unity/Application/mirbuffersgtexture.h	2015-10-16 17:43:47 +0000
@@ -34,6 +34,7 @@
 
     void setBuffer(std::shared_ptr<mir::graphics::Buffer> buffer);
     void freeBuffer();
+    bool hasBuffer() const;
 
     int textureId() const override;
     QSize textureSize() const override;

=== modified file 'src/modules/Unity/Application/mirsurface.cpp'
--- src/modules/Unity/Application/mirsurface.cpp	2015-09-18 16:33:06 +0000
+++ src/modules/Unity/Application/mirsurface.cpp	2015-10-16 17:43:47 +0000
@@ -21,6 +21,7 @@
 
 // Mir
 #include <mir/geometry/rectangle.h>
+#include <mir/graphics/buffer.h>
 #include <mir/events/event_builders.h>
 #include <mir/shell/shell.h>
 #include <mir_toolkit/event.h>
@@ -309,45 +310,64 @@
     }
 }
 
-void MirSurface::updateTexture()
+bool MirSurface::updateTexture()
 {
     QMutexLocker locker(&m_mutex);
-
-    if (m_textureUpdated) {
-        return;
-    }
-
     Q_ASSERT(!m_texture.isNull());
+
     MirBufferSGTexture *texture = static_cast<MirBufferSGTexture*>(m_texture.data());
 
-    const void* const userId = (void*)123;
-    auto renderables = m_surface->generate_renderables(userId);
+    if (m_textureUpdated) {
+        return texture->hasBuffer();
+    }
 
-    if (m_surface->buffers_ready_for_compositor(userId) > 0 && renderables.size() > 0) {
+    if (m_pendingBuffer) {
         // Avoid holding two buffers for the compositor at the same time. Thus free the current
         // before acquiring the next
         texture->freeBuffer();
-        texture->setBuffer(renderables[0]->buffer());
+        texture->setBuffer(m_pendingBuffer);
+        m_pendingBuffer.reset();
         ++m_currentFrameNumber;
-
-        if (texture->textureSize() != m_size) {
-            m_size = texture->textureSize();
-            QMetaObject::invokeMethod(this, "emitSizeChanged", Qt::QueuedConnection);
+    }
+
+    m_textureUpdated = true;
+
+    return texture->hasBuffer();
+}
+
+void MirSurface::consumeBuffer()
+{
+    QMutexLocker locker(&m_mutex);
+    const void* const userId = (void*)123;
+    auto renderables = m_surface->generate_renderables(userId);
+
+    if (renderables.size() > 0 && m_surface->buffers_ready_for_compositor(userId) > 0) {
+        m_pendingBuffer = renderables[0]->buffer();
+
+        QSize size(m_pendingBuffer->size().width.as_int(),
+                   m_pendingBuffer->size().height.as_int());
+        if (size != m_size) {
+            m_size = size;
+            Q_EMIT sizeChanged(m_size);
         }
     }
 
     if (m_surface->buffers_ready_for_compositor(userId) > 0) {
         // restart the frame dropper to give MirSurfaceItems enough time to render the next frame.
-        // queued since the timer lives in a different thread
-        QMetaObject::invokeMethod(&m_frameDropperTimer, "start", Qt::QueuedConnection);
+        QMetaObject::invokeMethod(&m_frameDropperTimer, "start", Qt::AutoConnection);
     }
-
-    m_textureUpdated = true;
 }
 
 void MirSurface::onCompositorSwappedBuffers()
 {
+    QMutexLocker locker(&m_mutex);
     m_textureUpdated = false;
+
+    if (m_texture && m_pendingBuffer) {
+        // No need to hold onto this buffer as it won't be used on the next frame.
+        MirBufferSGTexture *texture = static_cast<MirBufferSGTexture*>(m_texture.data());
+        texture->freeBuffer();
+    }
 }
 
 bool MirSurface::numBuffersReadyForCompositor()

=== modified file 'src/modules/Unity/Application/mirsurface.h'
--- src/modules/Unity/Application/mirsurface.h	2015-09-25 17:30:26 +0000
+++ src/modules/Unity/Application/mirsurface.h	2015-10-16 17:43:47 +0000
@@ -34,7 +34,10 @@
 #include <mir/scene/surface.h>
 #include <mir_toolkit/common.h>
 
-namespace mir { namespace shell { class Shell; }}
+namespace mir {
+    namespace shell { class Shell; }
+    namespace graphics { class Buffer; }
+}
 
 class SurfaceObserver;
 
@@ -84,10 +87,12 @@
     void incrementViewCount() override;
     void decrementViewCount() override;
 
+    void consumeBuffer() override;
+
     // methods called from the rendering (scene graph) thread:
     QSharedPointer<QSGTexture> texture() override;
     QSGTexture *weakTexture() const override { return m_texture.data(); }
-    void updateTexture() override;
+    bool updateTexture() override;
     unsigned int currentFrameNumber() const override;
     bool numBuffersReadyForCompositor() override;
     // end of methods called from the rendering (scene graph) thread
@@ -112,7 +117,9 @@
     QString appId() const override;
 
 public Q_SLOTS:
+    // methods called from the rendering (scene graph) thread:
     void onCompositorSwappedBuffers() override;
+    // end of methods called from the rendering (scene graph) thread
 
 private Q_SLOTS:
     void dropPendingBuffer();
@@ -148,6 +155,8 @@
     std::shared_ptr<SurfaceObserver> m_surfaceObserver;
 
     QSize m_size;
+
+    std::shared_ptr<mir::graphics::Buffer> m_pendingBuffer;
 };
 
 } // namespace qtmir

=== modified file 'src/modules/Unity/Application/mirsurfaceinterface.h'
--- src/modules/Unity/Application/mirsurfaceinterface.h	2015-09-25 17:30:26 +0000
+++ src/modules/Unity/Application/mirsurfaceinterface.h	2015-10-16 17:43:47 +0000
@@ -51,10 +51,12 @@
     virtual void incrementViewCount() = 0;
     virtual void decrementViewCount() = 0;
 
+    virtual void consumeBuffer() = 0;
+
     // methods called from the rendering (scene graph) thread:
     virtual QSharedPointer<QSGTexture> texture() = 0;
     virtual QSGTexture *weakTexture() const = 0;
-    virtual void updateTexture() = 0;
+    virtual bool updateTexture() = 0;
     virtual unsigned int currentFrameNumber() const = 0;
     virtual bool numBuffersReadyForCompositor() = 0;
     // end of methods called from the rendering (scene graph) thread
@@ -79,7 +81,9 @@
     virtual QString appId() const = 0;
 
 public Q_SLOTS:
+    // methods called from the rendering (scene graph) thread:
     virtual void onCompositorSwappedBuffers() = 0;
+    // end of methods called from the rendering (scene graph) thread
 
 Q_SIGNALS:
     void firstFrameDrawn();

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2015-09-28 14:24:48 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2015-10-16 17:43:47 +0000
@@ -89,6 +89,7 @@
     , m_surfaceHeight(0)
     , m_orientationAngle(nullptr)
     , m_consumesInput(false)
+    , m_fillMode(Stretch)
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::MirSurfaceItem";
 
@@ -216,17 +217,15 @@
 
     ensureTextureProvider();
 
-    m_surface->updateTexture();
+    if (!m_textureProvider->texture() || !m_surface->updateTexture()) {
+        delete oldNode;
+        return 0;
+    }
 
     if (m_surface->numBuffersReadyForCompositor() > 0) {
         QTimer::singleShot(0, this, SLOT(update()));
     }
 
-    if (!m_textureProvider->texture()) {
-        delete oldNode;
-        return 0;
-    }
-
     m_textureProvider->smooth = smooth();
 
     QSGDefaultImageNode *node = static_cast<QSGDefaultImageNode*>(oldNode);
@@ -237,15 +236,31 @@
         node->setMipmapFiltering(QSGTexture::None);
         node->setHorizontalWrapMode(QSGTexture::ClampToEdge);
         node->setVerticalWrapMode(QSGTexture::ClampToEdge);
-        node->setSubSourceRect(QRectF(0, 0, 1, 1));
     } else {
         if (!m_lastFrameNumberRendered  || (*m_lastFrameNumberRendered != m_surface->currentFrameNumber())) {
             node->markDirty(QSGNode::DirtyMaterial);
         }
     }
 
-    node->setTargetRect(QRectF(0, 0, width(), height()));
-    node->setInnerTargetRect(QRectF(0, 0, width(), height()));
+    if (m_fillMode == PadOrCrop) {
+        const QSize &textureSize = m_textureProvider->texture()->textureSize();
+
+        QRectF targetRect;
+        targetRect.setWidth(qMin(width(), static_cast<qreal>(textureSize.width())));
+        targetRect.setHeight(qMin(height(), static_cast<qreal>(textureSize.height())));
+
+        qreal u = targetRect.width() / textureSize.width();
+        qreal v = targetRect.height() / textureSize.height();
+        node->setSubSourceRect(QRectF(0, 0, u, v));
+
+        node->setTargetRect(targetRect);
+        node->setInnerTargetRect(targetRect);
+    } else {
+        // Stretch
+        node->setSubSourceRect(QRectF(0, 0, 1, 1));
+        node->setTargetRect(QRectF(0, 0, width(), height()));
+        node->setInnerTargetRect(QRectF(0, 0, width(), height()));
+    }
 
     node->setFiltering(smooth() ? QSGTexture::Linear : QSGTexture::Nearest);
     node->setAntialiasing(antialiasing());
@@ -609,7 +624,7 @@
 
         // When a new mir frame gets posted we notify the QML engine that this item needs redrawing,
         // schedules call to updatePaintNode() from the rendering thread
-        connect(m_surface, &MirSurfaceInterface::framesPosted, this, &QQuickItem::update);
+        connect(m_surface, &MirSurfaceInterface::framesPosted, this, &MirSurfaceItem::onSurfacePostedFrames);
 
         connect(m_surface, &MirSurfaceInterface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);
         connect(m_surface, &MirSurfaceInterface::liveChanged, this, &MirSurfaceItem::liveChanged);
@@ -690,6 +705,33 @@
     }
 }
 
+MirSurfaceItem::FillMode MirSurfaceItem::fillMode() const
+{
+    return m_fillMode;
+}
+
+void MirSurfaceItem::setFillMode(FillMode value)
+{
+    if (m_fillMode != value) {
+        m_fillMode = value;
+        Q_EMIT fillModeChanged(m_fillMode);
+    }
+}
+
+void MirSurfaceItem::onSurfacePostedFrames()
+{
+    polish();
+    update();
+}
+
+void MirSurfaceItem::updatePolish()
+{
+    if (!m_surface || !m_surface->live()) {
+        return;
+    }
+    m_surface->consumeBuffer();
+}
+
 } // namespace qtmir
 
 #include "mirsurfaceitem.moc"

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
--- src/modules/Unity/Application/mirsurfaceitem.h	2015-09-18 20:11:50 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.h	2015-10-16 17:43:47 +0000
@@ -68,6 +68,9 @@
     int surfaceHeight() const override;
     void setSurfaceHeight(int value) override;
 
+    FillMode fillMode() const override;
+    void setFillMode(FillMode value) override;
+
     ////////
     // QQuickItem
 
@@ -107,6 +110,8 @@
 
     void releaseResources() override;
 
+    void updatePolish() override;
+
 private Q_SLOTS:
     void scheduleMirSurfaceSizeUpdate();
     void updateMirSurfaceSize();
@@ -115,6 +120,8 @@
 
     void onActualSurfaceSizeChanged(const QSize &size);
 
+    void onSurfacePostedFrames();
+
 private:
     void ensureTextureProvider();
 
@@ -163,6 +170,8 @@
     Mir::OrientationAngle *m_orientationAngle;
 
     bool m_consumesInput;
+
+    FillMode m_fillMode;
 };
 
 } // namespace qtmir

=== modified file 'src/modules/Unity/CMakeLists.txt'
--- src/modules/Unity/CMakeLists.txt	2014-09-22 18:06:58 +0000
+++ src/modules/Unity/CMakeLists.txt	2015-10-16 17:43:47 +0000
@@ -1,1 +1,2 @@
 add_subdirectory(Application)
+add_subdirectory(Screens)

=== added directory 'src/modules/Unity/Screens'
=== added file 'src/modules/Unity/Screens/CMakeLists.txt'
--- src/modules/Unity/Screens/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Screens/CMakeLists.txt	2015-10-16 17:43:47 +0000
@@ -0,0 +1,24 @@
+include_directories(
+    ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
+    ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
+    ${MIRSERVER_INCLUDE_DIRS}
+    )
+
+set(SCREENSPLUGIN_SRC
+    plugin.cpp
+    screens.cpp
+    )
+
+add_library(unityscreensplugin SHARED
+    ${SCREENSPLUGIN_SRC}
+)
+
+target_link_libraries(
+    unityscreensplugin
+
+    Qt5::Gui
+    Qt5::Qml
+)
+
+# install
+add_qml_plugin(Unity.Screens 0.1 Unity/Screens TARGETS unityscreensplugin)

=== added file 'src/modules/Unity/Screens/plugin.cpp'
--- src/modules/Unity/Screens/plugin.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Screens/plugin.cpp	2015-10-16 17:43:47 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2015 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"
+
+using namespace qtmir;
+
+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<QScreen*>("QScreen*");
+
+        qmlRegisterType<qtmir::Screens>(uri, 0, 1, "Screens");
+    }
+};
+
+#include "plugin.moc"

=== added file 'src/modules/Unity/Screens/qmldir'
--- src/modules/Unity/Screens/qmldir	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Screens/qmldir	2015-10-16 17:43:47 +0000
@@ -0,0 +1,2 @@
+module Unity.Screens
+plugin unityscreensplugin

=== added file 'src/modules/Unity/Screens/screens.cpp'
--- src/modules/Unity/Screens/screens.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Screens/screens.cpp	2015-10-16 17:43:47 +0000
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2015 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"
+
+// mirserver
+#include "screen.h"
+
+// Qt
+#include <QGuiApplication>
+#include <QScreen>
+
+Q_DECLARE_METATYPE(QScreen*)
+
+namespace qtmir {
+
+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();
+}
+
+QHash<int, QByteArray> Screens::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[ScreenRole] = "screen";
+    roles[OutputTypeRole] = "outputType";
+    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()));
+    case OutputTypeRole:
+        auto screen = static_cast<Screen*>(m_screenList.at(index.row())->handle());
+        if (screen) {
+            return QVariant(static_cast<OutputTypes>(screen->outputType())); //FIXME: cheeky
+        } else
+            return OutputTypes::Unknown;
+    }
+
+    return QVariant();
+}
+
+int Screens::rowCount(const QModelIndex &) const
+{
+    return count();
+}
+
+int Screens::count() const
+{
+    return m_screenList.size();
+}
+
+void Screens::onScreenAdded(QScreen *screen)
+{
+    if (m_screenList.contains(screen))
+        return;
+
+    beginInsertRows(QModelIndex(), count(), count());
+    m_screenList.push_back(screen);
+    endInsertRows();
+    Q_EMIT screenAdded(screen);
+    Q_EMIT countChanged();
+}
+
+void Screens::onScreenRemoved(QScreen *screen)
+{
+    int index = m_screenList.indexOf(screen);
+    if (index < 0)
+        return;
+
+    beginRemoveRows(QModelIndex(), index, index);
+    m_screenList.removeAt(index);
+    endRemoveRows();
+    Q_EMIT screenRemoved(screen);
+    Q_EMIT countChanged();
+}
+
+
+} // namespace qtmir

=== added file 'src/modules/Unity/Screens/screens.h'
--- src/modules/Unity/Screens/screens.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Screens/screens.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2015 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 <QAbstractListModel>
+
+class QScreen;
+
+namespace qtmir {
+
+class Screens : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_ENUMS(OutputTypes)
+
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+
+public:
+    enum ItemRoles {
+        ScreenRole = Qt::UserRole + 1,
+        OutputTypeRole
+    };
+
+    enum OutputTypes {
+        Unknown,
+        VGA,
+        DVII,
+        DVID,
+        DVIA,
+        Composite,
+        SVideo,
+        LVDS,
+        Component,
+        NinePinDIN,
+        DisplayPort,
+        HDMIA,
+        HDMIB,
+        TV,
+        EDP
+    };
+
+    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;
+
+Q_SIGNALS:
+    void countChanged();
+    void screenAdded(QScreen *screen);
+    void screenRemoved(QScreen *screen);
+
+private Q_SLOTS:
+    void onScreenAdded(QScreen *screen);
+    void onScreenRemoved(QScreen *screen);
+
+private:
+    QList<QScreen *> m_screenList;
+};
+
+} // namespace qtmir
+
+#endif // SCREENS_H

=== modified file 'src/platforms/mirserver/CMakeLists.txt'
--- src/platforms/mirserver/CMakeLists.txt	2015-10-16 17:43:47 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2015-10-16 17:43:47 +0000
@@ -31,6 +31,7 @@
     ${QT5PLATFORM_SUPPORT_INCLUDE_DIRS}
     ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
     ${QT5_PLATFORMSUPPORT_INCLUDE_DIRS}
+    ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
 
     ${APPLICATION_API_INCLUDE_DIRS}
 )
@@ -55,16 +56,18 @@
     promptsessionlistener.cpp
     mirserver.cpp
     mirserverstatuslistener.cpp
-    display.cpp
     screen.cpp
-    displaywindow.cpp
+    screencontroller.cpp
+    screenwindow.cpp
     mirserverintegration.cpp
     miropenglcontext.cpp
     nativeinterface.cpp
+    offscreensurface.cpp
     qtcompositor.cpp
     services.cpp
     ubuntutheme.cpp
     clipboard.cpp
+    tileddisplayconfigurationpolicy.cpp
     tracepoints.c
 # We need to run moc on these headers
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h

=== removed file 'src/platforms/mirserver/display.cpp'
--- src/platforms/mirserver/display.cpp	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/display.cpp	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2013-2015 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 "display.h"
-
-#include "screen.h"
-#include "mirserver.h"
-
-#include <mir/graphics/display.h>
-#include <mir/graphics/display_configuration.h>
-
-namespace mg = mir::graphics;
-
-// TODO: Listen for display changes and update the list accordingly
-
-Display::Display(const std::shared_ptr<mir::graphics::DisplayConfiguration> &displayConfig)
-{
-    displayConfig->for_each_output([this](mg::DisplayConfigurationOutput const& output) {
-        if (output.used) {
-            auto screen = new Screen(output);
-            m_screens.push_back(screen);
-        }
-    });
-}
-
-Display::~Display()
-{
-    for (auto screen : m_screens)
-        delete screen;
-    m_screens.clear();
-}

=== removed file 'src/platforms/mirserver/display.h'
--- src/platforms/mirserver/display.h	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/display.h	1970-01-01 00:00:00 +0000
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2013-2015 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 DISPLAY_H
-#define DISPLAY_H
-
-#include <qpa/qplatformscreen.h>
-#include <memory>
-
-namespace mir { namespace graphics { class DisplayConfiguration; }}
-
-class Display
-{
-public:
-    Display(const std::shared_ptr<mir::graphics::DisplayConfiguration> &displayConfig);
-    virtual ~Display();
-
-    QList<QPlatformScreen *> screens() const { return m_screens; }
-
-private:
-    QList<QPlatformScreen *> m_screens;
-};
-
-#endif // DISPLAY_H

=== modified file 'src/platforms/mirserver/logging.h'
--- src/platforms/mirserver/logging.h	2014-10-01 18:42:26 +0000
+++ src/platforms/mirserver/logging.h	2015-10-16 17:43:47 +0000
@@ -25,5 +25,6 @@
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_SENSOR_MESSAGES)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_MIR_INPUT)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_CLIPBOARD)
+Q_DECLARE_LOGGING_CATEGORY(QTMIR_SCREENS)
 
 #endif // UBUNTU_APPLICATION_PLUGIN_LOGGING_H

=== modified file 'src/platforms/mirserver/miropenglcontext.cpp'
--- src/platforms/mirserver/miropenglcontext.cpp	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/miropenglcontext.cpp	2015-10-16 17:43:47 +0000
@@ -16,12 +16,14 @@
 
 #include "miropenglcontext.h"
 
-#include "displaywindow.h"
+#include "offscreensurface.h"
+#include "mirglconfig.h"
 #include "mirserver.h"
-#include "mirglconfig.h"
+#include "screenwindow.h"
 
 #include <QDebug>
 
+#include <QOpenGLFramebufferObject>
 #include <QSurfaceFormat>
 #include <QtPlatformSupport/private/qeglconvenience_p.h>
 
@@ -38,7 +40,7 @@
     : m_logger(new QOpenGLDebugLogger(this))
 #endif
 {
-    std::shared_ptr<mir::graphics::Display> display = server->the_display();
+    auto display = server->the_display();
 
     // create a temporary GL context to fetch the EGL display and config, so Qt can determine the surface format
     std::unique_ptr<mir::graphics::GLContext> mirContext = display->create_gl_context();
@@ -106,17 +108,30 @@
 
 void MirOpenGLContext::swapBuffers(QPlatformSurface *surface)
 {
-    // ultimately calls Mir's DisplayBuffer::post_update()
-    DisplayWindow *displayBuffer = static_cast<DisplayWindow*>(surface);
-    displayBuffer->swapBuffers(); //blocks for vsync
+    if (surface->surface()->surfaceClass() == QSurface::Offscreen) {
+        // NOOP
+    } else {
+        // ultimately calls Mir's DisplayBuffer::post_update()
+        ScreenWindow *screenWindow = static_cast<ScreenWindow*>(surface);
+        screenWindow->swapBuffers(); //blocks for vsync
+    }
 }
 
 bool MirOpenGLContext::makeCurrent(QPlatformSurface *surface)
 {
+    if (surface->surface()->surfaceClass() == QSurface::Offscreen) {
+        auto offscreen = static_cast<OffscreenSurface *>(surface);
+        if (!offscreen->buffer()) {
+            auto buffer = new QOpenGLFramebufferObject(surface->surface()->size());
+            offscreen->setBuffer(buffer);
+        }
+        return offscreen->buffer()->bind();
+    }
+
     // ultimately calls Mir's DisplayBuffer::make_current()
-    DisplayWindow *displayBuffer = static_cast<DisplayWindow*>(surface);
-    if (displayBuffer) {
-        displayBuffer->makeCurrent();
+    ScreenWindow *screenWindow = static_cast<ScreenWindow*>(surface);
+    if (screenWindow) {
+        screenWindow->makeCurrent();
 
 #ifndef QT_NO_DEBUG
         if (!m_logger->isLogging() && m_logger->initialize()) {
@@ -133,7 +148,7 @@
 
 void MirOpenGLContext::doneCurrent()
 {
-    // could call Mir's DisplayBuffer::release_current(), but for what DisplayBuffer?
+    // FIXME: create a temporary GL context just to release? Would be better to get existing one.
 }
 
 QFunctionPointer MirOpenGLContext::getProcAddress(const QByteArray &procName)

=== modified file 'src/platforms/mirserver/miropenglcontext.h'
--- src/platforms/mirserver/miropenglcontext.h	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/miropenglcontext.h	2015-10-16 17:43:47 +0000
@@ -23,6 +23,7 @@
 #include <QOpenGLDebugLogger>
 #endif
 
+
 class MirServer;
 
 class MirOpenGLContext : public QObject, public QPlatformOpenGLContext

=== modified file 'src/platforms/mirserver/mirserver.cpp'
--- src/platforms/mirserver/mirserver.cpp	2015-10-16 17:43:47 +0000
+++ src/platforms/mirserver/mirserver.cpp	2015-10-16 17:43:47 +0000
@@ -23,18 +23,25 @@
 #include "mirglconfig.h"
 #include "mirserverstatuslistener.h"
 #include "promptsessionlistener.h"
+#include "screencontroller.h"
 #include "sessionlistener.h"
 #include "sessionauthorizer.h"
 #include "qtcompositor.h"
 #include "qteventfeeder.h"
+#include "tileddisplayconfigurationpolicy.h"
 #include "logging.h"
 
+// std
+#include <memory>
+
 // egl
+#define MESA_EGL_NO_X11_HEADERS
 #include <EGL/egl.h>
 
 // mir
 #include <mir/graphics/cursor.h>
 
+namespace mg = mir::graphics;
 namespace mo  = mir::options;
 namespace msh = mir::shell;
 namespace ms = mir::scene;
@@ -48,8 +55,10 @@
 
 Q_LOGGING_CATEGORY(QTMIR_MIR_MESSAGES, "qtmir.mir")
 
-MirServer::MirServer(int argc, char const* argv[], QObject* parent)
+MirServer::MirServer(int argc, char const* argv[],
+                     const QSharedPointer<ScreenController> &screenController, QObject* parent)
     : QObject(parent)
+    , m_screenController(screenController)
 {
     set_command_line_handler(&ignore_unparsed_arguments);
     set_command_line(argc, argv);
@@ -74,9 +83,9 @@
             return std::make_shared<QtCompositor>();
         });
 
-    override_the_input_dispatcher([]
+    override_the_input_dispatcher([&screenController]
         {
-            return std::make_shared<QtEventFeeder>();
+            return std::make_shared<QtEventFeeder>(screenController);
         });
 
     override_the_gl_config([]
@@ -95,20 +104,45 @@
             return std::make_shared<MirWindowManager>(the_shell_display_layout());
         });
 
-    set_terminator([&](int)
+    wrap_display_configuration_policy(
+        [](const std::shared_ptr<mg::DisplayConfigurationPolicy> &wrapped)
+            -> std::shared_ptr<mg::DisplayConfigurationPolicy>
+        {
+            return std::make_shared<TiledDisplayConfigurationPolicy>(wrapped);
+        });
+
+    set_terminator([](int)
         {
             qDebug() << "Signal caught by Mir, stopping Mir server..";
             QCoreApplication::quit();
         });
 
+    add_init_callback([this, &screenController] {
+        screenController->init(the_display(), the_compositor());
+    });
+
     apply_settings();
 
     // We will draw our own cursor.
-    add_init_callback([this](){ the_cursor()->hide(); });
+    // FIXME: Call override_the_cusor() instead once this method becomes available in a
+    //        future version of Mir.
+    add_init_callback([this]() {
+        the_cursor()->hide();
+        // Hack to work around https://bugs.launchpad.net/mir/+bug/1502200
+        static_cast<QtCompositor*>(the_compositor().get())->setCursor(the_cursor());
+    });
 
     qCDebug(QTMIR_MIR_MESSAGES) << "MirServer created";
 }
 
+// Override default implementation to ensure we terminate the ScreenController first.
+// Code path followed when Qt tries to shutdown the server.
+void MirServer::stop()
+{
+    m_screenController->terminate();
+    mir::Server::stop();
+}
+
 
 /************************************ Shell side ************************************/
 

=== modified file 'src/platforms/mirserver/mirserver.h'
--- src/platforms/mirserver/mirserver.h	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/mirserver.h	2015-10-16 17:43:47 +0000
@@ -18,6 +18,7 @@
 #define MIRSERVER_H
 
 #include <QObject>
+#include <QSharedPointer>
 #include <mir/server.h>
 
 class QtEventFeeder;
@@ -25,6 +26,7 @@
 class SessionAuthorizer;
 using MirShell = mir::shell::Shell;
 class PromptSessionListener;
+class ScreenController;
 
 // We use virtual inheritance of mir::Server to facilitate derived classes (e.g. testing)
 // calling initialization functions before MirServer is constructed.
@@ -38,12 +40,12 @@
     Q_PROPERTY(PromptSessionListener* promptSessionListener READ promptSessionListener CONSTANT)
 
 public:
-    MirServer(int argc, char const* argv[], QObject* parent = 0);
+    MirServer(int argc, char const* argv[], const QSharedPointer<ScreenController> &, QObject* parent = 0);
     ~MirServer() = default;
 
     /* mir specific */
     using mir::Server::run;
-    using mir::Server::stop;
+    using mir::Server::the_compositor;
     using mir::Server::the_display;
     using mir::Server::the_gl_config;
     using mir::Server::the_main_loop;
@@ -52,6 +54,8 @@
     using mir::Server::the_session_authorizer;
     using mir::Server::the_session_listener;
 
+    void stop();
+
     /* qt specific */
     // getters
     SessionAuthorizer *sessionAuthorizer();
@@ -60,7 +64,9 @@
     MirShell *shell();
 
 private:
+    std::weak_ptr<MirShell> m_shell;
     std::shared_ptr<QtEventFeeder> m_qtEventFeeder;
+    const QSharedPointer<ScreenController> m_screenController;
 };
 
 #endif // MIRSERVER_H

=== modified file 'src/platforms/mirserver/mirserverintegration.cpp'
--- src/platforms/mirserver/mirserverintegration.cpp	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/mirserverintegration.cpp	2015-10-16 17:43:47 +0000
@@ -26,7 +26,8 @@
 #include <qpa/qplatforminputcontextfactory_p.h>
 #include <qpa/qwindowsysteminterface.h>
 
-#include <QCoreApplication>
+#include <QGuiApplication>
+#include <QStringList>
 #include <QOpenGLContext>
 #include <QDebug>
 
@@ -36,13 +37,16 @@
 
 // local
 #include "clipboard.h"
-#include "display.h"
-#include "displaywindow.h"
 #include "miropenglcontext.h"
 #include "nativeinterface.h"
+#include "offscreensurface.h"
 #include "qmirserver.h"
+#include "screen.h"
+#include "screencontroller.h"
+#include "screenwindow.h"
 #include "services.h"
 #include "ubuntutheme.h"
+#include "logging.h"
 
 namespace mg = mir::graphics;
 using qtmir::Clipboard;
@@ -52,7 +56,6 @@
     , m_fontDb(new QGenericUnixFontDatabase())
     , m_services(new Services)
     , m_mirServer(new QMirServer(QCoreApplication::arguments()))
-    , m_display(nullptr)
     , m_nativeInterface(nullptr)
     , m_clipboard(new Clipboard)
 {
@@ -72,12 +75,14 @@
                      QCoreApplication::instance(), &QCoreApplication::quit);
 
     m_inputContext = QPlatformInputContextFactory::create();
+
+    // Default Qt behaviour doesn't match a shell's intentions, so customize:
+    qGuiApp->setQuitOnLastWindowClosed(false);
 }
 
 MirServerIntegration::~MirServerIntegration()
 {
     delete m_nativeInterface;
-    delete m_display;
 }
 
 bool MirServerIntegration::hasCapability(QPlatformIntegration::Capability cap) const
@@ -87,7 +92,7 @@
     case OpenGL: return true;
     case ThreadedOpenGL: return true;
     case BufferQueueingOpenGL: return true;
-    case MultipleWindows: return false; // multi-monitor support
+    case MultipleWindows: return true; // multi-monitor support
     case WindowManagement: return false; // platform has no WM, as this implements the WM!
     case NonFullScreenWindows: return false;
     default: return QPlatformIntegration::hasCapability(cap);
@@ -98,44 +103,30 @@
 {
     QWindowSystemInterface::flushWindowSystemEvents();
 
-    DisplayWindow* displayWindow = nullptr;
-
-    auto const mirServer = m_mirServer->mirServer().lock();
-    mg::DisplayBuffer* first_buffer{nullptr};
-    mg::DisplaySyncGroup* first_group{nullptr};
-    if (mirServer) {
-        mirServer->the_display()->for_each_display_sync_group([&](mg::DisplaySyncGroup &group) {
-            if (!first_group) {
-                first_group = &group;
-            }
-            group.for_each_display_buffer([&](mg::DisplayBuffer &buffer) {
-                if (!first_buffer) {
-                    first_buffer = &buffer;
-                }
-            });
-        });
-    }
-
-    // FIXME(gerry) this will go very bad for >1 display buffer
-    if (first_group && first_buffer)
-        displayWindow = new DisplayWindow(window, first_group, first_buffer);
-
-    if (!displayWindow)
+    auto screens = m_mirServer->screenController().lock();
+    if (!screens) {
+        qCritical("Screens are not initialized, unable to create a new QWindow/ScreenWindow");
         return nullptr;
-
-    //displayWindow->requestActivateWindow();
-    return displayWindow;
+    }
+
+    auto platformWindow = new ScreenWindow(window);
+    if (screens->compositing()) {
+        platformWindow->setExposed(true);
+    }
+
+    qCDebug(QTMIR_SCREENS) << "QWindow" << window << "with geom" << window->geometry()
+                           << "is backed by a" << static_cast<Screen *>(window->screen()->handle())
+                           << "with geometry" << window->screen()->geometry();
+    return platformWindow;
 }
 
-QPlatformBackingStore *MirServerIntegration::createPlatformBackingStore(QWindow *window) const
+QPlatformBackingStore *MirServerIntegration::createPlatformBackingStore(QWindow */*window*/) const
 {
-    qDebug() << "createPlatformBackingStore" << window;
     return nullptr;
 }
 
 QPlatformOpenGLContext *MirServerIntegration::createPlatformOpenGLContext(QOpenGLContext *context) const
 {
-    qDebug() << "createPlatformOpenGLContext" << context;
     return new MirOpenGLContext(m_mirServer->mirServer(), context->format());
 }
 
@@ -151,12 +142,18 @@
         exit(2);
     }
 
-    m_display = new Display(m_mirServer->mirServer().data()->the_display()->configuration());
+    auto screens = m_mirServer->screenController().lock();
+    if (!screens) {
+        qFatal("ScreenController not initialized");
+    }
+    QObject::connect(screens.data(), &ScreenController::screenAdded,
+            [this](Screen *screen) { this->screenAdded(screen); });
+    Q_FOREACH(auto screen, screens->screens()) {
+        screenAdded(screen);
+    }
+
     m_nativeInterface = new NativeInterface(m_mirServer->mirServer());
 
-    for (QPlatformScreen *screen : m_display->screens())
-        screenAdded(screen);
-
     m_clipboard->setupDBusService();
 }
 
@@ -195,3 +192,9 @@
 {
     return m_clipboard.data();
 }
+
+QPlatformOffscreenSurface *MirServerIntegration::createPlatformOffscreenSurface(
+        QOffscreenSurface *surface) const
+{
+    return new OffscreenSurface(surface);
+}

=== modified file 'src/platforms/mirserver/mirserverintegration.h'
--- src/platforms/mirserver/mirserverintegration.h	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/mirserverintegration.h	2015-10-16 17:43:47 +0000
@@ -19,13 +19,9 @@
 
 // qt
 #include <qpa/qplatformintegration.h>
-
-// local
-#include "mirserver.h"
-
-class Display;
+#include <QScopedPointer>
+
 class NativeInterface;
-class MirServer;
 class QMirServer;
 
 namespace qtmir {
@@ -60,6 +56,8 @@
 
     QPlatformNativeInterface *nativeInterface() const override;
 
+    QPlatformOffscreenSurface *createPlatformOffscreenSurface(QOffscreenSurface *surface) const override;
+
 private:
     QScopedPointer<QPlatformAccessibility> m_accessibility;
     QScopedPointer<QPlatformFontDatabase> m_fontDb;
@@ -67,7 +65,6 @@
 
     QScopedPointer<QMirServer> m_mirServer;
 
-    Display *m_display;
     NativeInterface *m_nativeInterface;
     QPlatformInputContext* m_inputContext;
     QScopedPointer<qtmir::Clipboard> m_clipboard;

=== added file 'src/platforms/mirserver/offscreensurface.cpp'
--- src/platforms/mirserver/offscreensurface.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/offscreensurface.cpp	2015-10-16 17:43:47 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2015 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 "offscreensurface.h"
+
+#include "mirserver.h"
+
+// Mir
+#include <mir/graphics/display.h>
+#include <mir/graphics/gl_context.h>
+
+//Qt
+#include <QOffscreenSurface>
+#include <QOpenGLFramebufferObject>
+#include <QSurfaceFormat>
+#include <QtPlatformSupport/private/qeglconvenience_p.h>
+
+namespace mg = mir::graphics;
+
+OffscreenSurface::OffscreenSurface(QOffscreenSurface *offscreenSurface)
+    : QPlatformOffscreenSurface(offscreenSurface)
+    , m_buffer(nullptr)
+    , m_format(offscreenSurface->requestedFormat())
+{
+}
+
+QSurfaceFormat OffscreenSurface::format() const
+{
+    return m_format;
+}
+
+bool OffscreenSurface::isValid() const
+{
+    if (m_buffer) {
+        return m_buffer->isValid();
+    }
+    return false;
+}
+
+QOpenGLFramebufferObject* OffscreenSurface::buffer() const
+{
+    return m_buffer;
+}
+
+void OffscreenSurface::setBuffer(QOpenGLFramebufferObject *buffer)
+{
+    m_buffer = buffer;
+}

=== added file 'src/platforms/mirserver/offscreensurface.h'
--- src/platforms/mirserver/offscreensurface.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/offscreensurface.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2015 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 OFFSCREENSURFACE_H
+#define OFFSCREENSURFACE_H
+
+#include <qpa/qplatformoffscreensurface.h>
+#include <QSurfaceFormat>
+#include <QSharedPointer>
+
+class MirServer;
+class QOpenGLFramebufferObject;
+
+class OffscreenSurface : public QPlatformOffscreenSurface
+{
+public:
+    OffscreenSurface(QOffscreenSurface *offscreenSurface);
+
+    QSurfaceFormat format() const override;
+    bool isValid() const override;
+
+    QOpenGLFramebufferObject* buffer() const;
+    void setBuffer(QOpenGLFramebufferObject *buffer);
+
+private:
+    QOpenGLFramebufferObject *m_buffer;
+    QSurfaceFormat m_format;
+};
+
+#endif // OFFSCREENSURFACE_H

=== modified file 'src/platforms/mirserver/qmirserver.cpp'
--- src/platforms/mirserver/qmirserver.cpp	2015-05-19 15:36:17 +0000
+++ src/platforms/mirserver/qmirserver.cpp	2015-10-16 17:43:47 +0000
@@ -23,7 +23,8 @@
 #include "mirserver.h"
 #include "qmirserver.h"
 #include "qmirserver_p.h"
-
+#include "screencontroller.h"
+#include "screen.h"
 
 QMirServer::QMirServer(const QStringList &arguments, QObject *parent)
     : QObject(parent)
@@ -40,7 +41,9 @@
     }
     argv[argc] = '\0';
 
-    d->server = QSharedPointer<MirServer>(new MirServer(argc, const_cast<const char**>(argv)));
+    d->screenController = QSharedPointer<ScreenController>(new ScreenController());
+
+    d->server = QSharedPointer<MirServer>(new MirServer(argc, const_cast<const char**>(argv), d->screenController));
 
     d->serverThread = new MirServerThread(d->server);
 
@@ -63,6 +66,7 @@
         qCritical() << "ERROR: QMirServer - Mir failed to start";
         return false;
     }
+    d->screenController->update();
 
     Q_EMIT started();
     return true;
@@ -93,3 +97,9 @@
     Q_D(const QMirServer);
     return d->server.toWeakRef();
 }
+
+QWeakPointer<ScreenController> QMirServer::screenController() const
+{
+    Q_D(const QMirServer);
+    return d->screenController;
+}

=== modified file 'src/platforms/mirserver/qmirserver.h'
--- src/platforms/mirserver/qmirserver.h	2015-05-18 20:39:09 +0000
+++ src/platforms/mirserver/qmirserver.h	2015-10-16 17:43:47 +0000
@@ -23,6 +23,7 @@
 
 class QMirServerPrivate;
 class MirServer;
+class ScreenController;
 
 class QMirServer: public QObject
 {
@@ -38,6 +39,8 @@
 
     QWeakPointer<MirServer> mirServer() const;
 
+    QWeakPointer<ScreenController> screenController() const;
+
 Q_SIGNALS:
     void started();
     void stopped();

=== modified file 'src/platforms/mirserver/qmirserver_p.h'
--- src/platforms/mirserver/qmirserver_p.h	2015-05-18 18:30:33 +0000
+++ src/platforms/mirserver/qmirserver_p.h	2015-10-16 17:43:47 +0000
@@ -27,6 +27,7 @@
 
 // local
 #include "mirserver.h"
+#include "screencontroller.h"
 
 class QMirServer;
 class MirServerThread;
@@ -34,6 +35,7 @@
 struct QMirServerPrivate
 {
     QSharedPointer<MirServer> server;
+    QSharedPointer<ScreenController> screenController;
     MirServerThread *serverThread;
 };
 

=== modified file 'src/platforms/mirserver/qtcompositor.cpp'
--- src/platforms/mirserver/qtcompositor.cpp	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/qtcompositor.cpp	2015-10-16 17:43:47 +0000
@@ -15,44 +15,32 @@
  */
 
 #include "qtcompositor.h"
-#include "displaywindow.h"
-
-#include <QGuiApplication>
-#include <QWindow>
-
-#include <QDebug>
-
-QtCompositor::QtCompositor()
-{
-
-}
-
+#include "logging.h"
+
+#include <mir/graphics/cursor.h>
+
+// Lives in a Mir thread
 void QtCompositor::start()
 {
-    // (Re)Start Qt's render thread by setting all its windows to exposed
-    setAllWindowsExposed(true);
+    qCDebug(QTMIR_SCREENS) << "QtCompositor::start";
+
+    // FIXME: Hack to work around https://bugs.launchpad.net/mir/+bug/1502200
+    //        See the FIXME in mirserver.cpp
+    if (m_cursor) {
+        m_cursor->hide();
+    }
+
+    Q_EMIT starting(); // blocks
 }
 
 void QtCompositor::stop()
 {
-    // Stop Qt's render threads by setting all its windows it obscured
-    setAllWindowsExposed(false);
+    qCDebug(QTMIR_SCREENS) << "QtCompositor::stop";
+
+    Q_EMIT stopping(); // blocks
 }
 
-void QtCompositor::setAllWindowsExposed(const bool exposed)
+void QtCompositor::setCursor(std::shared_ptr<mir::graphics::Cursor> cursor)
 {
-    qDebug() << "QtCompositor::setAllWindowsExposed" << exposed;
-    QList<QWindow *> windowList = QGuiApplication::allWindows();
-
-    // manipulate Qt object's indirectly via posted events as we're not in Qt's GUI thread
-    auto iterator = windowList.constBegin();
-    while (iterator != windowList.constEnd()) {
-        QWindow *window = *iterator;
-        DisplayWindow *displayWindow = static_cast<DisplayWindow*>(window->handle());
-        if (displayWindow) {
-            QCoreApplication::postEvent(displayWindow,
-                                        new QEvent( (exposed) ? QEvent::Show : QEvent::Hide));
-        }
-        iterator++;
-    }
+    m_cursor = cursor;
 }

=== modified file 'src/platforms/mirserver/qtcompositor.h'
--- src/platforms/mirserver/qtcompositor.h	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/qtcompositor.h	2015-10-16 17:43:47 +0000
@@ -17,18 +17,38 @@
 #ifndef QTCOMPOSITOR_H
 #define QTCOMPOSITOR_H
 
-#include "mir/compositor/compositor.h"
-
-class QtCompositor : public mir::compositor::Compositor
+#include <mir/compositor/compositor.h>
+
+// std lib
+#include <memory>
+
+// Qt
+#include <QObject>
+
+namespace mir {
+    namespace graphics {
+        class Cursor;
+    }
+}
+
+class QtCompositor : public QObject, public mir::compositor::Compositor
 {
+    Q_OBJECT
 public:
-    QtCompositor();
+    QtCompositor() = default;
+    virtual ~QtCompositor() noexcept = default;
 
     void start();
     void stop();
 
+    void setCursor(std::shared_ptr<mir::graphics::Cursor>);
+
+Q_SIGNALS:
+    void starting();
+    void stopping();
+
 private:
-    void setAllWindowsExposed(const bool exposed);
+    std::shared_ptr<mir::graphics::Cursor> m_cursor;
 };
 
 #endif // QTCOMPOSITOR_H

=== modified file 'src/platforms/mirserver/qteventfeeder.cpp'
--- src/platforms/mirserver/qteventfeeder.cpp	2015-10-16 17:43:47 +0000
+++ src/platforms/mirserver/qteventfeeder.cpp	2015-10-16 17:43:47 +0000
@@ -17,7 +17,8 @@
 #include "qteventfeeder.h"
 #include "cursor.h"
 #include "logging.h"
-#include "screen.h"
+#include "screen.h" // NEEDED?
+#include "screencontroller.h"
 
 #include <qpa/qplatforminputcontext.h>
 #include <qpa/qplatformintegration.h>
@@ -367,7 +368,8 @@
 
 namespace {
 
-class QtWindowSystem : public QtEventFeeder::QtWindowSystemInterface {
+class QtWindowSystem : public QtEventFeeder::QtWindowSystemInterface
+{
 public:
     QtWindowSystem()
     {
@@ -376,18 +378,19 @@
         qRegisterMetaType<Qt::MouseButtons>("Qt::MouseButtons");
     }
 
-    bool hasTargetWindow() override
-    {
-        if (mTopLevelWindow.isNull() && !QGuiApplication::topLevelWindows().isEmpty()) {
-            mTopLevelWindow = QGuiApplication::topLevelWindows().first();
-        }
-        return !mTopLevelWindow.isNull();
-    }
-
-    QRect targetWindowGeometry() override
-    {
-        Q_ASSERT(!mTopLevelWindow.isNull());
-        return mTopLevelWindow->geometry();
+    void setScreenController(const QSharedPointer<ScreenController> &sc) override
+    {
+        m_screenController = sc;
+    }
+
+    virtual QWindow* focusedWindow() override
+    {
+        return QGuiApplication::focusWindow();
+    }
+
+    QWindow* getWindowForTouchPoint(const QPoint &point) override //FIXME: not efficient, not updating focused window
+    {
+        return m_screenController->getWindowForPoint(point);
     }
 
     void registerTouchDevice(QTouchDevice *device) override
@@ -395,47 +398,55 @@
         QWindowSystemInterface::registerTouchDevice(device);
     }
 
-    void handleExtendedKeyEvent(ulong timestamp, QEvent::Type type, int key,
+    void handleExtendedKeyEvent(QWindow *window, ulong timestamp, QEvent::Type type, int key,
                 Qt::KeyboardModifiers modifiers,
                 quint32 nativeScanCode, quint32 nativeVirtualKey,
                 quint32 nativeModifiers,
                 const QString& text, bool autorep, ushort count) override
     {
-        Q_ASSERT(!mTopLevelWindow.isNull());
-        QWindowSystemInterface::handleExtendedKeyEvent(mTopLevelWindow.data(), timestamp, type, key, modifiers,
+        QWindowSystemInterface::handleExtendedKeyEvent(window, timestamp, type, key, modifiers,
                 nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
     }
 
-    void handleTouchEvent(ulong timestamp, QTouchDevice *device,
+    void handleTouchEvent(QWindow *window, ulong timestamp, QTouchDevice *device,
             const QList<struct QWindowSystemInterface::TouchPoint> &points, Qt::KeyboardModifiers mods) override
     {
-        Q_ASSERT(!mTopLevelWindow.isNull());
-        QWindowSystemInterface::handleTouchEvent(mTopLevelWindow.data(), timestamp, device, points, mods);
+        QWindowSystemInterface::handleTouchEvent(window, timestamp, device, points, mods);
     }
 
     void handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) override
     {
-        Q_ASSERT(!mTopLevelWindow.isNull());
-        auto platformCursor = static_cast<qtmir::Cursor*>(mTopLevelWindow->screen()->handle()->cursor());
-        platformCursor->handleMouseEvent(timestamp, movement, buttons, modifiers);
+        // Send to the first screen that handles the mouse event
+        // TODO: Have a mechanism to tell which screen currently has the logical mouse pointer
+        //       (because they all might have their own separate graphical mouse pointer item)
+        //       This will probably come once we implement the feature of having the mouse pointer
+        //       crossing adjacent screens.
+
+        QList<Screen*> screens = m_screenController->screens();
+        bool eventHandled = false;
+        int i = 0;
+        while (i < screens.count() && !eventHandled) {
+            auto platformCursor = static_cast<qtmir::Cursor*>(screens[i]->cursor());
+            eventHandled = platformCursor->handleMouseEvent(timestamp, movement, buttons, modifiers);
+            ++i;
+        }
     }
 
-
 private:
-    QPointer<QWindow> mTopLevelWindow;
+    QSharedPointer<ScreenController> m_screenController;
 };
 
 } // anonymous namespace
 
-
-QtEventFeeder::QtEventFeeder(QtEventFeeder::QtWindowSystemInterface *windowSystem)
-{
-    if (windowSystem) {
-        mQtWindowSystem = windowSystem;
-    } else {
-        mQtWindowSystem = new QtWindowSystem;
-    }
-
+QtEventFeeder::QtEventFeeder(const QSharedPointer<ScreenController> &screenController)
+    : QtEventFeeder(screenController, new QtWindowSystem)
+{
+}
+
+QtEventFeeder::QtEventFeeder(const QSharedPointer<ScreenController> &screenController,
+                             QtEventFeeder::QtWindowSystemInterface *windowSystem)
+    : mQtWindowSystem(windowSystem)
+{
     // Initialize touch device. Hardcoded just like in qtubuntu
     // TODO: Create them from info gathered from Mir and store things like device id and source
     //       in a QTouchDevice-derived class created by us. So that we can properly assemble back
@@ -445,6 +456,7 @@
     mTouchDevice->setCapabilities(
             QTouchDevice::Position | QTouchDevice::Area | QTouchDevice::Pressure |
             QTouchDevice::NormalizedPosition);
+    mQtWindowSystem->setScreenController(screenController);
     mQtWindowSystem->registerTouchDevice(mTouchDevice);
 }
 
@@ -458,6 +470,7 @@
     auto type = mir_event_get_type(&event);
     if (type != mir_event_type_input)
         return false;
+
     auto iev = mir_event_get_input_event(&event);
 
     switch (mir_input_event_get_type(iev)) {
@@ -517,9 +530,6 @@
 
 void QtEventFeeder::dispatchPointer(MirInputEvent const* ev)
 {
-    if (!mQtWindowSystem->hasTargetWindow())
-        return;
-
     auto timestamp = mir_input_event_get_event_time(ev) / 1000000;
 
     auto pev = mir_input_event_get_pointer_event(ev);
@@ -527,6 +537,7 @@
 
     auto modifiers = getQtModifiersFromMir(mir_pointer_event_modifiers(pev));
     auto buttons = getQtMouseButtonsfromMirPointerEvent(pev);
+
     auto movement = QPointF(mir_pointer_event_axis_value(pev, mir_pointer_axis_relative_x),
                             mir_pointer_event_axis_value(pev, mir_pointer_axis_relative_y));
 
@@ -535,9 +546,6 @@
 
 void QtEventFeeder::dispatchKey(MirInputEvent const* event)
 {
-    if (!mQtWindowSystem->hasTargetWindow())
-        return;
-
     ulong timestamp = mir_input_event_get_event_time(event) / 1000000;
 
     auto kev = mir_input_event_get_keyboard_event(event);
@@ -579,12 +587,17 @@
                             text, is_auto_rep);
         qKeyEvent.setTimestamp(timestamp);
         if (context->filterEvent(&qKeyEvent)) {
-            // key event filtered out by input context
+            qCDebug(QTMIR_MIR_INPUT) << "Received" << qPrintable(mirKeyboardEventToString(kev))
+                << "but not dispatching as it was filtered out by input context";
             return;
         }
     }
 
-    mQtWindowSystem->handleExtendedKeyEvent(timestamp, keyType, keyCode, modifiers,
+    qCDebug(QTMIR_MIR_INPUT).nospace() << "Received" << qPrintable(mirKeyboardEventToString(kev))
+        << ". Dispatching to " << mQtWindowSystem->focusedWindow();
+
+    mQtWindowSystem->handleExtendedKeyEvent(mQtWindowSystem->focusedWindow(),
+        timestamp, keyType, keyCode, modifiers,
         mir_keyboard_event_scan_code(kev),
         mir_keyboard_event_key_code(kev),
         mir_keyboard_event_modifiers(kev), text, is_auto_rep);
@@ -592,59 +605,69 @@
 
 void QtEventFeeder::dispatchTouch(MirInputEvent const* event)
 {
-    if (!mQtWindowSystem->hasTargetWindow())
-        return;
-
     auto tev = mir_input_event_get_touch_event(event);
     qCDebug(QTMIR_MIR_INPUT) << "Received" << qPrintable(mirTouchEventToString(tev));
 
     // FIXME(loicm) Max pressure is device specific. That one is for the Samsung Galaxy Nexus. That
     //     needs to be fixed as soon as the compat input lib adds query support.
     const float kMaxPressure = 1.28;
-    const QRect kWindowGeometry = mQtWindowSystem->targetWindowGeometry();
+    const int kPointerCount = mir_touch_event_point_count(tev);
     QList<QWindowSystemInterface::TouchPoint> touchPoints;
-
-    // TODO: Is it worth setting the Qt::TouchPointStationary ones? Currently they are left
-    //       as Qt::TouchPointMoved
-    const int kPointerCount = mir_touch_event_point_count(tev);
-    for (int i = 0; i < kPointerCount; ++i) {
-        QWindowSystemInterface::TouchPoint touchPoint;
-
-        const float kX = mir_touch_event_axis_value(tev, i, mir_touch_axis_x);
-        const float kY = mir_touch_event_axis_value(tev, i, mir_touch_axis_y);
-        const float kW = mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_major);
-        const float kH = mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_minor);
-        const float kP = mir_touch_event_axis_value(tev, i, mir_touch_axis_pressure);
-        touchPoint.id = mir_touch_event_id(tev, i);
-
-        touchPoint.normalPosition = QPointF(kX / kWindowGeometry.width(), kY / kWindowGeometry.height());
-        touchPoint.area = QRectF(kX - (kW / 2.0), kY - (kH / 2.0), kW, kH);
-        touchPoint.pressure = kP / kMaxPressure;
-        switch (mir_touch_event_action(tev, i))
-        {
-        case mir_touch_action_up:
-            touchPoint.state = Qt::TouchPointReleased;
-            break;
-        case mir_touch_action_down:
-            touchPoint.state = Qt::TouchPointPressed;
-            break;
-        case mir_touch_action_change:
-            touchPoint.state = Qt::TouchPointMoved;
-            break;
-        default:
-            break;
-        }
-
-        touchPoints.append(touchPoint);
+    QWindow *window = nullptr;
+
+    if (kPointerCount > 0) {
+        window = mQtWindowSystem->getWindowForTouchPoint(
+                    QPoint(mir_touch_event_axis_value(tev, 0, mir_touch_axis_x),
+                           mir_touch_event_axis_value(tev, 0, mir_touch_axis_y)));
+
+        if (!window) {
+            qCDebug(QTMIR_MIR_INPUT) << "REJECTING INPUT EVENT, no matching window";
+            return;
+        }
+
+        const QRect kWindowGeometry = window->geometry();
+
+        // TODO: Is it worth setting the Qt::TouchPointStationary ones? Currently they are left
+        //       as Qt::TouchPointMoved
+        for (int i = 0; i < kPointerCount; ++i) {
+            QWindowSystemInterface::TouchPoint touchPoint;
+
+            const float kX = mir_touch_event_axis_value(tev, i, mir_touch_axis_x);
+            const float kY = mir_touch_event_axis_value(tev, i, mir_touch_axis_y);
+            const float kW = mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_major);
+            const float kH = mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_minor);
+            const float kP = mir_touch_event_axis_value(tev, i, mir_touch_axis_pressure);
+            touchPoint.id = mir_touch_event_id(tev, i);
+
+            touchPoint.normalPosition = QPointF(kX / kWindowGeometry.width(), kY / kWindowGeometry.height());
+            touchPoint.area = QRectF(kX - (kW / 2.0), kY - (kH / 2.0), kW, kH);
+            touchPoint.pressure = kP / kMaxPressure;
+            switch (mir_touch_event_action(tev, i))
+            {
+            case mir_touch_action_up:
+                touchPoint.state = Qt::TouchPointReleased;
+                break;
+            case mir_touch_action_down:
+                touchPoint.state = Qt::TouchPointPressed;
+                break;
+            case mir_touch_action_change:
+                touchPoint.state = Qt::TouchPointMoved;
+                break;
+            default:
+                break;
+            }
+
+            touchPoints.append(touchPoint);
+        }
     }
 
     // Qt needs a happy, sane stream of touch events. So let's make sure we're not forwarding
     // any insanity.
-    validateTouches(mir_input_event_get_event_time(event) / 1000000, touchPoints);
+    validateTouches(window, mir_input_event_get_event_time(event) / 1000000, touchPoints);
 
     // Touch event propagation.
     qCDebug(QTMIR_MIR_INPUT) << "Sending to Qt" << qPrintable(touchesToString(touchPoints));
-    mQtWindowSystem->handleTouchEvent(
+    mQtWindowSystem->handleTouchEvent(window,
         //scales down the nsec_t (int64) to fit a ulong, precision lost but time difference suitable
         mir_input_event_get_event_time(event) / 1000000,
         mTouchDevice,
@@ -661,7 +684,7 @@
     // not used
 }
 
-void QtEventFeeder::validateTouches(ulong timestamp,
+void QtEventFeeder::validateTouches(QWindow *window, ulong timestamp,
         QList<QWindowSystemInterface::TouchPoint> &touchPoints)
 {
     QSet<int> updatedTouches;
@@ -685,7 +708,7 @@
         if (!updatedTouches.contains(it.key())) {
             qCWarning(QTMIR_MIR_INPUT)
                 << "There's a touch (id =" << it.key() << ") missing. Releasing it.";
-            sendActiveTouchRelease(timestamp, it.key());
+            sendActiveTouchRelease(window, timestamp, it.key());
             it = mActiveTouches.erase(it);
         } else {
             ++it;
@@ -703,7 +726,7 @@
     }
 }
 
-void QtEventFeeder::sendActiveTouchRelease(ulong timestamp, int id)
+void QtEventFeeder::sendActiveTouchRelease(QWindow *window, ulong timestamp, int id)
 {
     QList<QWindowSystemInterface::TouchPoint> touchPoints = mActiveTouches.values();
 
@@ -717,7 +740,7 @@
     }
 
     qCDebug(QTMIR_MIR_INPUT) << "Sending to Qt" << qPrintable(touchesToString(touchPoints));
-    mQtWindowSystem->handleTouchEvent(timestamp, mTouchDevice, touchPoints);
+    mQtWindowSystem->handleTouchEvent(window, timestamp, mTouchDevice, touchPoints);
 }
 
 bool QtEventFeeder::validateTouch(QWindowSystemInterface::TouchPoint &touchPoint)

=== modified file 'src/platforms/mirserver/qteventfeeder.h'
--- src/platforms/mirserver/qteventfeeder.h	2015-10-16 17:43:47 +0000
+++ src/platforms/mirserver/qteventfeeder.h	2015-10-16 17:43:47 +0000
@@ -23,6 +23,7 @@
 #include <qpa/qwindowsysteminterface.h>
 
 class QTouchDevice;
+class ScreenController;
 
 /*
   Fills Qt's event loop with input events from Mir
@@ -33,27 +34,29 @@
     // Interface between QtEventFeeder and the actual QWindowSystemInterface functions
     // and other related Qt methods and objects to enable replacing them with mocks in
     // pure unit tests.
-    // TODO - Make it work with multimonitor scenarios
     class QtWindowSystemInterface {
         public:
         virtual ~QtWindowSystemInterface() {}
-        virtual bool hasTargetWindow() = 0;
-        virtual QRect targetWindowGeometry() = 0;
+        virtual void setScreenController(const QSharedPointer<ScreenController> &sc) = 0;
+        virtual QWindow* getWindowForTouchPoint(const QPoint &point) = 0;
+        virtual QWindow* focusedWindow() = 0;
         virtual void registerTouchDevice(QTouchDevice *device) = 0;
-        virtual void handleExtendedKeyEvent(ulong timestamp, QEvent::Type type, int key,
+        virtual void handleExtendedKeyEvent(QWindow *window, ulong timestamp, QEvent::Type type, int key,
                 Qt::KeyboardModifiers modifiers,
                 quint32 nativeScanCode, quint32 nativeVirtualKey,
                 quint32 nativeModifiers,
                 const QString& text = QString(), bool autorep = false,
                 ushort count = 1) = 0;
-        virtual void handleTouchEvent(ulong timestamp, QTouchDevice *device,
+        virtual void handleTouchEvent(QWindow *window, ulong timestamp, QTouchDevice *device,
                 const QList<struct QWindowSystemInterface::TouchPoint> &points,
                 Qt::KeyboardModifiers mods = Qt::NoModifier) = 0;
         virtual void handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,
                                       Qt::KeyboardModifiers modifiers) = 0;
     };
 
-    QtEventFeeder(QtWindowSystemInterface *windowSystem = nullptr);
+    QtEventFeeder(const QSharedPointer<ScreenController> &screenController);
+    QtEventFeeder(const QSharedPointer<ScreenController> &screenController,
+                  QtWindowSystemInterface *windowSystem);
     virtual ~QtEventFeeder();
 
     static const int MirEventActionMask;
@@ -68,9 +71,9 @@
     void dispatchKey(MirInputEvent const* event);
     void dispatchTouch(MirInputEvent const* event);
     void dispatchPointer(MirInputEvent const* event);
-    void validateTouches(ulong timestamp, QList<QWindowSystemInterface::TouchPoint> &touchPoints);
+    void validateTouches(QWindow *window, ulong timestamp, QList<QWindowSystemInterface::TouchPoint> &touchPoints);
     bool validateTouch(QWindowSystemInterface::TouchPoint &touchPoint);
-    void sendActiveTouchRelease(ulong timestamp, int id);
+    void sendActiveTouchRelease(QWindow *window, ulong timestamp, int id);
 
     QString touchesToString(const QList<struct QWindowSystemInterface::TouchPoint> &points);
 

=== modified file 'src/platforms/mirserver/screen.cpp'
--- src/platforms/mirserver/screen.cpp	2015-10-16 17:43:47 +0000
+++ src/platforms/mirserver/screen.cpp	2015-10-16 17:43:47 +0000
@@ -20,12 +20,14 @@
 
 // Mir
 #include "mir/geometry/size.h"
+#include "mir/graphics/buffer.h"
+#include "mir/graphics/display_buffer.h"
+#include "mir/graphics/display.h"
+#include <mir/renderer/gl/render_target.h>
 
 // Qt
 #include <QCoreApplication>
 #include <qpa/qwindowsysteminterface.h>
-#include <QtSensors/QOrientationSensor>
-#include <QtSensors/QOrientationReading>
 #include <QThread>
 
 // Qt sensors
@@ -42,6 +44,17 @@
     char *c = (char*)&i;
     return *c == 1;
 }
+static mir::renderer::gl::RenderTarget *as_render_target(
+    mir::graphics::DisplayBuffer *displayBuffer)
+{
+    auto const render_target =
+        dynamic_cast<mir::renderer::gl::RenderTarget*>(
+            displayBuffer->native_display_buffer());
+    if (!render_target)
+        throw std::logic_error("DisplayBuffer does not support GL rendering");
+
+    return render_target;
+}
 
 enum QImage::Format qImageFormatFromMirPixelFormat(MirPixelFormat mirPixelFormat) {
     switch (mirPixelFormat) {
@@ -102,12 +115,15 @@
 
 bool Screen::skipDBusRegistration = false;
 
-Screen::Screen(mir::graphics::DisplayConfigurationOutput const &screen)
+Screen::Screen(const mir::graphics::DisplayConfigurationOutput &screen)
     : QObject(nullptr)
+    , m_renderTarget(nullptr)
+    , m_displayGroup(nullptr)
     , m_orientationSensor(new QOrientationSensor(this))
+    , m_screenWindow(nullptr)
     , m_unityScreen(nullptr)
 {
-    readMirDisplayConfiguration(screen);
+    setMirDisplayConfiguration(screen);
 
     // Set the default orientation based on the initial screen dimmensions.
     m_nativeOrientation = (m_geometry.width() >= m_geometry.height())
@@ -139,6 +155,14 @@
     }
 }
 
+Screen::~Screen()
+{
+    //if a ScreenWindow associated with this screen, kill it
+    if (m_screenWindow) {
+        m_screenWindow->window()->destroy(); // ends up destroying m_ScreenWindow
+    }
+}
+
 bool Screen::orientationSensorEnabled()
 {
     return m_orientationSensor->isActive();
@@ -150,8 +174,15 @@
     toggleSensors(status);
 }
 
-void Screen::readMirDisplayConfiguration(mir::graphics::DisplayConfigurationOutput const &screen)
+void Screen::setMirDisplayConfiguration(const mir::graphics::DisplayConfigurationOutput &screen)
 {
+    // Note: DisplayConfigurationOutput will be destroyed after this function returns
+
+    // Output data - each output has a unique id and corresponding type. Can be multiple cards.
+    m_outputId = screen.id;
+    m_cardId = screen.card_id;
+    m_type = screen.type;
+
     // Physical screen size
     m_physicalSize.setWidth(screen.physical_size_mm.width.as_float());
     m_physicalSize.setHeight(screen.physical_size_mm.height.as_float());
@@ -162,12 +193,34 @@
     // Pixel depth
     m_depth = 8 * MIR_BYTES_PER_PIXEL(screen.current_format);
 
-    // Mode = Resolution & refresh rate
+    // Power mode
+    m_powerMode = screen.power_mode;
+
+    QRect oldGeometry = m_geometry;
+    // Position of screen in virtual desktop coordinate space
+    m_geometry.setTop(screen.top_left.y.as_int());
+    m_geometry.setLeft(screen.top_left.x.as_int());
+
+    // Mode = current resolution & refresh rate
     mir::graphics::DisplayConfigurationMode mode = screen.modes.at(screen.current_mode_index);
     m_geometry.setWidth(mode.size.width.as_int());
     m_geometry.setHeight(mode.size.height.as_int());
 
-    m_refreshRate = mode.vrefresh_hz;
+    // DPI - unnecessary to calculate, default implementation in QPlatformScreen is sufficient
+
+    // Check for Screen geometry change
+    if (m_geometry != oldGeometry) {
+        QWindowSystemInterface::handleScreenGeometryChange(this->screen(), m_geometry, m_geometry);
+        if (m_screenWindow) { // resize corresponding window immediately
+            m_screenWindow->setGeometry(m_geometry);
+        }
+    }
+
+    // Refresh rate
+    if (m_refreshRate != mode.vrefresh_hz) {
+        m_refreshRate = mode.vrefresh_hz;
+        QWindowSystemInterface::handleScreenRefreshRateChange(this->screen(), mode.vrefresh_hz);
+    }
 }
 
 void Screen::toggleSensors(const bool enable) const
@@ -232,3 +285,52 @@
     const QPlatformCursor *platformCursor = &m_cursor;
     return const_cast<QPlatformCursor *>(platformCursor);
 }
+
+ScreenWindow *Screen::window() const
+{
+    return m_screenWindow;
+}
+
+void Screen::setWindow(ScreenWindow *window)
+{
+    if (window && m_screenWindow) {
+        qCDebug(QTMIR_SENSOR_MESSAGES) << "Screen::setWindow - overwriting existing ScreenWindow";
+    }
+    m_screenWindow = window;
+}
+
+void Screen::setMirDisplayBuffer(mir::graphics::DisplayBuffer *buffer, mir::graphics::DisplaySyncGroup *group)
+{
+    qCDebug(QTMIR_SCREENS) << "Screen::setMirDisplayBuffer" << buffer << group;
+    // This operation should only be performed while rendering is stopped
+    m_renderTarget = as_render_target(buffer);
+    m_displayGroup = group;
+}
+
+void Screen::swapBuffers()
+{
+    m_renderTarget->swap_buffers();
+
+    /* FIXME this exposes a QtMir architecture problem, as Screen is supposed to wrap a mg::DisplayBuffer.
+     * We use Qt's multithreaded renderer, where each Screen is rendered to relatively independently, and
+     * post() called also individually.
+     *
+     * But if this is a native server on Android, in the multimonitor case a DisplaySyncGroup can contain
+     * 2+ DisplayBuffers, one post() call will submit all mg::DisplayBuffers in the group for flipping.
+     * This will cause just one Screen to be updated, blocking the swap call for the other Screens, which
+     * will slow rendering dramatically.
+     *
+     * Integrating the Qt Scenegraph renderer as a Mir renderer should solve this issue.
+     */
+    m_displayGroup->post();
+}
+
+void Screen::makeCurrent()
+{
+    m_renderTarget->make_current();
+}
+
+void Screen::doneCurrent()
+{
+    m_renderTarget->release_current();
+}

=== modified file 'src/platforms/mirserver/screen.h'
--- src/platforms/mirserver/screen.h	2015-10-16 17:43:47 +0000
+++ src/platforms/mirserver/screen.h	2015-10-16 17:43:47 +0000
@@ -17,22 +17,31 @@
 #ifndef SCREEN_H
 #define SCREEN_H
 
+// Qt
 #include <QObject>
 #include <QTimer>
 #include <QtDBus/QDBusInterface>
 #include <qpa/qplatformscreen.h>
 
+// Mir
 #include <mir/graphics/display_configuration.h>
 
+// local
 #include "cursor.h"
+#include "screenwindow.h"
 
 class QOrientationSensor;
+namespace mir {
+    namespace graphics { class DisplayBuffer; class DisplaySyncGroup; }
+    namespace renderer { namespace gl { class RenderTarget; }}
+}
 
 class Screen : public QObject, public QPlatformScreen
 {
     Q_OBJECT
 public:
-    Screen(mir::graphics::DisplayConfigurationOutput const&);
+    Screen(const mir::graphics::DisplayConfigurationOutput &);
+    ~Screen();
 
     // QPlatformScreen methods.
     QRect geometry() const override { return m_geometry; }
@@ -45,6 +54,9 @@
     QPlatformCursor *cursor() const override;
 
     void toggleSensors(const bool enable) const;
+    mir::graphics::DisplayConfigurationOutputType outputType() const { return m_type; }
+
+    ScreenWindow* window() const;
 
     // QObject methods.
     void customEvent(QEvent* event) override;
@@ -57,22 +69,40 @@
    void onDisplayPowerStateChanged(int, int);
    void onOrientationReadingChanged();
 
+protected:
+    void setWindow(ScreenWindow *window);
+
+    void setMirDisplayConfiguration(const mir::graphics::DisplayConfigurationOutput &);
+    void setMirDisplayBuffer(mir::graphics::DisplayBuffer *, mir::graphics::DisplaySyncGroup *);
+    void swapBuffers();
+    void makeCurrent();
+    void doneCurrent();
+
 private:
-    void readMirDisplayConfiguration(mir::graphics::DisplayConfigurationOutput const&);
-
     QRect m_geometry;
     int m_depth;
     QImage::Format m_format;
     QSizeF m_physicalSize;
     qreal m_refreshRate;
 
+    mir::renderer::gl::RenderTarget *m_renderTarget;
+    mir::graphics::DisplaySyncGroup *m_displayGroup;
+    mir::graphics::DisplayConfigurationOutputId m_outputId;
+    mir::graphics::DisplayConfigurationCardId m_cardId;
+    mir::graphics::DisplayConfigurationOutputType m_type;
+    MirPowerMode m_powerMode;
+
     Qt::ScreenOrientation m_nativeOrientation;
     Qt::ScreenOrientation m_currentOrientation;
     QOrientationSensor *m_orientationSensor;
 
+    ScreenWindow *m_screenWindow;
     QDBusInterface *m_unityScreen;
 
     qtmir::Cursor m_cursor;
+
+    friend class ScreenController;
+    friend class ScreenWindow;
 };
 
 #endif // SCREEN_H

=== added file 'src/platforms/mirserver/screencontroller.cpp'
--- src/platforms/mirserver/screencontroller.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/screencontroller.cpp	2015-10-16 17:43:47 +0000
@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2015 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 "screencontroller.h"
+
+#include "screenwindow.h"
+#include "qtcompositor.h"
+#include "logging.h"
+#include "mirserverintegration.h"
+#include "screen.h"
+
+// Mir
+#include <mir/graphics/display.h>
+#include <mir/graphics/display_buffer.h>
+
+// Qt
+#include <QScreen>
+#include <QQuickWindow>
+#include <qpa/qwindowsysteminterface.h>
+#include <QGuiApplication> // for qApp
+
+// std
+#include <memory>
+
+Q_LOGGING_CATEGORY(QTMIR_SCREENS, "qtmir.screens")
+
+namespace mg = mir::graphics;
+
+
+ScreenController::ScreenController(QObject *parent)
+    : QObject(parent)
+    , m_compositing(false)
+{
+    qCDebug(QTMIR_SCREENS) << "ScreenController::ScreenController";
+}
+
+// init only after MirServer has initialized - runs on MirServerThread!!!
+void ScreenController::init(const std::shared_ptr<mir::graphics::Display> &display,
+                            const std::shared_ptr<mir::compositor::Compositor> &compositor)
+{
+    m_display = display;
+    m_compositor = compositor;
+
+    // Use a Blocking Queued Connection to enforce synchronization of Qt GUI thread with Mir thread(s)
+    // on compositor shutdown. Compositor startup can be lazy.
+    // Queued connections work because the thread affinity of this class is with the Qt GUI thread.
+    auto qtCompositor = static_cast<QtCompositor *>(compositor.get());
+    connect(qtCompositor, &QtCompositor::starting,
+            this, &ScreenController::onCompositorStarting);
+    connect(qtCompositor, &QtCompositor::stopping,
+            this, &ScreenController::onCompositorStopping, Qt::BlockingQueuedConnection);
+}
+
+// terminate before shutting down the Mir server, or else liable to deadlock with the blocking connection above
+// Runs on MirServerThread!!!
+void ScreenController::terminate()
+{
+    auto qtCompositor = static_cast<QtCompositor *>(m_compositor.get());
+    qtCompositor->disconnect();
+}
+
+void ScreenController::onCompositorStarting()
+{
+    qCDebug(QTMIR_SCREENS) << "ScreenController::onCompositorStarting";
+    m_compositing = true;
+
+    update();
+
+    // (Re)Start Qt's render thread by setting all windows with a corresponding screen to exposed.
+    for (auto screen : m_screenList) {
+        auto window = static_cast<ScreenWindow *>(screen->window());
+        if (window && window->window()) {
+            window->setExposed(true);
+        }
+    }
+}
+
+void ScreenController::onCompositorStopping()
+{
+    qCDebug(QTMIR_SCREENS) << "ScreenController::onCompositorStopping";
+    m_compositing = false;
+
+    // Stop Qt's render threads by setting all its windows it obscured. Must
+    // block until all windows have their GL contexts released.
+    for (auto screen : m_screenList) {
+        auto window = static_cast<ScreenWindow *>(screen->window());
+        if (window && window->window()) {
+            window->setExposed(false);
+        }
+    }
+
+    update();
+}
+
+void ScreenController::update()
+{
+    qCDebug(QTMIR_SCREENS) << "ScreenController::update";
+    auto display = m_display.lock();
+    if (!display)
+        return;
+    auto displayConfig = display->configuration();
+
+    // Mir only tells us something changed, it is up to us to figure out what.
+    QList<Screen*> newScreenList;
+    QList<Screen*> oldScreenList = m_screenList;
+    m_screenList.clear();
+
+    displayConfig->for_each_output(
+        [this, &oldScreenList, &newScreenList](const mg::DisplayConfigurationOutput &output) {
+            if (output.used && output.connected) {
+                Screen *screen = findScreenWithId(oldScreenList, output.id);
+                if (screen) { // we've already set up this display before, refresh its internals
+                    screen->setMirDisplayConfiguration(output);
+                    oldScreenList.removeAll(screen);
+                } else {
+                    // new display, so create Screen for it
+                    screen = this->createScreen(output);
+                    newScreenList.append(screen);
+                    qCDebug(QTMIR_SCREENS) << "Added Screen with id" << output.id.as_value()
+                                           << "and geometry" << screen->geometry();
+                }
+                m_screenList.append(screen);
+            }
+        }
+    );
+
+    // Delete any old & unused Screens
+    for (auto screen: oldScreenList) {
+        qCDebug(QTMIR_SCREENS) << "Removed Screen with id" << screen->m_outputId.as_value()
+                               << "and geometry" << screen->geometry();
+        // The screen is automatically removed from Qt's internal list by the QPlatformScreen destructor.
+        auto window = static_cast<ScreenWindow *>(screen->window());
+        if (window && window->window() && window->isExposed()) {
+            window->window()->hide();
+        }
+        bool ok = QMetaObject::invokeMethod(qApp, "onScreenAboutToBeRemoved", Qt::DirectConnection, Q_ARG(QScreen*, screen->screen()));
+        if (!ok) {
+            qCWarning(QTMIR_SCREENS) << "Failed to invoke QGuiApplication::onScreenAboutToBeRemoved(QScreen*) slot.";
+        }
+        delete screen;
+    }
+
+    // Match up the new Mir DisplayBuffers with each Screen
+    display->for_each_display_sync_group([&](mg::DisplaySyncGroup &group) {
+        group.for_each_display_buffer([&](mg::DisplayBuffer &buffer) {
+            // only way to match Screen to a DisplayBuffer is by matching the geometry
+            QRect dbGeom(buffer.view_area().top_left.x.as_int(),
+                         buffer.view_area().top_left.y.as_int(),
+                         buffer.view_area().size.width.as_int(),
+                         buffer.view_area().size.height.as_int());
+
+            for (auto screen : m_screenList) {
+                if (dbGeom == screen->geometry()) {
+                    screen->setMirDisplayBuffer(&buffer, &group);
+                    break;
+                }
+            }
+        });
+    });
+
+    qCDebug(QTMIR_SCREENS) << "=======================================";
+    for (auto screen: m_screenList) {
+        qCDebug(QTMIR_SCREENS) << screen << "- id:" << screen->m_outputId.as_value()
+                               << "geometry:" << screen->geometry()
+                               << "window:" << screen->window()
+                               << "type" << static_cast<int>(screen->outputType());
+    }
+    qCDebug(QTMIR_SCREENS) << "=======================================";
+
+    for (auto screen : newScreenList) {
+        Q_EMIT screenAdded(screen);
+    }
+}
+
+Screen* ScreenController::createScreen(const mir::graphics::DisplayConfigurationOutput &output) const
+{
+    return new Screen(output);
+}
+
+Screen* ScreenController::findScreenWithId(const QList<Screen *> &list, const mg::DisplayConfigurationOutputId id)
+{
+    for (Screen *screen : list) {
+        if (screen->m_outputId == id) {
+            return screen;
+        }
+    }
+    return nullptr;
+}
+
+QWindow* ScreenController::getWindowForPoint(const QPoint &point) //FIXME - not thread safe & not efficient
+{
+    for (Screen *screen : m_screenList) {
+        if (screen->window() && screen->geometry().contains(point)) {
+            return screen->window()->window();
+        }
+    }
+    return nullptr;
+}

=== added file 'src/platforms/mirserver/screencontroller.h'
--- src/platforms/mirserver/screencontroller.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/screencontroller.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2015 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 SCREENCONTROLLER_H
+#define SCREENCONTROLLER_H
+
+#include <QObject>
+#include <QPoint>
+
+// Mir
+#include <mir/graphics/display_configuration.h>
+
+// std
+#include <memory>
+
+namespace mir {
+    namespace graphics { class Display; }
+    namespace compositor { class Compositor; }
+}
+class Screen;
+class QWindow;
+
+/*
+ * ScreenController monitors the Mir display configuration and compositor status, and updates
+ * the relevant QScreen and QWindow states accordingly.
+ *
+ * Primary purposes are:
+ * 1. to update QScreen state on Mir display configuration changes
+ * 2. to stop the Qt renderer by hiding its QWindow when Mir wants to stop all compositing,
+ *    and resume Qt's renderer by showing its QWindow when Mir wants to resume compositing.
+ *
+ *
+ * Threading Note:
+ * This object must have affinity to the main Qt GUI thread, as it creates & destroys Platform
+ * objects which Qt uses internally. However beware as the init() & terminate() methods need to
+ * be called on the MirServerThread thread, as we need to monitor the screen state *after*
+ * Mir has initialized but before Qt's event loop has started, and tear down before Mir terminates.
+ * Also note the MirServerThread does not have an QEventLoop.
+ *
+ * All other methods must be called on the Qt GUI thread.
+ */
+
+class ScreenController : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ScreenController(QObject *parent = 0);
+
+    QList<Screen*> screens() const { return m_screenList; }
+    bool compositing() const { return m_compositing; }
+
+    QWindow* getWindowForPoint(const QPoint &point);
+
+Q_SIGNALS:
+    void screenAdded(Screen *screen);
+
+public Q_SLOTS:
+    void update();
+
+public:
+    // called by MirServer
+    void init(const std::shared_ptr<mir::graphics::Display> &display,
+              const std::shared_ptr<mir::compositor::Compositor> &compositor);
+    void terminate();
+
+    // override for testing purposes
+    virtual Screen *createScreen(const mir::graphics::DisplayConfigurationOutput &output) const;
+
+protected Q_SLOTS:
+    void onCompositorStarting();
+    void onCompositorStopping();
+
+private:
+    Screen* findScreenWithId(const QList<Screen*> &list, const mir::graphics::DisplayConfigurationOutputId id);
+
+    std::weak_ptr<mir::graphics::Display> m_display;
+    std::shared_ptr<mir::compositor::Compositor> m_compositor;
+    QList<Screen*> m_screenList;
+    bool m_compositing;
+};
+
+#endif // SCREENCONTROLLER_H

=== renamed file 'src/platforms/mirserver/displaywindow.cpp' => 'src/platforms/mirserver/screenwindow.cpp'
--- src/platforms/mirserver/displaywindow.cpp	2015-10-07 14:38:44 +0000
+++ src/platforms/mirserver/screenwindow.cpp	2015-10-16 17:43:47 +0000
@@ -14,15 +14,22 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "displaywindow.h"
-
-#include "mir/geometry/size.h"
-
+#include "screenwindow.h"
+#include "screen.h"
+
+// Mir
+#include <mir/geometry/size.h>
+#include <mir/graphics/display_buffer.h>
+
+// Qt
 #include <qpa/qwindowsysteminterface.h>
 #include <qpa/qplatformscreen.h>
-
+#include <QQuickWindow>
+#include <QtQuick/private/qsgrenderloop_p.h>
 #include <QDebug>
 
+#include "logging.h"
+
 static WId newWId()
 {
     static WId id = 0;
@@ -33,106 +40,74 @@
     return ++id;
 }
 
-static mir::renderer::gl::RenderTarget *as_render_target(
-    mir::graphics::DisplayBuffer *displayBuffer)
-{
-    auto const render_target =
-        dynamic_cast<mir::renderer::gl::RenderTarget*>(
-            displayBuffer->native_display_buffer());
-    if (!render_target)
-        throw std::logic_error("DisplayBuffer does not support GL rendering");
-
-    return render_target;
-}
-
-DisplayWindow::DisplayWindow(
-    QWindow *window,
-    mir::graphics::DisplaySyncGroup *displayGroup,
-    mir::graphics::DisplayBuffer *displayBuffer)
-    : QObject(nullptr), QPlatformWindow(window)
-    , m_isExposed(true)
+ScreenWindow::ScreenWindow(QWindow *window)
+    : QPlatformWindow(window)
+    , m_exposed(false)
     , m_winId(newWId())
-    , m_displayGroup(displayGroup)
-    , m_renderTarget(as_render_target(displayBuffer))
 {
-    qDebug() << "DisplayWindow::DisplayWindow";
-    qWarning("Window %p: %p 0x%x\n", this, window, uint(m_winId));
+    // Register with the Screen it is associated with
+    auto myScreen = static_cast<Screen *>(screen());
+    Q_ASSERT(myScreen);
+    myScreen->setWindow(this);
+
+    qCDebug(QTMIR_SCREENS) << "ScreenWindow" << this << "with window ID" << uint(m_winId) << "backed by" << myScreen;
 
     QRect screenGeometry(screen()->availableGeometry());
     if (window->geometry() != screenGeometry) {
         setGeometry(screenGeometry);
+        window->setGeometry(screenGeometry);
     }
     window->setSurfaceType(QSurface::OpenGLSurface);
-
-    // The compositor window is always active. I.e., it's always focused so that
-    // it always processes key events, etc
-    requestActivateWindow();
-}
-
-QRect DisplayWindow::geometry() const
-{
-    // For yet-to-become-fullscreen windows report the geometry covering the entire
-    // screen. This is particularly important for Quick where the root object may get
-    // sized to some geometry queried before calling create().
-    return screen()->availableGeometry();
-}
-
-void DisplayWindow::setGeometry(const QRect &)
-{
-    // We only support full-screen windows
-    QRect rect(screen()->availableGeometry());
-    QWindowSystemInterface::handleGeometryChange(window(), rect);
-    QPlatformWindow::setGeometry(rect);
-}
-
-bool DisplayWindow::isExposed() const
-{
-    return m_isExposed;
-}
-
-bool DisplayWindow::event(QEvent *event)
-{
-    // Intercept Hide event and convert to Expose event, as Hide causes Qt to release GL
-    // resources, which we don't want. Must intercept Show to un-do hide.
-    if (event->type() == QEvent::Hide) {
-        qDebug() << "DisplayWindow::event got QEvent::Hide";
-        m_isExposed = false;
-        QWindowSystemInterface::handleExposeEvent(window(), QRect());
-        QWindowSystemInterface::flushWindowSystemEvents();
-        return true;
-    } else if (event->type() == QEvent::Show) {
-        qDebug() << "DisplayWindow::event got QEvent::Show";
-        m_isExposed = true;
-        QRect rect(QPoint(), geometry().size());
-        QWindowSystemInterface::handleExposeEvent(window(), rect);
-        QWindowSystemInterface::flushWindowSystemEvents();
-        return true;
+}
+
+ScreenWindow::~ScreenWindow()
+{
+    qCDebug(QTMIR_SCREENS) << "Destroying ScreenWindow" << this;
+    static_cast<Screen *>(screen())->setWindow(nullptr);
+}
+
+bool ScreenWindow::isExposed() const
+{
+    return m_exposed;
+}
+
+void ScreenWindow::setExposed(const bool exposed)
+{
+    qCDebug(QTMIR_SCREENS) << "ScreenWindow::setExposed" << this << exposed;
+    if (m_exposed == exposed)
+        return;
+
+    m_exposed = exposed;
+    if (!window())
+        return;
+
+    // If backing a QQuickWindow, need to stop/start its renderer immediately
+    auto quickWindow = static_cast<QQuickWindow *>(window());
+    if (!quickWindow)
+        return;
+
+    auto renderer = QSGRenderLoop::instance();
+    if (exposed) {
+        renderer->show(quickWindow);
+        QWindowSystemInterface::handleExposeEvent(window(), QRegion()); // else it won't redraw
+    } else {
+        quickWindow->setPersistentOpenGLContext(false);
+        quickWindow->setPersistentSceneGraph(false);
+        renderer->hide(quickWindow); // ExposeEvent will arrive too late, need to stop compositor immediately
     }
-    return QObject::event(event);
-}
-
-void DisplayWindow::swapBuffers()
-{
-    m_renderTarget->swap_buffers();
-
-    // FIXME this exposes a QtMir architecture problem now, as DisplayWindow
-    // is supposed to wrap a mg::DisplayBuffer. We use Qt's multithreaded
-    // renderer, where each DisplayWindow is rendered to relatively
-    // independently, and post() called also individually.
-    //
-    // But in multimonitor case where a DisplaySyncGroup contains 2
-    // DisplayBuffers, one post() call will submit both
-    // mg::DisplayBuffers for flipping, which can happen before the other
-    // DisplayWindow has been rendered to, causing visual artifacts
-    m_displayGroup->post();
-}
-
-void DisplayWindow::makeCurrent()
-{
-    m_renderTarget->make_current();
-}
-
-void DisplayWindow::doneCurrent()
-{
-    m_renderTarget->release_current();
+}
+
+void ScreenWindow::swapBuffers()
+{
+    static_cast<Screen *>(screen())->swapBuffers();
+}
+
+void ScreenWindow::makeCurrent()
+{
+    static_cast<Screen *>(screen())->makeCurrent();
+}
+
+void ScreenWindow::doneCurrent()
+{
+    static_cast<Screen *>(screen())->doneCurrent();
 }

=== renamed file 'src/platforms/mirserver/displaywindow.h' => 'src/platforms/mirserver/screenwindow.h'
--- src/platforms/mirserver/displaywindow.h	2015-10-07 14:38:44 +0000
+++ src/platforms/mirserver/screenwindow.h	2015-10-16 17:43:47 +0000
@@ -14,44 +14,33 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef DISPLAYWINDOW_H
-#define DISPLAYWINDOW_H
+#ifndef SCREENWINDOW_H
+#define SCREENWINDOW_H
 
 #include <qpa/qplatformwindow.h>
 
-#include <mir/graphics/display.h>
-#include <mir/graphics/display_buffer.h>
-#include <mir/renderer/gl/render_target.h>
-
-#include <QObject>
-
-// DisplayWindow wraps the whatever implementation Mir creates of a DisplayBuffer,
-// which is the buffer output for an individual display.
-
-class DisplayWindow : public QObject, public QPlatformWindow
+// ScreenWindow implements the basics of a QPlatformWindow.
+// QtMir enforces one Window per Screen, so Window and Screen are tightly coupled.
+// All Mir specifics live in the associated Screen object.
+
+class ScreenWindow : public QPlatformWindow
 {
-    Q_OBJECT
 public:
-    explicit DisplayWindow(QWindow *window, mir::graphics::DisplaySyncGroup*, mir::graphics::DisplayBuffer*);
+    explicit ScreenWindow(QWindow *window);
+    virtual ~ScreenWindow();
 
-    QRect geometry() const override;
-    void setGeometry(const QRect &rect) override;
+    bool isExposed() const override;
+    void setExposed(const bool exposed);
 
     WId winId() const override { return m_winId; }
 
-    bool isExposed() const override;
-
-    bool event(QEvent *event) override;
-
     void swapBuffers();
     void makeCurrent();
     void doneCurrent();
 
 private:
-    bool m_isExposed;
+    bool m_exposed;
     WId m_winId;
-    mir::graphics::DisplaySyncGroup *m_displayGroup;
-    mir::renderer::gl::RenderTarget *m_renderTarget;
 };
 
-#endif // DISPLAYWINDOW_H
+#endif // SCREENWINDOW_H

=== added file 'src/platforms/mirserver/tileddisplayconfigurationpolicy.cpp'
--- src/platforms/mirserver/tileddisplayconfigurationpolicy.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/tileddisplayconfigurationpolicy.cpp	2015-10-16 17:43:47 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2015 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 "tileddisplayconfigurationpolicy.h"
+
+#include <mir/graphics/display_configuration.h>
+#include <mir/geometry/point.h>
+
+namespace mg = mir::graphics;
+
+TiledDisplayConfigurationPolicy::TiledDisplayConfigurationPolicy(
+        const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> &wrapped)
+    : m_wrapped(wrapped)
+{
+}
+
+void TiledDisplayConfigurationPolicy::apply_to(mg::DisplayConfiguration& conf)
+{
+    int nextTopLeftPosition = 0;
+
+    m_wrapped->apply_to(conf);
+
+    conf.for_each_output(
+        [&](mg::UserDisplayConfigurationOutput& output)
+        {
+            if (output.connected && output.used) {
+                output.top_left = mir::geometry::Point{nextTopLeftPosition, 0};
+                nextTopLeftPosition += output.modes[output.preferred_mode_index].size.width.as_int();
+            }
+        });
+}

=== added file 'src/platforms/mirserver/tileddisplayconfigurationpolicy.h'
--- src/platforms/mirserver/tileddisplayconfigurationpolicy.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/tileddisplayconfigurationpolicy.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2015 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 TILEDDISPLAYCONFIGURATIONPOLICY_H
+#define TILEDDISPLAYCONFIGURATIONPOLICY_H
+
+#include <mir/graphics/display_configuration_policy.h>
+
+#include <memory>
+
+class TiledDisplayConfigurationPolicy : public mir::graphics::DisplayConfigurationPolicy
+{
+public:
+    TiledDisplayConfigurationPolicy(const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> &wrapped);
+
+    void apply_to(mir::graphics::DisplayConfiguration& conf) override;
+
+private:
+    const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> m_wrapped;
+};
+
+#endif // TILEDDISPLAYCONFIGURATIONPOLICY_H

=== added directory 'tests/common'
=== added file 'tests/common/fake_displayconfigurationoutput.h'
--- tests/common/fake_displayconfigurationoutput.h	1970-01-01 00:00:00 +0000
+++ tests/common/fake_displayconfigurationoutput.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2015 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 FAKE_DISPLAYCONFIGURATIONOUTPUT_H
+#define FAKE_DISPLAYCONFIGURATIONOUTPUT_H
+
+#include <mir/graphics/display_configuration.h>
+
+namespace mg = mir::graphics;
+namespace geom = mir::geometry;
+
+const mg::DisplayConfigurationOutput fakeOutput1
+{
+    mg::DisplayConfigurationOutputId{3},
+    mg::DisplayConfigurationCardId{2},
+    mg::DisplayConfigurationOutputType::dvid,
+    {
+        mir_pixel_format_abgr_8888
+    },
+    {
+        {geom::Size{100, 200}, 60.0},
+        {geom::Size{100, 200}, 59.0},
+        {geom::Size{150, 200}, 59.0}
+    },
+    0,
+    geom::Size{1111, 2222},
+    true,
+    true,
+    geom::Point(),
+    2,
+    mir_pixel_format_abgr_8888,
+    mir_power_mode_on,
+    mir_orientation_normal,
+    1.0f,
+    mir_form_factor_unknown
+};
+
+const mg::DisplayConfigurationOutput fakeOutput2
+{
+    mg::DisplayConfigurationOutputId{2},
+    mg::DisplayConfigurationCardId{4},
+    mg::DisplayConfigurationOutputType::lvds,
+    {
+        mir_pixel_format_xbgr_8888
+    },
+    {
+        {geom::Size{800, 1200}, 90.0},
+        {geom::Size{1600, 2400}, 60.0},
+        {geom::Size{1500, 2000}, 75.0}
+    },
+    0,
+    geom::Size{1000, 2000},
+    true,
+    true,
+    geom::Point(500, 600),
+    2,
+    mir_pixel_format_xbgr_8888,
+    mir_power_mode_on,
+    mir_orientation_left,
+    1.0f,
+    mir_form_factor_unknown
+};
+
+#endif // FAKE_DISPLAYCONFIGURATIONOUTPUT_H

=== added file 'tests/common/gmock_fixes.h'
--- tests/common/gmock_fixes.h	1970-01-01 00:00:00 +0000
+++ tests/common/gmock_fixes.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,124 @@
+//
+// Copyright © 2012 Canonical Ltd. Copyright 2007, Google Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: [e-mail] (Zhanyong Wan)
+// Authored by: Alan Griffiths <[e-mail]>
+
+#ifndef MIR_TEST_GMOCK_FIXES_H_
+#define MIR_TEST_GMOCK_FIXES_H_
+
+#include <memory>
+#include <gmock/gmock.h>
+
+namespace testing
+{
+namespace internal
+{
+
+template<typename T>
+class ActionResultHolder<std::unique_ptr<T>>
+: public UntypedActionResultHolderBase {
+ public:
+  explicit ActionResultHolder(std::unique_ptr<T>&& a_value) :
+  value_(std::move(a_value)) {}
+
+  // The compiler-generated copy constructor and assignment operator
+  // are exactly what we need, so we don't need to define them.
+
+  // Returns the held value and deletes this object.
+  std::unique_ptr<T> GetValueAndDelete() const {
+      std::unique_ptr<T> retval(std::move(value_));
+    delete this;
+    return retval;
+  }
+
+  // Prints the held value as an action's result to os.
+  virtual void PrintAsActionResult(::std::ostream* os) const {
+    *os << "\n          Returns: ";
+    // T may be a reference type, so we don't use UniversalPrint().
+    UniversalPrinter<std::unique_ptr<T>>::Print(value_, os);
+  }
+
+  // Performs the given mock function's default action and returns the
+  // result in a new-ed ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMockerBase<F>* func_mocker,
+      const typename Function<F>::ArgumentTuple& args,
+      const string& call_description) {
+    return new ActionResultHolder(
+        func_mocker->PerformDefaultAction(args, call_description));
+  }
+
+  // Performs the given action and returns the result in a new-ed
+  // ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder*
+  PerformAction(const Action<F>& action,
+                const typename Function<F>::ArgumentTuple& args) {
+    return new ActionResultHolder(action.Perform(args));
+  }
+
+ private:
+  std::unique_ptr<T> mutable value_;
+
+  // T could be a reference type, so = isn't supported.
+  GTEST_DISALLOW_ASSIGN_(ActionResultHolder);
+};
+
+}
+
+template<typename T>
+class DefaultValue<std::unique_ptr<T>> {
+ public:
+  // Unsets the default value for type T.
+  static void Clear() {}
+
+  // Returns true iff the user has set the default value for type T.
+  static bool IsSet() { return false; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return true;
+  }
+
+  // Returns the default value for type T if the user has set one;
+  // otherwise returns the built-in default value if there is one;
+  // otherwise aborts the process.
+  static std::unique_ptr<T> Get() {
+    return std::unique_ptr<T>();
+  }
+};
+
+}
+
+#endif /* MIR_TEST_GMOCK_FIXES_H_ */

=== added file 'tests/common/mock_display.h'
--- tests/common/mock_display.h	1970-01-01 00:00:00 +0000
+++ tests/common/mock_display.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2015 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 MOCKDISPLAY_H
+#define MOCKDISPLAY_H
+
+#include <mir/graphics/display.h>
+#include <mir/graphics/gl_context.h>
+
+#include <gmock/gmock.h>
+#include "gmock_fixes.h"
+
+class MockDisplaySyncGroup : public mir::graphics::DisplaySyncGroup
+{
+public:
+    MOCK_METHOD1(for_each_display_buffer, void(std::function<void(mir::graphics::DisplayBuffer&)> const& f));
+    MOCK_METHOD0(post, void());
+};
+
+struct MockDisplay : public mir::graphics::Display
+{
+public:
+    MOCK_METHOD1(for_each_display_sync_group, void(std::function<void(mir::graphics::DisplaySyncGroup&)> const&));
+    MOCK_CONST_METHOD0(configuration, std::unique_ptr<mir::graphics::DisplayConfiguration>());
+    MOCK_METHOD1(configure, void(mir::graphics::DisplayConfiguration const&));
+    MOCK_METHOD2(register_configuration_change_handler,
+                 void(mir::graphics::EventHandlerRegister&, mir::graphics::DisplayConfigurationChangeHandler const&));
+
+    MOCK_METHOD3(register_pause_resume_handlers, void(mir::graphics::EventHandlerRegister&,
+                                                      mir::graphics::DisplayPauseHandler const&,
+                                                      mir::graphics::DisplayResumeHandler const&));
+    MOCK_METHOD0(pause, void());
+    MOCK_METHOD0(resume, void());
+    MOCK_METHOD1(create_hardware_cursor, std::shared_ptr<mir::graphics::Cursor>(std::shared_ptr<mir::graphics::CursorImage> const&));
+    MOCK_METHOD0(create_gl_context, std::unique_ptr<mir::graphics::GLContext>());
+};
+
+
+
+#endif // MOCKDISPLAY_H

=== added file 'tests/common/mock_display_configuration.h'
--- tests/common/mock_display_configuration.h	1970-01-01 00:00:00 +0000
+++ tests/common/mock_display_configuration.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2015 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 MOCK_DISPLAY_CONFIGURATION_H
+#define MOCK_DISPLAY_CONFIGURATION_H
+
+#include <mir/graphics/display_configuration.h>
+
+#include <gmock/gmock.h>
+#include "gmock_fixes.h"
+
+class MockDisplayConfiguration : public mir::graphics::DisplayConfiguration
+{
+public:
+    MOCK_CONST_METHOD1(for_each_card, void(std::function<void(mir::graphics::DisplayConfigurationCard const&)>));
+
+    MOCK_CONST_METHOD1(for_each_output, void(std::function<void(mir::graphics::DisplayConfigurationOutput const&)>));
+    MOCK_METHOD1(for_each_output, void(std::function<void(mir::graphics::UserDisplayConfigurationOutput&)>));
+
+    MOCK_CONST_METHOD0(valid, bool());
+};
+#endif // MOCK_DISPLAY_CONFIGURATION_H

=== added file 'tests/common/mock_gl_display_buffer.h'
--- tests/common/mock_gl_display_buffer.h	1970-01-01 00:00:00 +0000
+++ tests/common/mock_gl_display_buffer.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2015 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 MOCK_GL_DISPLAY_BUFFER_H
+#define MOCK_GL_DISPLAY_BUFFER_H
+
+#include <mir/graphics/display_buffer.h>
+#include <mir/renderer/gl/render_target.h>
+
+#include <gmock/gmock.h>
+
+class MockGLDisplayBuffer : public mir::graphics::DisplayBuffer,
+                            public mir::renderer::gl::RenderTarget,
+                            public mir::graphics::NativeDisplayBuffer
+{
+public:
+    MockGLDisplayBuffer()
+    {
+        using namespace testing;
+        ON_CALL(*this, view_area())
+            .WillByDefault(Return(mir::geometry::Rectangle{{0,0},{0,0}}));
+        ON_CALL(*this, native_display_buffer())
+            .WillByDefault(Return(dynamic_cast<mir::graphics::NativeDisplayBuffer*>(this)));
+    }
+    MOCK_CONST_METHOD0(view_area, mir::geometry::Rectangle());
+    MOCK_METHOD1(post_renderables_if_optimizable, bool(mir::graphics::RenderableList const&));
+    MOCK_CONST_METHOD0(orientation, MirOrientation());
+    MOCK_METHOD0(native_display_buffer, mir::graphics::NativeDisplayBuffer*());
+
+    MOCK_METHOD0(make_current, void());
+    MOCK_METHOD0(release_current, void());
+    MOCK_METHOD0(swap_buffers, void());
+};
+
+
+#endif // MOCK_GL_DISPLAY_BUFFER_H

=== added file 'tests/common/mock_main_loop.h'
--- tests/common/mock_main_loop.h	1970-01-01 00:00:00 +0000
+++ tests/common/mock_main_loop.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2015 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 MOCKMAINLOOP_H
+#define MOCKMAINLOOP_H
+
+#include <gmock/gmock.h>
+
+#include <mir/main_loop.h>
+
+#include <memory>
+
+class MockMainLoop : public mir::MainLoop
+{
+public:
+    ~MockMainLoop() noexcept {}
+
+    void run() override {}
+    void stop() override {}
+
+    MOCK_METHOD2(register_signal_handler,
+                 void(std::initializer_list<int>,
+                      std::function<void(int)> const&));
+
+    MOCK_METHOD3(register_fd_handler,
+                 void(std::initializer_list<int>, void const*,
+                      std::function<void(int)> const&));
+
+    MOCK_METHOD1(unregister_fd_handler, void(void const*));
+
+    MOCK_METHOD2(enqueue, void(void const*, mir::ServerAction const&));
+    MOCK_METHOD1(pause_processing_for,void (void const*));
+    MOCK_METHOD1(resume_processing_for,void (void const*));
+
+    MOCK_METHOD1(create_alarm, std::unique_ptr<mir::time::Alarm>(std::function<void()> const& callback));
+    MOCK_METHOD1(create_alarm, std::unique_ptr<mir::time::Alarm>(std::shared_ptr<mir::LockableCallback> const& callback));
+};
+
+
+#endif // MOCKMAINLOOP_H

=== modified file 'tests/mirserver/CMakeLists.txt'
--- tests/mirserver/CMakeLists.txt	2014-11-13 15:47:30 +0000
+++ tests/mirserver/CMakeLists.txt	2015-10-16 17:43:47 +0000
@@ -1,3 +1,4 @@
 add_subdirectory(QtEventFeeder)
 add_subdirectory(Clipboard)
 add_subdirectory(Screen)
+add_subdirectory(ScreenController)

=== modified file 'tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h'
--- tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2015-10-16 17:43:47 +0000
+++ tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2015-10-16 17:43:47 +0000
@@ -19,19 +19,26 @@
 #define MOCK_QTWINDOWSYSTEM_H
 
 #include <qteventfeeder.h>
+#include <QWindow>
 
 class MockQtWindowSystem : public QtEventFeeder::QtWindowSystemInterface {
 public:
-    MOCK_METHOD0(hasTargetWindow, bool());
-    MOCK_METHOD0(targetWindowGeometry, QRect());
+    MOCK_CONST_METHOD0(ready, bool());
+    MOCK_METHOD1(setScreenController, void(const QSharedPointer<ScreenController> &));
+    MOCK_METHOD1(getWindowForTouchPoint, QWindow*(const QPoint &point));
+    MOCK_METHOD0(lastWindow, QWindow*());
+    MOCK_METHOD0(focusedWindow, QWindow*());
     MOCK_METHOD1(registerTouchDevice, void(QTouchDevice* device));
-    MOCK_METHOD10(handleExtendedKeyEvent, void(ulong timestamp, QEvent::Type type, int key,
-            Qt::KeyboardModifiers modifiers,
-            quint32 nativeScanCode, quint32 nativeVirtualKey,
-            quint32 nativeModifiers,
-            const QString& text, bool autorep,
-            ushort count));
-    MOCK_METHOD4(handleTouchEvent, void(ulong timestamp, QTouchDevice *device,
+
+    // Wanted to use GMock, but MOCK_METHOD11 not implemented
+    void handleExtendedKeyEvent(QWindow */*window*/, ulong /*timestamp*/, QEvent::Type /*type*/, int /*key*/,
+            Qt::KeyboardModifiers /*modifiers*/,
+            quint32 /*nativeScanCode*/, quint32 /*nativeVirtualKey*/,
+            quint32 /*nativeModifiers*/,
+            const QString& /*text*/ = QString(), bool /*autorep*/ = false,
+            ushort /*count*/ = 1) {}
+
+    MOCK_METHOD5(handleTouchEvent, void(QWindow *window, ulong timestamp, QTouchDevice *device,
             const QList<struct QWindowSystemInterface::TouchPoint> &points,
             Qt::KeyboardModifiers mods));
     MOCK_METHOD4(handleMouseEvent, void(ulong, QPointF, Qt::MouseButtons, Qt::KeyboardModifiers));

=== modified file 'tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp'
--- tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2015-09-18 16:33:06 +0000
+++ tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2015-10-16 17:43:47 +0000
@@ -69,33 +69,44 @@
 
     MockQtWindowSystem *mockWindowSystem;
     QtEventFeeder *qtEventFeeder;
+    QWindow *window;
+    QGuiApplication *app;
 };
 
 void QtEventFeederTest::SetUp()
 {
     mockWindowSystem = new MockQtWindowSystem;
+    auto screens = QSharedPointer<ScreenController>();
 
     EXPECT_CALL(*mockWindowSystem, registerTouchDevice(_));
 
-    qtEventFeeder = new QtEventFeeder(mockWindowSystem);
+    qtEventFeeder = new QtEventFeeder(screens, mockWindowSystem);
 
     ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+
+    int argc = 0;
+    char **argv = nullptr;
+    setenv("QT_QPA_PLATFORM", "minimal", 1);
+    app = new QGuiApplication(argc, argv);
+    window = new QWindow;
 }
 
 void QtEventFeederTest::TearDown()
 {
     // mockWindowSystem will be deleted by QtEventFeeder
     delete qtEventFeeder;
+    delete window;
+    delete app;
 }
 
 void QtEventFeederTest::setIrrelevantMockWindowSystemExpectations()
 {
-    EXPECT_CALL(*mockWindowSystem, hasTargetWindow())
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(true));
-    EXPECT_CALL(*mockWindowSystem, targetWindowGeometry())
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(QRect(0,0,100,100)));
+    EXPECT_CALL(*mockWindowSystem, getWindowForTouchPoint(_))
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(window));
+    EXPECT_CALL(*mockWindowSystem, focusedWindow())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(window));
 }
 
 
@@ -113,7 +124,7 @@
 
     setIrrelevantMockWindowSystemExpectations();
 
-    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,_,AllOf(SizeIs(1),
                                                               Contains(AllOf(HasId(0),
                                                                              IsPressed()))),_)).Times(1);
 
@@ -132,12 +143,12 @@
         InSequence sequence;
 
         EXPECT_CALL(*mockWindowSystem,
-                    handleTouchEvent(_,_,AllOf(SizeIs(1),
+                    handleTouchEvent(_,_,_,AllOf(SizeIs(1),
                                                Contains(AllOf(HasId(0),IsReleased()))
                                                ),_)).Times(1);
 
         EXPECT_CALL(*mockWindowSystem,
-                    handleTouchEvent(_,_,AllOf(SizeIs(1),
+                    handleTouchEvent(_,_,_,AllOf(SizeIs(1),
                                                Contains(AllOf(HasId(1),IsPressed()))
                                                ),_)).Times(1);
     }
@@ -161,7 +172,7 @@
                    10, 10, 10 /* x, y, pressure*/,
                    1, 1, 10 /* touch major, minor, size */);
 
-    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,_,AllOf(SizeIs(1),
                                                               Contains(AllOf(HasId(0),
                                                                              IsPressed()))),_)).Times(1);
     qtEventFeeder->dispatch(*ev1);
@@ -181,7 +192,7 @@
                    1, 1, 10 /* touch major, minor, size */);
 
     EXPECT_CALL(*mockWindowSystem,
-        handleTouchEvent(_,_,AllOf(SizeIs(2),
+        handleTouchEvent(_,_,_,AllOf(SizeIs(2),
                                    Contains(AllOf(HasId(0), StateIsMoved())),
                                    Contains(AllOf(HasId(1), IsPressed()))
                                    ),_)).Times(1);
@@ -208,14 +219,14 @@
 
         // first release touch 0
         EXPECT_CALL(*mockWindowSystem,
-            handleTouchEvent(_,_,AllOf(SizeIs(2),
+            handleTouchEvent(_,_,_,AllOf(SizeIs(2),
                                        Contains(AllOf(HasId(0), IsReleased())),
                                        Contains(AllOf(HasId(1), IsStationary()))
                                        ),_)).Times(1);
 
         // then press touch 2
         EXPECT_CALL(*mockWindowSystem,
-            handleTouchEvent(_,_,AllOf(SizeIs(2),
+            handleTouchEvent(_,_,_,AllOf(SizeIs(2),
                                        Contains(AllOf(HasId(1), StateIsMoved())),
                                        Contains(AllOf(HasId(2), IsPressed()))
                                        ),_)).Times(1);
@@ -230,7 +241,7 @@
 {
     setIrrelevantMockWindowSystemExpectations();
 
-    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,_,AllOf(SizeIs(1),
                                                               Contains(AllOf(HasId(0),
                                                                              IsPressed()))),_)).Times(1);
 
@@ -243,7 +254,7 @@
 
     setIrrelevantMockWindowSystemExpectations();
 
-    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,_,AllOf(SizeIs(1),
                                                               Contains(AllOf(HasId(0), StateIsMoved()))
                                                              ),_)).Times(1);
 

=== modified file 'tests/mirserver/Screen/CMakeLists.txt'
--- tests/mirserver/Screen/CMakeLists.txt	2014-12-03 08:56:35 +0000
+++ tests/mirserver/Screen/CMakeLists.txt	2015-10-16 17:43:47 +0000
@@ -5,6 +5,7 @@
 )
 
 include_directories(
+  ${CMAKE_SOURCE_DIR}/tests/common
   ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
   ${CMAKE_SOURCE_DIR}/src/common
   ${Qt5Gui_PRIVATE_INCLUDE_DIRS}

=== modified file 'tests/mirserver/Screen/screen_test.cpp'
--- tests/mirserver/Screen/screen_test.cpp	2015-10-08 12:33:06 +0000
+++ tests/mirserver/Screen/screen_test.cpp	2015-10-16 17:43:47 +0000
@@ -18,39 +18,21 @@
 #include <gtest/gtest.h>
 
 #include "mir/graphics/display_configuration.h"
+#include "fake_displayconfigurationoutput.h"
 
 #include <screen.h>
 
+using namespace ::testing;
+
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 
-mg::DisplayConfigurationOutput const fake_output
-{
-    mg::DisplayConfigurationOutputId{3},
-    mg::DisplayConfigurationCardId{2},
-    mg::DisplayConfigurationOutputType::dvid,
-    {
-        mir_pixel_format_abgr_8888
-    },
-    {
-        {geom::Size{10, 20}, 60.0},
-        {geom::Size{10, 20}, 59.0},
-        {geom::Size{15, 20}, 59.0}
-    },
-    0,
-    geom::Size{10, 20},
-    true,
-    true,
-    geom::Point(),
-    2,
-    mir_pixel_format_abgr_8888,
-    mir_power_mode_on,
-    mir_orientation_normal,
-    1.0f,
-    mir_form_factor_unknown
+class ScreenTest : public ::testing::Test {
+protected:
+    void SetUp() override;
 };
 
-TEST(ScreenTest, OrientationSensor)
+void ScreenTest::SetUp()
 {
     if (!qEnvironmentVariableIsSet("QT_ACCEL_FILEPATH")) {
         // Trick Qt >= 5.4.1 to load the generic sensors
@@ -58,7 +40,11 @@
     }
 
     Screen::skipDBusRegistration = true;
-    Screen *screen = new Screen(fake_output);
+}
+
+TEST_F(ScreenTest, OrientationSensor)
+{
+    Screen *screen = new Screen(fakeOutput1);
 
     // Default state should be active
     ASSERT_TRUE(screen->orientationSensorEnabled());
@@ -69,3 +55,29 @@
     screen->onDisplayPowerStateChanged(1,0);
     ASSERT_TRUE(screen->orientationSensorEnabled());
 }
+
+TEST_F(ScreenTest, ReadConfigurationFromDisplayConfig)
+{
+    Screen *screen = new Screen(fakeOutput1);
+
+    EXPECT_EQ(screen->geometry(), QRect(0, 0, 150, 200));
+    EXPECT_EQ(screen->availableGeometry(), QRect(0, 0, 150, 200));
+    EXPECT_EQ(screen->depth(), 32);
+    EXPECT_EQ(screen->format(), QImage::Format_RGBA8888);
+    EXPECT_EQ(screen->refreshRate(), 59);
+    EXPECT_EQ(screen->physicalSize(), QSize(1111, 2222));
+    EXPECT_EQ(screen->outputType(), mg::DisplayConfigurationOutputType::dvid);
+}
+
+TEST_F(ScreenTest, ReadDifferentConfigurationFromDisplayConfig)
+{
+    Screen *screen = new Screen(fakeOutput2);
+
+    EXPECT_EQ(screen->geometry(), QRect(500, 600, 1500, 2000));
+    EXPECT_EQ(screen->availableGeometry(), QRect(500, 600, 1500, 2000));
+    EXPECT_EQ(screen->depth(), 32);
+    EXPECT_EQ(screen->format(), QImage::Format_RGBX8888);
+    EXPECT_EQ(screen->refreshRate(), 75);
+    EXPECT_EQ(screen->physicalSize(), QSize(1000, 2000));
+    EXPECT_EQ(screen->outputType(), mg::DisplayConfigurationOutputType::lvds);
+}

=== added directory 'tests/mirserver/ScreenController'
=== added file 'tests/mirserver/ScreenController/CMakeLists.txt'
--- tests/mirserver/ScreenController/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/mirserver/ScreenController/CMakeLists.txt	2015-10-16 17:43:47 +0000
@@ -0,0 +1,29 @@
+set(
+  SCREENCONTROLLER_TEST_SOURCES
+  screencontroller_test.cpp
+  ${CMAKE_SOURCE_DIR}/src/common/debughelpers.cpp
+  # to be moc-ed
+  stub_screen.h
+  testable_screencontroller.h
+)
+
+include_directories(
+  ${CMAKE_SOURCE_DIR}/tests/common
+  ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
+  ${CMAKE_SOURCE_DIR}/src/common
+  ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
+  ${MIRSERVER_INCLUDE_DIRS}
+  ${MIRRENDERERGLDEV_INCLUDE_DIRS}
+)
+
+add_executable(ScreenControllerTest ${SCREENCONTROLLER_TEST_SOURCES})
+
+target_link_libraries(
+  ScreenControllerTest
+  qpa-mirserver
+
+  ${GTEST_BOTH_LIBRARIES}
+  ${GMOCK_LIBRARIES}
+)
+
+add_test(ScreenController, ScreenControllerTest)

=== added file 'tests/mirserver/ScreenController/screencontroller_test.cpp'
--- tests/mirserver/ScreenController/screencontroller_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/mirserver/ScreenController/screencontroller_test.cpp	2015-10-16 17:43:47 +0000
@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2015 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 <gtest/gtest.h>
+#include "gmock_fixes.h"
+
+#include "stub_display.h"
+#include "mock_main_loop.h"
+#include "qtcompositor.h"
+#include "fake_displayconfigurationoutput.h"
+
+#include "testable_screencontroller.h"
+#include "screen.h"
+#include "screenwindow.h"
+
+#include <QGuiApplication>
+
+using namespace ::testing;
+
+namespace mg = mir::graphics;
+namespace geom = mir::geometry;
+
+class ScreenControllerTest : public ::testing::Test {
+protected:
+    void SetUp() override;
+    void TearDown() override;
+
+    ScreenController *screenController;
+    std::shared_ptr<StubDisplay> display;
+    std::shared_ptr<QtCompositor> compositor;
+    QGuiApplication *app;
+};
+
+void ScreenControllerTest::SetUp()
+{
+    setenv("QT_QPA_PLATFORM", "minimal", 1);
+    Screen::skipDBusRegistration = true;
+
+    screenController = new TestableScreenController;
+    display = std::make_shared<StubDisplay>();
+    compositor = std::make_shared<QtCompositor>();
+
+    static_cast<TestableScreenController*>(screenController)->do_init(display, compositor);
+
+    int argc = 0;
+    char **argv = nullptr;
+    setenv("QT_QPA_PLATFORM", "minimal", 1);
+    app = new QGuiApplication(argc, argv);
+}
+
+void ScreenControllerTest::TearDown()
+{
+    delete screenController;
+}
+
+TEST_F(ScreenControllerTest, SingleScreenFound)
+{
+    // Set up display state
+    std::vector<mg::DisplayConfigurationOutput> config{fakeOutput1};
+    std::vector<MockGLDisplayBuffer*> bufferConfig; // only used to match buffer with display, unecessary here
+    display->setFakeConfiguration(config, bufferConfig);
+
+    screenController->update();
+
+    ASSERT_EQ(1, screenController->screens().count());
+    Screen* screen = screenController->screens().first();
+    EXPECT_EQ(QRect(0, 0, 150, 200), screen->geometry());
+}
+
+TEST_F(ScreenControllerTest, MultipleScreenFound)
+{
+    std::vector<mg::DisplayConfigurationOutput> config{fakeOutput1, fakeOutput2};
+    std::vector<MockGLDisplayBuffer*> bufferConfig; // only used to match buffer with display, unecessary here
+    display->setFakeConfiguration(config, bufferConfig);
+
+    screenController->update();
+
+    ASSERT_EQ(2, screenController->screens().count());
+    EXPECT_EQ(QRect(0, 0, 150, 200), screenController->screens().at(0)->geometry());
+    EXPECT_EQ(QRect(500, 600, 1500, 2000), screenController->screens().at(1)->geometry());
+}
+
+TEST_F(ScreenControllerTest, ScreenAdded)
+{
+    std::vector<mg::DisplayConfigurationOutput> config{fakeOutput1};
+    std::vector<MockGLDisplayBuffer*> bufferConfig; // only used to match buffer with display, unecessary here
+    display->setFakeConfiguration(config, bufferConfig);
+
+    screenController->update();
+
+    config.push_back(fakeOutput2);
+    display->setFakeConfiguration(config, bufferConfig);
+
+    ASSERT_EQ(1, screenController->screens().count());
+    EXPECT_EQ(QRect(0, 0, 150, 200), screenController->screens().at(0)->geometry());
+
+    screenController->update();
+
+    ASSERT_EQ(2, screenController->screens().count());
+    EXPECT_EQ(QRect(0, 0, 150, 200), screenController->screens().at(0)->geometry());
+    EXPECT_EQ(QRect(500, 600, 1500, 2000), screenController->screens().at(1)->geometry());
+}
+
+TEST_F(ScreenControllerTest, ScreenRemoved)
+{
+    std::vector<mg::DisplayConfigurationOutput> config{fakeOutput2, fakeOutput1};
+    std::vector<MockGLDisplayBuffer*> bufferConfig; // only used to match buffer with display, unecessary here
+    display->setFakeConfiguration(config, bufferConfig);
+
+    screenController->update();
+
+    config.pop_back();
+    display->setFakeConfiguration(config, bufferConfig);
+
+    ASSERT_EQ(2, screenController->screens().count());
+    EXPECT_EQ(QRect(500, 600, 1500, 2000), screenController->screens().at(0)->geometry());
+    EXPECT_EQ(QRect(0, 0, 150, 200), screenController->screens().at(1)->geometry());
+
+    screenController->update();
+
+    ASSERT_EQ(1, screenController->screens().count());
+    EXPECT_EQ(QRect(500, 600, 1500, 2000), screenController->screens().at(0)->geometry());
+}
+
+TEST_F(ScreenControllerTest, MatchBufferWithDisplay)
+{
+    std::vector<mg::DisplayConfigurationOutput> config{fakeOutput1};
+    MockGLDisplayBuffer buffer1;
+    std::vector<MockGLDisplayBuffer*> buffers {&buffer1};
+
+    geom::Rectangle buffer1Geom{{0, 0}, {150, 200}};
+    EXPECT_CALL(buffer1, view_area())
+            .WillRepeatedly(Return(buffer1Geom));
+
+    display->setFakeConfiguration(config, buffers);
+    screenController->update();
+
+    ASSERT_EQ(1, screenController->screens().count());
+    EXPECT_CALL(buffer1, make_current());
+    static_cast<StubScreen*>(screenController->screens().at(0))->makeCurrent();
+}
+
+TEST_F(ScreenControllerTest, MultipleMatchBuffersWithDisplays)
+{
+    std::vector<mg::DisplayConfigurationOutput> config{fakeOutput1, fakeOutput2};
+    MockGLDisplayBuffer buffer1, buffer2;
+    std::vector<MockGLDisplayBuffer*> buffers {&buffer1, &buffer2};
+
+    geom::Rectangle buffer1Geom{{500, 600}, {1500, 2000}};
+    geom::Rectangle buffer2Geom{{0, 0}, {150, 200}};
+    EXPECT_CALL(buffer1, view_area())
+            .WillRepeatedly(Return(buffer1Geom));
+    EXPECT_CALL(buffer2, view_area())
+            .WillRepeatedly(Return(buffer2Geom));
+
+    display->setFakeConfiguration(config, buffers);
+    screenController->update();
+
+    ASSERT_EQ(2, screenController->screens().count());
+    EXPECT_CALL(buffer1, make_current());
+    EXPECT_CALL(buffer2, make_current());
+    static_cast<StubScreen*>(screenController->screens().at(0))->makeCurrent();
+    static_cast<StubScreen*>(screenController->screens().at(1))->makeCurrent();
+}

=== added file 'tests/mirserver/ScreenController/stub_display.h'
--- tests/mirserver/ScreenController/stub_display.h	1970-01-01 00:00:00 +0000
+++ tests/mirserver/ScreenController/stub_display.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2015 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 STUB_DISPLAY_H
+#define STUB_DISPLAY_H
+
+#include "mock_display.h"
+#include "mock_gl_display_buffer.h"
+#include "mock_display_configuration.h"
+
+namespace mg = mir::graphics;
+namespace geom = mir::geometry;
+
+class StubDisplayConfiguration : public MockDisplayConfiguration
+{
+public:
+    StubDisplayConfiguration(const std::vector<mg::DisplayConfigurationOutput> &config)
+        : m_config(config)
+    {}
+
+    void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const override
+    {
+        for (auto config : m_config) {
+            f(config);
+        }
+    }
+
+private:
+    const std::vector<mg::DisplayConfigurationOutput> m_config;
+};
+
+
+class StubDisplaySyncGroup : public MockDisplaySyncGroup
+{
+public:
+    StubDisplaySyncGroup(MockGLDisplayBuffer *buffer) : buffer(buffer) {}
+
+    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
+    {
+        f(*buffer);
+    }
+    std::chrono::milliseconds recommended_sleep() const
+    {
+        std::chrono::milliseconds one{1};
+        return one;
+    }
+private:
+    MockGLDisplayBuffer *buffer;
+};
+
+
+class StubDisplay : public MockDisplay
+{
+public:
+    // Note, GMock cannot mock functions which return non-copyable objects, so stubbing needed
+    std::unique_ptr<mg::DisplayConfiguration> configuration() const override
+    {
+        return std::unique_ptr<mg::DisplayConfiguration>(
+            new StubDisplayConfiguration(m_config)
+        );
+    }
+
+    void for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f) override
+    {
+        for (auto displayBuffer : m_displayBuffers) {
+            StubDisplaySyncGroup b(displayBuffer);
+            f(b);
+        }
+    }
+
+    void setFakeConfiguration(std::vector<mg::DisplayConfigurationOutput> &config,
+                              std::vector<MockGLDisplayBuffer*> &displayBuffers)
+    {
+        m_config = config;
+        m_displayBuffers = displayBuffers;
+    }
+
+private:
+    std::vector<mg::DisplayConfigurationOutput> m_config;
+    std::vector<MockGLDisplayBuffer*> m_displayBuffers;
+};
+
+#endif // STUB_DISPLAY_H

=== added file 'tests/mirserver/ScreenController/stub_screen.h'
--- tests/mirserver/ScreenController/stub_screen.h	1970-01-01 00:00:00 +0000
+++ tests/mirserver/ScreenController/stub_screen.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2015 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 STUBSCREEN_H
+#define STUBSCREEN_H
+
+#include "screen.h"
+
+class StubScreen : public Screen
+{
+    Q_OBJECT
+public:
+    StubScreen(const mir::graphics::DisplayConfigurationOutput &output) : Screen(output) {}
+
+    void makeCurrent() { Screen::makeCurrent(); }
+};
+
+#endif // STUBSCREEN_H

=== added file 'tests/mirserver/ScreenController/testable_screencontroller.h'
--- tests/mirserver/ScreenController/testable_screencontroller.h	1970-01-01 00:00:00 +0000
+++ tests/mirserver/ScreenController/testable_screencontroller.h	2015-10-16 17:43:47 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2015 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 "screencontroller.h"
+#include "stub_screen.h"
+
+struct TestableScreenController : public ScreenController
+{
+    Q_OBJECT
+
+public:
+    Screen *createScreen(const mir::graphics::DisplayConfigurationOutput &output) const override
+    {
+        return new StubScreen(output);
+    }
+
+    void do_init(const std::shared_ptr<mir::graphics::Display> &display,
+              const std::shared_ptr<mir::compositor::Compositor> &compositor)
+    {
+        init(display, compositor);
+    }
+
+    void do_terminate() { terminate(); }
+};

=== modified file 'tests/modules/common/fake_mirsurface.h'
--- tests/modules/common/fake_mirsurface.h	2015-09-25 17:30:26 +0000
+++ tests/modules/common/fake_mirsurface.h	2015-10-16 17:43:47 +0000
@@ -130,10 +130,12 @@
         }
     }
 
+    void consumeBuffer() override {}
+
     // methods called from the rendering (scene graph) thread:
     QSharedPointer<QSGTexture> texture() override { return QSharedPointer<QSGTexture>(); }
     QSGTexture *weakTexture() const override { return nullptr; }
-    void updateTexture() override {}
+    bool updateTexture() override { return true; }
     unsigned int currentFrameNumber() const override { return 0; }
     bool numBuffersReadyForCompositor() override { return 0; }
     // end of methods called from the rendering (scene graph) thread

=== modified file 'tests/modules/common/qtmir_test.h'
--- tests/modules/common/qtmir_test.h	2015-08-11 12:08:32 +0000
+++ tests/modules/common/qtmir_test.h	2015-10-16 17:43:47 +0000
@@ -78,7 +78,7 @@
 {
 public:
     FakeMirServer()
-    : MirServer(0, argv)
+    : MirServer(0, argv, QSharedPointer<ScreenController>())
     {
     }