Merge lp:~lukas-kde/qtmir/wheelEvent into lp:qtmir

[Lukáš Tinkl]

Implement support for mouse wheel events; correctly pass around buttons

Implement support for mouse wheel events; also correctly pass around buttons

Cf. https://bugs.launchpad.net/ubuntu/+source/qtmir/+bug/1497091

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

https://code.launchpad.net/~lukas-kde/qtubuntu/wheelEvent/+merge/273149

* Did you perform an exploratory manual test run of your code change and any related functionality?

Yes

* Did you make sure that your branch does not contain spurious tags?

Yes

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

Yes

* If you changed the UI, has there been a design review?

N/A

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:383
http://jenkins.qa.ubuntu.com/job/qtmir-ci/475/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/171
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/171
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/171/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/53
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/208
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/208
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/208/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/53

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

review: Approve (continuous-integration)

[Daniel d'Andrada (dandrader)]

"""
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=8)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application>=8)
"""

The unity-api versioning scheme is made so that qtmir and unity8 depend on a *specific* version of the API. That's meant solely ensure that qtmir and unity8 are kept in sync. There's absolutely no guarantee (or effort to towards it) that a given version is backward or forward compatible.

review: Needs Fixing

[lp:~lukas-kde/qtmir/wheelEvent]

384. By Lukáš Tinkl on 2015-10-07

require strict unity-api dep

remove noisy debug

[Lukáš Tinkl (lukas-kde)]

> """
> -pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=8)
> +pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application>=8)
> """
>
> The unity-api versioning scheme is made so that qtmir and unity8 depend on a
> *specific* version of the API. That's meant solely ensure that qtmir and
> unity8 are kept in sync. There's absolutely no guarantee (or effort to towards
> it) that a given version is backward or forward compatible.

Got it, fixed

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:384
http://jenkins.qa.ubuntu.com/job/qtmir-ci/482/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/178
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/178
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/178/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/60
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/215
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/215
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/215/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/60

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

review: Approve (continuous-integration)

[Daniel d'Andrada (dandrader)]

Could you please move "getMirButtonsFromQt(qtEvent->buttons())" into a separate variable like it's being done for timestamp and modifiers?

The mir::events::make_event() call is already messy from having such a large number of parameters. Using those helper variables improve readability and I think won't impact performance as I bet they will be optimized away by the compiler.

[lp:~lukas-kde/qtmir/wheelEvent]

385. By Lukáš Tinkl on 2015-10-07

extract the buttons into a variable

[Lukáš Tinkl (lukas-kde)]

> Could you please move "getMirButtonsFromQt(qtEvent->buttons())" into a
> separate variable like it's being done for timestamp and modifiers?
>
> The mir::events::make_event() call is already messy from having such a large
> number of parameters. Using those helper variables improve readability and I
> think won't impact performance as I bet they will be optimized away by the
> compiler.

Done

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:385
http://jenkins.qa.ubuntu.com/job/qtmir-ci/485/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/181
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/181
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/181/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/63
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/218
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/218
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/218/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/63

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

review: Approve (continuous-integration)

[Daniel d'Andrada (dandrader)]

the handleWheelEvent() line in qteventfeeder.h is way too long. Please avoid going beyond 120 chars. It's our coding style (which, by the way, I couldn't find it right now).

That's the last nitpick I have with this MP. :)

[lp:~lukas-kde/qtmir/wheelEvent]

386. By Lukáš Tinkl on 2015-10-08

wrap too long lines

[Lukáš Tinkl (lukas-kde)]

> the handleWheelEvent() line in qteventfeeder.h is way too long. Please avoid
> going beyond 120 chars. It's our coding style (which, by the way, I couldn't
> find it right now).
>
> That's the last nitpick I have with this MP. :)

Fixed

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:386
http://jenkins.qa.ubuntu.com/job/qtmir-ci/486/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/182
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/182
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/182/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/64
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/219
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/219
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/219/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/64

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

review: Approve (continuous-integration)

[Daniel d'Andrada (dandrader)]

> > the handleWheelEvent() line in qteventfeeder.h is way too long. Please avoid
> > going beyond 120 chars. It's our coding style (which, by the way, I couldn't
> > find it right now).
> >
> > That's the last nitpick I have with this MP. :)
>
> Fixed

Thanks!

review: Approve

[lp:~lukas-kde/qtmir/wheelEvent]

387. By Lukáš Tinkl on 2015-10-13

[ CI Train Bot ]
* New rebuild forced.
[ Daniel d'Andrada ]
* MirSurfaceItem: texture must be manipulated only from the scene
  graph thread (LP: #1499388, #1495871)
[ Gerry Boland ]
* Add "Closing" state to Application, use it to distinguish user-
  induced close from app-induced close. Don't clear QML cache if user-
  induced. (LP: #1500372)

388. By Lukáš Tinkl on 2015-10-13

make the cursor work

389. By Lukáš Tinkl on 2015-10-14

merge lp:~unity-team/qtmir/touch_tracing

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-09-17 20:17:17 +0000
+++ CMakeLists.txt	2015-10-13 19:42:45 +0000
@@ -75,7 +75,7 @@
 pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
 pkg_check_modules(QTDBUSTEST libqtdbustest-1 REQUIRED)
 pkg_check_modules(QTDBUSMOCK libqtdbusmock-1 REQUIRED)
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=8)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=9)
 
 include_directories(${APPLICATION_API_INCLUDE_DIRS})
 
@@ -120,6 +120,7 @@
 
 # Set QML module install path
 set(QML_MODULE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/qt5/qml")
+set(QTMIR_DATA_DIR ${CMAKE_INSTALL_DATADIR}/qtmir)
 
 
 # Customisations for the build type
@@ -156,6 +157,7 @@
     message(STATUS "Tests disabled")
 endif()
 
-
 # add subdirectories to build
 add_subdirectory(src)
+add_subdirectory(demos)
+add_subdirectory(benchmarks)

=== added directory 'benchmarks'
=== added file 'benchmarks/CMakeLists.txt'
--- benchmarks/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ benchmarks/CMakeLists.txt	2015-10-13 19:42:45 +0000
@@ -0,0 +1,8 @@
+file(GLOB BENCHMARK_FILES
+	*.py
+	*.R
+)
+
+install(FILES ${BENCHMARK_FILES}
+    DESTINATION ${QTMIR_DATA_DIR}/benchmarks
+)

=== added file 'benchmarks/README'
--- benchmarks/README	1970-01-01 00:00:00 +0000
+++ benchmarks/README	2015-10-13 19:42:45 +0000
@@ -0,0 +1,12 @@
+To run performance tests on device:
+
+Firstly, you will need to install the qtmir-tests package. So either install the package using apt or build
+and install from source
+$ sudo apt-get install qtmir-tests
+
+Then you need to stop unity8 & unity-system compositor so that we can start out test in a controlled environment.
+$ sudo stop lightdm
+
+Next, start the test!
+$ cd benchmarks
+$ sudo python3 touch_event_latency.py
\ No newline at end of file

=== added file 'benchmarks/common.py'
--- benchmarks/common.py	1970-01-01 00:00:00 +0000
+++ benchmarks/common.py	2015-10-13 19:42:45 +0000
@@ -0,0 +1,33 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# 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 as published by
+# the Free Software Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY 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/>.
+
+from autopilot import (
+    input,
+    platform
+)
+
+def get_pointing_device():
+    """Return the pointing device depending on the platform.
+
+    If the platform is `Desktop`, the pointing device will be a `Mouse`.
+    If not, the pointing device will be `Touch`.
+
+    """
+    if platform.model() == 'Desktop':
+        input_device_class = input.Mouse
+    else:
+        input_device_class = input.Touch
+    return input.Pointer(device=input_device_class.create())
\ No newline at end of file

=== added file 'benchmarks/report_types.py'
--- benchmarks/report_types.py	1970-01-01 00:00:00 +0000
+++ benchmarks/report_types.py	2015-10-13 19:42:45 +0000
@@ -0,0 +1,121 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# 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 as published by
+# the Free Software Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY 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/>.
+
+import subprocess
+import os
+import shutil
+
+class Node:
+    def __init__(self, name):
+        self.name = name
+        self.children = []
+    
+    def add_child(self, child):
+        self.children.append(child)
+
+    def to_string(self):
+        output = "<%s>" % self.name
+        for child in self.children:
+            output += child.to_string()
+        output += "</%s>" % self.name
+        return output
+
+class Results(Node):
+    def __init__(self):
+        super().__init__("results")
+
+class Events(Node):
+    def __init__(self):
+        super().__init__("events")
+
+class Event:
+    def __init__(self, event):
+        self.pid = event["vpid"]
+        self.name = event.name
+        self.timestamp = event.timestamp
+
+    def to_string(self):
+        output = "<event "
+        output += "pid='{}' ".format(self.pid)
+        output += "name='{}' ".format(self.name)
+        output += "timestamp='{}' ".format(self.timestamp)
+        output += "/>"
+        return output
+
+class Processes(Node):
+    def __init__(self):
+        super().__init__("processes")
+
+class Process:
+    def __init__(self, name, pid):
+        self.name = name
+        self.pid = pid
+
+    def to_string(self):
+        output = "<process "
+        output += "name='{}' ".format(self.name)
+        output += "pid='{}' ".format(self.pid)
+        output += "/>"
+        return output
+
+class ResultsData:
+    def __init__(self, name, mean=0.0, deviation=0.0, comment=""):
+        self.data = []
+        self.name = name
+        self.mean = mean
+        self.deviation = deviation
+        self.comment = comment
+
+    def add_data(self, value):
+        self.data.append(value)
+
+    def to_string(self):
+        output = "<data name='{}' mean='{}' deviation='{}' comment='{}' count='{}'>".format(
+            self.name,
+            self.mean,
+            self.deviation, 
+            self.comment, 
+            len(self.data))
+        output += "<values>"
+        output += ",".join(map( lambda x: str(x), self.data))
+        output += "</values>"
+        output += "</data>"
+        return output;
+
+    def generate_histogram(self, filename):
+        cmdline = [
+            shutil.which("Rscript"),
+            os.path.split(os.path.abspath(__file__))[0] + "/touch_event_latency.R",
+            "data.csv",
+            "%s.png" % filename]
+        # Use R to generate a histogram plot
+        f = open("data.csv", "w")
+        f.write(",".join(map( lambda x: str(x), self.data)));
+        f.close()
+        process = subprocess.Popen(cmdline)
+        process.wait()
+        if process.returncode != 0:
+            print("Failed to generate histogram");
+        os.remove("data.csv")
+
+
+class Error:    
+    def __init__(self, comment):
+        self.comment = comment
+
+    def to_string(self):
+        return "<error comment='{}' />".format(self.comment)
+        return output
\ No newline at end of file

=== added file 'benchmarks/touch_event_latency.R'
--- benchmarks/touch_event_latency.R	1970-01-01 00:00:00 +0000
+++ benchmarks/touch_event_latency.R	2015-10-13 19:42:45 +0000
@@ -0,0 +1,6 @@
+args <- commandArgs(trailingOnly = TRUE)
+data <- scan(args[1], numeric(), sep=",")
+colors = c("red", "yellow", "green", "violet", "orange", "pink", "blue")
+png(filename=args[2])
+hist(data, breaks=max(data), col=colors)
+dev.off()

=== added file 'benchmarks/touch_event_latency.py'
--- benchmarks/touch_event_latency.py	1970-01-01 00:00:00 +0000
+++ benchmarks/touch_event_latency.py	2015-10-13 19:42:45 +0000
@@ -0,0 +1,271 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# 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 as published by
+# the Free Software Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY 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/>.
+
+from mir_perf_framework import PerformanceTest, Server, Client
+import time
+import statistics
+import shutil
+import sys
+from common import get_pointing_device
+import report_types
+
+####### TEST #######
+
+
+def perform_test():
+    host = Server(reports=["input"])
+    nested = Server(executable=shutil.which("qtmir-demo-shell"),
+                    host=host,
+                    reports=["input","client-input-receiver"],
+                    env={"QT_QPA_PLATFORM": "mirserver", "QML_NO_TOUCH_COMPRESSION": "1"})
+    client = Client(executable=shutil.which("qtmir-demo-client"),
+                    server=nested,
+                    reports=["input","client-input-receiver"],
+                    env={"QT_QPA_PLATFORM": "ubuntumirclient", "QML_NO_TOUCH_COMPRESSION": "1"},
+                    options=["--", "--desktop_file_hint=/usr/share/applications/qtmir-demo-client.desktop"])
+
+    test = PerformanceTest([host, nested, client])
+    test.start()
+
+    results = report_types.Results()
+    processes = report_types.Processes()
+    processes.add_child(report_types.Process("Host", host.process.pid))
+    processes.add_child(report_types.Process("Nested Server", nested.process.pid))
+    processes.add_child(report_types.Process("Client", client.process.pid))
+    results.add_child(processes)
+
+    time.sleep(3) # wait for settle
+
+    host_pid = host.process.pid
+    nested_pid = nested.process.pid
+    client_pid = client.process.pid
+
+    touch = get_pointing_device()
+    time.sleep(1) # let mir pick up the new input device
+    touch.drag(100, 100, 1000, 100, 5, 0.006)
+    touch.drag(1000, 100, 1000, 1000, 5, 0.006)
+    touch.drag(1000, 1000, 100, 1000, 5, 0.006)
+    touch.drag(100, 1000, 100, 100, 5, 0.006)
+
+    # time.sleep(5) # wait for settle
+    time.sleep(2) # wait for settle
+    test.stop()
+
+    ####### TRACE PARSING #######
+
+    trace = test.babeltrace()
+
+    server_touch_data_timestamps = {}
+    client_touch_data_timestamps = {}
+    client_touch_data_latency = {}
+
+    qtmir_touch_dispatch_start = {}
+    qtmir_touch_dispatch_end = {}
+    qtmir_touch_consume_start = {}
+    qtmir_touch_consume_end = {}
+
+    events = report_types.Events()
+
+    for event in trace.events:
+        events.add_child(report_types.Event(event))
+        pid = event["vpid"]
+        if event.name == "mir_client_input_receiver:touch_event":
+            if pid not in client_touch_data_timestamps: client_touch_data_timestamps[pid] = []
+            if pid not in client_touch_data_latency: client_touch_data_latency[pid] = []
+            diff = (event.timestamp - event["event_time"]) / 1000000.0
+            if diff > 0:
+                client_touch_data_timestamps[pid].append(event.timestamp)
+                client_touch_data_latency[pid].append(diff)
+
+        elif event.name == "mir_server_input:published_motion_event":
+            if pid not in server_touch_data_timestamps: server_touch_data_timestamps[pid] = []
+            server_touch_data_timestamps[pid].append(event["event_time"])
+
+        elif event.name == "qtmirserver:touchEventDispatch_start":
+            if pid not in qtmir_touch_dispatch_start: qtmir_touch_dispatch_start[pid] = []
+            qtmir_touch_dispatch_start[pid].append(event.timestamp)
+
+        elif event.name == "qtmirserver:touchEventDispatch_end":
+            if pid not in qtmir_touch_dispatch_end: qtmir_touch_dispatch_end[pid] = []
+            qtmir_touch_dispatch_end[pid].append(event.timestamp)
+
+        elif event.name == "qtmir:touchEventConsume_start":
+            if pid not in qtmir_touch_consume_start: qtmir_touch_consume_start[pid] = []
+            qtmir_touch_consume_start[pid].append(event.timestamp)
+
+        elif event.name == "qtmir:touchEventConsume_end":
+            if pid not in qtmir_touch_consume_end: qtmir_touch_consume_end[pid] = []
+            qtmir_touch_consume_end[pid].append(event.timestamp)
+
+    # LATENCY MEANS
+
+    if nested_pid in client_touch_data_latency:
+        nested_data = client_touch_data_latency[nested_pid]
+        nested_latency_xml = report_types.ResultsData(
+            "nested_latency",
+            statistics.mean(nested_data),
+            statistics.stdev(nested_data),
+            "Kernel to nested server latency")
+        for value in nested_data:
+            nested_latency_xml.add_data(value)
+        results.add_child(nested_latency_xml)
+        nested_latency_xml.generate_histogram("nested_latency")
+    else:
+        results.add_child(report_types.Error("No nested server touch latency data"))
+
+    if client_pid in client_touch_data_latency:
+        client_data = client_touch_data_latency[client_pid]
+
+        client_latency_xml = report_types.ResultsData(
+            "client_latency",
+            statistics.mean(client_data),
+            statistics.stdev(client_data),
+            "Kernel to client latency")
+        for value in client_data:
+            client_latency_xml.add_data(value)
+        results.add_child(client_latency_xml)
+        client_latency_xml.generate_histogram("client_latency")
+    else:
+        results.add_child(report_types.Error("No client touch latency data"))
+
+    # EVENT RATES
+    if host_pid in server_touch_data_timestamps:
+        last_timestamp = -1
+        input_rate = []
+
+        for next_timestamp in server_touch_data_timestamps[host_pid]:
+            if last_timestamp != -1:
+                diff = (next_timestamp - last_timestamp) / 1000000.0
+                input_rate.append(diff)
+            last_timestamp = next_timestamp
+
+        input_rate_xml = report_types.ResultsData(
+            "host_input_ate",
+            statistics.mean(input_rate),
+            statistics.stdev(input_rate),
+            "Host input event rate")
+        for value in input_rate:
+            input_rate_xml.add_data(value)
+        results.add_child(input_rate_xml)
+        input_rate_xml.generate_histogram("host_input_rate")
+    else:
+        results.add_child(report_types.Error("No host server input event timestamp data"))
+
+    if nested_pid in client_touch_data_timestamps:
+        last_timestamp = -1
+        input_rate = []
+        for next_timestamp in client_touch_data_timestamps[nested_pid]:
+            if last_timestamp != -1:
+                diff = (next_timestamp - last_timestamp) / 1000000.0
+                input_rate.append(diff)
+            last_timestamp = next_timestamp
+
+        input_rate_xml = report_types.ResultsData(
+            "nested_input_rate",
+            statistics.mean(input_rate),
+            statistics.stdev(input_rate),
+            "Nested server event rate")
+        for value in input_rate:
+            input_rate_xml.add_data(value)
+        results.add_child(input_rate_xml)
+        input_rate_xml.generate_histogram("nested_input_rate")
+    else:
+        results.add_child(report_types.Error("No nested server input event timestamp data"))
+
+    if client_pid in client_touch_data_timestamps:
+        last_timestamp = -1
+        input_rate = []
+        for next_timestamp in client_touch_data_timestamps[client_pid]:
+            if last_timestamp != -1:
+                diff = (next_timestamp - last_timestamp) / 1000000.0
+                input_rate.append(diff)
+            last_timestamp = next_timestamp
+
+        input_rate_xml = report_types.ResultsData(
+            "client_input_rate",
+            statistics.mean(input_rate),
+            statistics.stdev(input_rate),
+            "Client event rate")
+        for value in input_rate:
+            input_rate_xml.add_data(value)
+        results.add_child(input_rate_xml)
+        input_rate_xml.generate_histogram("client_input_rate")
+    else:
+        results.add_child(report_types.Error("No client event timestamp data"))
+
+    qtmir_loop_data = []
+    dispatch_data = []
+    consume_data = []
+
+    # TIME BETWEEN TRACEPOINTS
+    dispatch_starts = qtmir_touch_dispatch_start[nested_pid] if nested_pid in qtmir_touch_dispatch_start else []
+    dispatch_ends = qtmir_touch_dispatch_end[nested_pid] if nested_pid in qtmir_touch_dispatch_end else []
+    consume_starts = qtmir_touch_consume_start[nested_pid] if nested_pid in qtmir_touch_consume_start else []
+    consume_ends = qtmir_touch_consume_end[nested_pid] if nested_pid in qtmir_touch_consume_end else []
+
+    # since there's no uniqueness to events, we need to assume all events are 1:1 through system
+    if len(dispatch_starts) > 0 and len(dispatch_starts) == len(dispatch_ends) and len(dispatch_starts) == len(consume_starts) and len(consume_starts) == len(consume_ends):
+        i = 0
+
+        for start in dispatch_starts:
+            dispatch_diff = (dispatch_ends[i] - start) / 1000000.0
+            consume_diff = (consume_ends[i] - consume_starts[i]) / 1000000.0
+            loop_dif = (consume_starts[i] - dispatch_ends[i]) / 1000000.0
+            dispatch_data.append(dispatch_diff);
+            consume_data.append(consume_diff);
+            qtmir_loop_data.append(loop_dif);
+            i=i+1
+
+        qtmir_loop_xml = report_types.ResultsData(
+            "qtmir_eventloop",
+            statistics.mean(qtmir_loop_data),
+            statistics.stdev(qtmir_loop_data),
+            "Time spent in qtmir event loop")
+        for value in qtmir_loop_data:
+            qtmir_loop_xml.add_data(value)
+        results.add_child(qtmir_loop_xml)
+        qtmir_loop_xml.generate_histogram("qtmir_eventloop")
+
+        qtmir_dispatch_xml = report_types.ResultsData(
+            "qtmir_dispatch",
+            statistics.mean(dispatch_data),
+            statistics.stdev(dispatch_data),
+            "Time QteventFeeder spent dispatching event to qt")
+        for value in dispatch_data:
+            qtmir_dispatch_xml.add_data(value)
+        results.add_child(qtmir_dispatch_xml)
+        qtmir_dispatch_xml.generate_histogram("qtmir_dispatch")
+
+        qtmir_consume_xml = report_types.ResultsData(
+            "qtmir_consume",
+            statistics.mean(consume_data),
+            statistics.stdev(consume_data),
+            "Time MirSurfaceItem spent consiming event")
+        for value in consume_data:
+            qtmir_consume_xml.add_data(value)
+        results.add_child(qtmir_consume_xml)
+        qtmir_consume_xml.generate_histogram("qtmir_consume")
+
+    else:
+        results.add_child(report_types.Error("Cannot calculate QtMir loop data - Dispatch event count did not match surface consume event count"))
+
+    results.add_child(events)
+    return results
+
+if __name__ == "__main__":
+    results = perform_test();
+    f = open("touch_event_latency.xml", "w")
+    f.write(results.to_string())

=== modified file 'debian/control'
--- debian/control	2015-09-25 12:11:08 +0000
+++ debian/control	2015-10-13 19:42:45 +0000
@@ -23,7 +23,7 @@
                libubuntu-app-launch2-dev,
                libubuntu-application-api-dev (>= 2.1.0),
                libudev-dev,
-               libunity-api-dev (>= 7.100),
+               libunity-api-dev (>= 7.101),
                liburl-dispatcher1-dev,
                libxkbcommon-dev,
                libxrender-dev,
@@ -93,8 +93,28 @@
 Conflicts: libqtmir,
            libunity-mir1,
 Provides: unity-application-impl,
-          unity-application-impl-8,
+          unity-application-impl-9,
 Description: Qt plugin for Unity specific Mir APIs
  QtMir provides Qt/QML bindings for Mir features that are exposed through the
  qtmir-desktop or qtmir-android QPA plugin such as Application management
  (start/stop/suspend/resume) and surface management.
+
+Package: qtmir-tests
+Architecture: any
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends},
+Depends: autopilot-qt5,
+         littler,
+         lttng-tools,
+         mir-test-tools,
+         python3-autopilot,
+         python3-babeltrace,
+         python3-evdev,
+         python3-mir-perf-framework,
+         qtmir-desktop (= ${source:Version}) | qtmir-android (= ${source:Version}),
+         qtdeclarative5-qtmir-plugin,
+         ${misc:Depends},
+         ${shlibs:Depends},
+Description: QtMir tests and demos
+ This package provides benchmark tests and a simple shell and client using the
+ QtMir QPA.

=== added file 'debian/qtmir-tests.install'
--- debian/qtmir-tests.install	1970-01-01 00:00:00 +0000
+++ debian/qtmir-tests.install	2015-10-13 19:42:45 +0000
@@ -0,0 +1,6 @@
+usr/bin/qtmir-demo-shell
+usr/bin/qtmir-demo-client
+usr/share/applications/qtmir-demo-client.desktop
+usr/share/qtmir/qtmir-demo-shell/
+usr/share/qtmir/qtmir-demo-client/*
+usr/share/qtmir/benchmarks/*

=== modified file 'debian/rules'
--- debian/rules	2015-07-08 16:54:24 +0000
+++ debian/rules	2015-10-13 19:42:45 +0000
@@ -28,11 +28,11 @@
 
 override_dh_auto_configure:
 ifeq ($(DEB_HOST_ARCH),$(USES_GLES2))
-	mkdir -p $(ANDROID_DIR) && dh_auto_configure -B$(ANDROID_DIR) -- $(FLAGS) $(CURDIR) -DCMAKE_INSTALL_PREFIX=$(TMP1_DIR)/usr/ -DUSE_OPENGLES=1
+	mkdir -p $(ANDROID_DIR) && dh_auto_configure -B$(ANDROID_DIR) -- $(FLAGS) $(CURDIR) -DUSE_OPENGLES=1
 # See comment in CMakeLists.txt
-	mkdir -p $(DESKTOP_DIR) && dh_auto_configure -B$(DESKTOP_DIR) -- $(FLAGS) $(CURDIR) -DCMAKE_INSTALL_PREFIX=$(TMP2_DIR)/usr/ -DUSE_OPENGL_BUT_LINK_AGAINST_OPENGLES=1
+	mkdir -p $(DESKTOP_DIR) && dh_auto_configure -B$(DESKTOP_DIR) -- $(FLAGS) $(CURDIR) -DUSE_OPENGL_BUT_LINK_AGAINST_OPENGLES=1
 else
-	mkdir -p $(DESKTOP_DIR) && dh_auto_configure -B$(DESKTOP_DIR) -- $(FLAGS) $(CURDIR) -DCMAKE_INSTALL_PREFIX=$(TMP2_DIR)/usr/ -DUSE_OPENGLES=1
+	mkdir -p $(DESKTOP_DIR) && dh_auto_configure -B$(DESKTOP_DIR) -- $(FLAGS) $(CURDIR) -DUSE_OPENGLES=1
 endif
 
 override_dh_auto_build:
@@ -49,11 +49,9 @@
 
 override_dh_auto_install:
 ifeq ($(DEB_HOST_ARCH),$(USES_GLES2))
-	mkdir -p $(TMP1_DIR) && cd $(ANDROID_DIR) && INSTALL_ROOT=$(TMP1_DIR) make install
-	cd $(CURDIR)
+	dh_auto_install -B$(ANDROID_DIR) --destdir=$(TMP1_DIR)
 endif
-	mkdir -p $(TMP2_DIR) && cd $(DESKTOP_DIR) && INSTALL_ROOT=$(TMP2_DIR) make install
-	cd $(CURDIR)
+	dh_auto_install -B$(DESKTOP_DIR) --destdir=$(TMP2_DIR)
 
 override_dh_install:
 ifeq ($(DEB_HOST_ARCH),$(USES_GLES2))
@@ -61,4 +59,4 @@
 endif
 	dh_install --sourcedir=$(TMP2_DIR) -pqtmir-desktop
 	dh_install --sourcedir=$(TMP2_DIR) -pqtdeclarative5-qtmir-plugin
-
+	dh_install --sourcedir=$(TMP2_DIR) -pqtmir-tests

=== added file 'demos/CMakeLists.txt'
--- demos/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ demos/CMakeLists.txt	2015-10-13 19:42:45 +0000
@@ -0,0 +1,4 @@
+configure_file(paths.h.in ${CMAKE_CURRENT_BINARY_DIR}/paths.h @ONLY)
+
+add_subdirectory(qml-demo-client)
+add_subdirectory(qml-demo-shell)
\ No newline at end of file

=== added file 'demos/paths.h.in'
--- demos/paths.h.in	1970-01-01 00:00:00 +0000
+++ demos/paths.h.in	2015-10-13 19:42:45 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef PATHS_H
+#define PATHS_H
+
+// Qt
+#include <QtCore/QCoreApplication>
+#include <QtCore/QDir>
+#include <QtGui/QIcon>
+#include <QtQml/QQmlEngine>
+#include <QStandardPaths>
+
+inline bool isRunningInstalled() {
+    static bool installed = (QCoreApplication::applicationDirPath() ==
+                             QDir(("@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_BINDIR@")).canonicalPath());
+    return installed;
+}
+
+inline QString qmlDirectory() {
+    if (isRunningInstalled()) {
+        return QString("@CMAKE_INSTALL_PREFIX@/@QTMIR_DATA_DIR@/");
+    } else {
+        return QString("@CMAKE_SOURCE_DIR@/demos/");
+    }
+}
+#endif
\ No newline at end of file

=== added file 'demos/qml-demo-client/CMakeLists.txt'
--- demos/qml-demo-client/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-client/CMakeLists.txt	2015-10-13 19:42:45 +0000
@@ -0,0 +1,41 @@
+set(DEMO_CLIENT qtmir-demo-client)
+configure_file(${DEMO_CLIENT}.desktop.in ${CMAKE_CURRENT_BINARY_DIR}/${DEMO_CLIENT}.desktop @ONLY)
+
+include_directories(
+    ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
+)
+
+add_executable(${DEMO_CLIENT}
+    main.cpp
+)
+
+include_directories(
+    ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
+    ${Qt5Qml_PRIVATE_INCLUDE_DIRS}
+    ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
+)
+
+target_link_libraries(
+    ${DEMO_CLIENT}
+    Qt5::Core
+    Qt5::DBus
+    Qt5::Qml
+    Qt5::Quick
+)
+
+file(GLOB QML_JS_FILES *.qml *.js *.png)
+
+# install binaries
+install(TARGETS ${DEMO_CLIENT}
+     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+ )
+
+install(FILES
+    ${QML_JS_FILES}
+    DESTINATION ${QTMIR_DATA_DIR}/${DEMO_CLIENT}
+)
+
+install(FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/${DEMO_CLIENT}.desktop
+    DESTINATION ${CMAKE_INSTALL_PREFIX}/share/applications
+)
\ No newline at end of file

=== added file 'demos/qml-demo-client/main.cpp'
--- demos/qml-demo-client/main.cpp	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-client/main.cpp	2015-10-13 19:42:45 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2012-2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Qt
+#include <QtQuick/QQuickView>
+#include <QtGui/QGuiApplication>
+#include <QDebug>
+#include <csignal>
+#include <libintl.h>
+#include <getopt.h>
+#include "../paths.h"
+
+// REMOVEME - Should be able to use qmlscene, but in order to use the mir benchmarking we need
+// to parse command line switches. Wait until MIR_SOCKET supported by the benchmark framework.
+
+int main(int argc, char **argv)
+{
+    int arg;
+    opterr = 0;
+    while ((arg = getopt (argc, argv, "hm:")) != -1)
+    {
+        switch (arg)
+        {
+        case 'm':
+            setenv("MIR_SOCKET", optarg, 1);
+            break;
+
+        case '?':
+        case 'h':
+        default:
+            puts(argv[0]);
+            puts("Usage:");
+            puts("    -m <Mir server socket>");
+            puts("    -h: this help text");
+            return -1;
+        }
+    }
+
+    QGuiApplication::setApplicationName("qml-demo-client");
+    QGuiApplication *application;
+
+    application = new QGuiApplication(argc, (char**)argv);
+    QQuickView* view = new QQuickView();
+    view->setResizeMode(QQuickView::SizeRootObjectToView);
+    view->setColor("black");
+    view->setTitle("Demo Client");
+    
+    QUrl source(::qmlDirectory() + "qtmir-demo-client/qml-demo-client.qml");
+
+    view->setSource(source);
+    QObject::connect(view->engine(), SIGNAL(quit()), application, SLOT(quit()));
+
+    view->showFullScreen();
+    int result = application->exec();
+
+    delete view;
+    delete application;
+
+    return result;
+}

=== added file 'demos/qml-demo-client/qtmir-demo-client.desktop.in'
--- demos/qml-demo-client/qtmir-demo-client.desktop.in	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-client/qtmir-demo-client.desktop.in	2015-10-13 19:42:45 +0000
@@ -0,0 +1,9 @@
+[Desktop Entry]
+Type=Application
+Name=QtMir Demo Client
+Comment=QtMir demo client
+Exec=@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_BINDIR@/qtmir-demo-client
+Terminal=false
+Icon=
+NoDisplay=false
+X-Ubuntu-Touch=true

=== added file 'demos/qml-demo-shell/CMakeLists.txt'
--- demos/qml-demo-shell/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/CMakeLists.txt	2015-10-13 19:42:45 +0000
@@ -0,0 +1,35 @@
+set(DEMO_SHELL qtmir-demo-shell)
+
+include_directories(
+    ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
+)
+
+add_executable(${DEMO_SHELL}
+    main.cpp
+)
+
+include_directories(
+    ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
+    ${Qt5Qml_PRIVATE_INCLUDE_DIRS}
+    ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
+)
+
+target_link_libraries(
+    ${DEMO_SHELL}
+    Qt5::Core
+    Qt5::DBus
+    Qt5::Qml
+    Qt5::Quick
+)
+
+file(GLOB QML_JS_FILES *.qml *.js *.png)
+
+# install binaries
+install(TARGETS ${DEMO_SHELL}
+     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+ )
+
+install(FILES
+    ${QML_JS_FILES}
+    DESTINATION ${QTMIR_DATA_DIR}/${DEMO_SHELL}
+)

=== added file 'demos/qml-demo-shell/ResizeArea.qml'
--- demos/qml-demo-shell/ResizeArea.qml	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/ResizeArea.qml	2015-10-13 19:42:45 +0000
@@ -0,0 +1,128 @@
+import QtQuick 2.4
+import Unity.Application 0.1
+
+MouseArea {
+    id: root
+
+    // to be set from outside
+    property Item target
+    property real borderThickness
+
+    property bool leftBorder: false
+    property bool rightBorder: false
+    property bool topBorder: false
+    property bool bottomBorder: false
+
+    property bool dragging: false
+    property real startX
+    property real startY
+    property real startWidth
+    property real startHeight
+
+    hoverEnabled: true
+
+    property string cursorName: {
+        if (containsMouse || pressed) {
+            if (leftBorder && !topBorder && !bottomBorder) {
+                return "left_side";
+            } else if (rightBorder && !topBorder && !bottomBorder) {
+                return "right_side";
+            } else if (topBorder && !leftBorder && !rightBorder) {
+                return "top_side";
+            } else if (bottomBorder && !leftBorder && !rightBorder) {
+                return "bottom_side";
+            } else if (leftBorder && topBorder) {
+                return "top_left_corner";
+            } else if (leftBorder && bottomBorder) {
+                return "bottom_left_corner";
+            } else if (rightBorder && topBorder) {
+                return "top_right_corner";
+            } else if (rightBorder && bottomBorder) {
+                return "bottom_right_corner";
+            } else {
+                return "";
+            }
+        } else {
+            return "";
+        }
+    }
+    onCursorNameChanged: {
+        Mir.cursorName = cursorName;
+    }
+
+    function updateBorders() {
+        leftBorder = mouseX <= borderThickness;
+        rightBorder = mouseX >= width - borderThickness;
+        topBorder = mouseY <= borderThickness;
+        bottomBorder = mouseY >= height - borderThickness;
+    }
+
+    onPressedChanged: {
+        if (pressed) {
+            var pos = mapToItem(target.parent, mouseX, mouseY);
+            startX = pos.x;
+            startY = pos.y;
+            startWidth = target.width;
+            startHeight = target.height;
+            dragging = true;
+        } else {
+            dragging = false;
+            if (containsMouse) {
+                updateBorders();
+            }
+        }
+    }
+
+    onEntered: {
+        if (!pressed) {
+            updateBorders();
+        }
+    }
+
+    onPositionChanged: {
+        if (!pressed) {
+            updateBorders();
+        }
+
+        if (!dragging) {
+            return;
+        }
+
+        var pos = mapToItem(target.parent, mouse.x, mouse.y);
+
+        if (leftBorder) {
+            if (startX + startWidth - pos.x > target.minWidth) {
+                target.x = pos.x;
+                target.width = startX + startWidth - target.x;
+                startX = target.x;
+                startWidth = target.width;
+            }
+
+        } else if (rightBorder) {
+            var deltaX = pos.x - startX;
+            if (startWidth + deltaX >= target.minWidth) {
+                target.width = startWidth + deltaX;
+            } else {
+                target.width = target.minWidth;
+            }
+        }
+
+        if (topBorder) {
+            if (startY + startHeight - pos.y > target.minHeight) {
+                target.y = pos.y;
+                target.height = startY + startHeight - target.y;
+                startY = target.y;
+                startHeight = target.height;
+            }
+
+        } else if (bottomBorder) {
+            var deltaY = pos.y - startY;
+            if (startHeight + deltaY >= target.minHeight) {
+                target.height = startHeight + deltaY;
+            } else {
+                target.height = target.minHeight;
+            }
+        }
+    }
+}
+

=== renamed file 'demos/qml-demo-shell/qml-demo-shell.qml' => 'demos/qml-demo-shell/Shell.qml'
--- demos/qml-demo-shell/qml-demo-shell.qml	2015-08-31 09:51:28 +0000
+++ demos/qml-demo-shell/Shell.qml	2015-10-13 19:42:45 +0000
@@ -1,4 +1,4 @@
-import QtQuick 2.0
+import QtQuick 2.4
 import Unity.Application 0.1
 
 Rectangle {
@@ -88,6 +88,7 @@
     }
 
     Rectangle {
+        id: resizeButton
         width: 90
         height: 40
         color: "blue"
@@ -103,6 +104,23 @@
         }
     }
 
+    Rectangle {
+        width: 40
+        height: 40
+        color: "green"
+        anchors { right: resizeButton.left; bottom: parent.bottom }
+        Text {
+            anchors.centerIn: parent
+            text: "⟳"
+            color: "white"
+            font.pixelSize: 35
+        }
+        MouseArea {
+            anchors.fill: parent
+            onClicked: { root.rotation += 180; }
+        }
+    }
+
     Component {
         id: windowStretchComponent
         Window {

=== modified file 'demos/qml-demo-shell/TitleBar.qml'
--- demos/qml-demo-shell/TitleBar.qml	2015-08-24 12:43:01 +0000
+++ demos/qml-demo-shell/TitleBar.qml	2015-10-13 19:42:45 +0000
@@ -1,4 +1,5 @@
-import QtQuick 2.0
+import QtQuick 2.4
+import Unity.Application 0.1
 
 Rectangle {
     id: root
@@ -21,8 +22,10 @@
                 distanceX = pos.x;
                 distanceY = pos.y;
                 dragging = true;
+                Mir.cursorName = "grabbing";
             } else {
                 dragging = false;
+                Mir.cursorName = "";
             }
         }
         onMouseXChanged: {

=== modified file 'demos/qml-demo-shell/Window.qml'
--- demos/qml-demo-shell/Window.qml	2015-08-31 09:51:28 +0000
+++ demos/qml-demo-shell/Window.qml	2015-10-13 19:42:45 +0000
@@ -58,87 +58,10 @@
         }
     ]
 
-
-    MouseArea {
-        anchors.fill: parent
-
-        property real startX
-        property real startY
-        property real startWidth
-        property real startHeight
-        property bool leftBorder
-        property bool rightBorder
-        property bool topBorder
-        property bool bottomBorder
-        property bool dragging
-        onPressedChanged: {
-            if (pressed) {
-                var pos = mapToItem(root.parent, mouseX, mouseY);
-                startX = pos.x;
-                startY = pos.y;
-                startWidth = width;
-                startHeight = height;
-                leftBorder = mouseX > 0 && mouseX < root.borderThickness;
-                rightBorder = mouseX > (root.width - root.borderThickness) && mouseX < root.width;
-                topBorder = mouseY > 0 && mouseY < root.borderThickness;
-                bottomBorder = mouseY > (root.height - root.borderThickness) && mouseY < root.height;
-                dragging = true;
-            } else {
-                dragging = false;
-            }
-        }
-
-        onMouseXChanged: {
-            if (!pressed || !dragging) {
-                return;
-            }
-
-            var pos = mapToItem(root.parent, mouseX, mouseY);
-
-            if (leftBorder) {
-
-                if (startX + startWidth - pos.x > root.minWidth) {
-                    root.x = pos.x;
-                    root.width = startX + startWidth - root.x;
-                    startX = root.x;
-                    startWidth = root.width;
-                }
-
-            } else if (rightBorder) {
-                var deltaX = pos.x - startX;
-                if (startWidth + deltaX >= root.minWidth) {
-                    root.width = startWidth + deltaX;
-                } else {
-                    root.width = root.minWidth;
-                }
-            }
-        }
-
-        onMouseYChanged: {
-            if (!pressed || !dragging) {
-                return;
-            }
-
-            var pos = mapToItem(root.parent, mouseX, mouseY);
-
-            if (topBorder) {
-
-                if (startY + startHeight - pos.y > root.minHeight) {
-                    root.y = pos.y;
-                    root.height = startY + startHeight - root.y;
-                    startY = root.y;
-                    startHeight = root.height;
-                }
-
-            } else if (bottomBorder) {
-                var deltaY = pos.y - startY;
-                if (startHeight + deltaY >= root.minHeight) {
-                    root.height = startHeight + deltaY;
-                } else {
-                    root.height = root.minHeight;
-                }
-            }
-        }
+    ResizeArea {
+        anchors.fill: root
+        borderThickness: root.borderThickness
+        target: root
     }
 
     TitleBar {

=== added file 'demos/qml-demo-shell/main.cpp'
--- demos/qml-demo-shell/main.cpp	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/main.cpp	2015-10-13 19:42:45 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2012-2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Qt
+#include <QCommandLineParser>
+#include <QtQuick/QQuickView>
+#include <QtGui/QGuiApplication>
+#include <QtQml/QQmlEngine>
+#include <QtQml/QQmlContext>
+#include <QLibrary>
+#include <QDebug>
+#include <csignal>
+#include <libintl.h>
+#include "../paths.h"
+
+#include <private/qobject_p.h>
+
+// REMOVEME - Should be able to use qmlscene, but in order to use the mir benchmarking we need
+// to parse command line switches. Wait until MIR_SOCKET supported by the benchmark framework.
+
+int main(int argc, const char *argv[])
+{
+    QGuiApplication::setApplicationName("qml-demo-shell");
+    QGuiApplication *application;
+
+    application = new QGuiApplication(argc, (char**)argv);
+    QQuickView* view = new QQuickView();
+    view->setResizeMode(QQuickView::SizeRootObjectToView);
+    view->setColor("black");
+    view->setTitle("Demo Shell");
+    
+    QUrl source(::qmlDirectory() + "qtmir-demo-shell/qml-demo-shell.qml");
+
+    view->setSource(source);
+    QObject::connect(view->engine(), SIGNAL(quit()), application, SLOT(quit()));
+
+    view->showFullScreen();
+    int result = application->exec();
+
+    delete view;
+    delete application;
+
+    return result;
+}

=== 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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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

=== added file 'src/common/timestamp.cpp'
--- src/common/timestamp.cpp	1970-01-01 00:00:00 +0000
+++ src/common/timestamp.cpp	2015-10-13 19:42:45 +0000
@@ -0,0 +1,18 @@
+
+#include <chrono>
+#include "timestamp_impl.h"
+
+std::chrono::nanoseconds appStartTime(0);
+
+void resetStartTime(std::chrono::nanoseconds timestamp)
+{
+	appStartTime = timestamp;
+}
+
+std::chrono::nanoseconds getStartTime(std::chrono::nanoseconds timestamp, bool allowReset)
+{
+	if (allowReset && appStartTime.count() == 0) {
+		resetStartTime(timestamp);
+	}
+	return appStartTime;
+}

=== added file 'src/common/timestamp.h'
--- src/common/timestamp.h	1970-01-01 00:00:00 +0000
+++ src/common/timestamp.h	2015-10-13 19:42:45 +0000
@@ -0,0 +1,39 @@
+/*
+ * 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 QTMIR_TIMESTAMP_H
+#define QTMIR_TIMESTAMP_H
+
+#include <QtCore/qglobal.h>
+#include <chrono>
+
+namespace qtmir {
+
+// Converts a mir timestamp (in nanoseconds) to and from a timestamp in milliseconds.
+// Qt system events only work with ulong timestamps. On 32bit archs a ulong is 4 bytes long, so the 64 bit nanoseconds
+// will be truncated and skewed. In order to fix this, we truncate the result by using time since "first call"
+template<typename T>
+T compressTimestamp(std::chrono::nanoseconds timestamp);
+
+	// "Re-inflate" a truncated timestamp.
+template<typename T>
+std::chrono::nanoseconds uncompressTimestamp(T timestamp);
+
+}
+
+#include "timestamp_impl.h"
+
+#endif // QTMIR_TIMESTAMP_H

=== added file 'src/common/timestamp_impl.h'
--- src/common/timestamp_impl.h	1970-01-01 00:00:00 +0000
+++ src/common/timestamp_impl.h	2015-10-13 19:42:45 +0000
@@ -0,0 +1,34 @@
+#include <QCoreApplication>
+#include <QVariant>
+
+extern "C" {
+	void resetStartTime(std::chrono::nanoseconds timestamp);
+	std::chrono::nanoseconds getStartTime(std::chrono::nanoseconds timestamp, bool allowReset = true);
+}
+
+namespace qtmir {
+
+template<typename T>
+T compressTimestamp(std::chrono::nanoseconds timestamp)
+{
+    std::chrono::nanoseconds startTime = getStartTime(timestamp);
+    std::chrono::nanoseconds result = timestamp - startTime;
+
+    if (std::numeric_limits<std::chrono::nanoseconds::rep>::max() > std::numeric_limits<T>::max() &&
+        result > std::chrono::nanoseconds(std::numeric_limits<T>::max())) {
+        // we've overflowed the boundaries of the millisecond type.
+        resetStartTime(timestamp);
+        return 0;
+    }
+
+    return result.count();
+}
+
+template<typename T>
+std::chrono::nanoseconds uncompressTimestamp(T timestamp)
+{
+    auto tsNS = std::chrono::nanoseconds(timestamp);
+    return getStartTime(tsNS, false) + std::chrono::nanoseconds(tsNS);
+}
+
+}
\ No newline at end of file

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2015-09-17 16:17:17 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2015-10-13 19:42:45 +0000
@@ -92,4 +92,3 @@
 # install
 add_qml_plugin(Unity.Application 0.1 Unity/Application TARGETS unityapplicationplugin)
 install(FILES com.canonical.qtmir.gschema.xml DESTINATION ${CMAKE_INSTALL_DATADIR}/glib-2.0/schemas)
-

=== 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-13 19:42:45 +0000
@@ -59,6 +59,11 @@
     m_width = size.width.as_int();
 }
 
+bool MirBufferSGTexture::hasBuffer() const
+{
+    return !!m_mirBuffer;
+}
+
 int MirBufferSGTexture::textureId() const
 {
     return m_textureId;
@@ -71,12 +76,17 @@
 
 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 {
+        return false;
+    }
 }
 
 void MirBufferSGTexture::bind()
 {
+    Q_ASSERT(hasBuffer());
     glBindTexture(GL_TEXTURE_2D, m_textureId);
     updateBindOptions(true/* force */);
 

=== 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-13 19:42:45 +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-13 19:42:45 +0000
@@ -15,6 +15,7 @@
  */
 
 #include "mirsurface.h"
+#include "timestamp.h"
 
 // mirserver
 #include <surfaceobserver.h>
@@ -49,18 +50,29 @@
     return m_mods;
 }
 
+MirPointerButtons
+getMirButtonsFromQt(Qt::MouseButtons buttons)
+{
+    MirPointerButtons result = 0;
+    if (buttons & Qt::LeftButton)
+        result |= mir_pointer_button_primary;
+    if (buttons & Qt::RightButton)
+        result |= mir_pointer_button_secondary;
+    if (buttons & Qt::MiddleButton)
+        result |= mir_pointer_button_tertiary;
+    if (buttons & Qt::BackButton)
+        result |= mir_pointer_button_back;
+    if (buttons & Qt::ForwardButton)
+        result |= mir_pointer_button_forward;
+
+    return result;
+}
+
 mir::EventUPtr makeMirEvent(QMouseEvent *qtEvent, MirPointerAction action)
 {
-    auto timestamp = std::chrono::milliseconds(qtEvent->timestamp());
+    auto timestamp = uncompressTimestamp<ulong>(qtEvent->timestamp());
     auto modifiers = getMirModifiersFromQt(qtEvent->modifiers());
-
-    MirPointerButtons buttons = 0;
-    if (qtEvent->buttons() & Qt::LeftButton)
-        buttons |= mir_pointer_button_primary;
-    if (qtEvent->buttons() & Qt::RightButton)
-        buttons |= mir_pointer_button_secondary;
-    if (qtEvent->buttons() & Qt::MidButton)
-        buttons |= mir_pointer_button_tertiary;
+    auto buttons = getMirButtonsFromQt(qtEvent->buttons());
 
     return mir::events::make_event(0 /*DeviceID */, timestamp, 0 /* mac */, modifiers, action,
                                    buttons, qtEvent->x(), qtEvent->y(), 0, 0, 0, 0);
@@ -68,7 +80,7 @@
 
 mir::EventUPtr makeMirEvent(QHoverEvent *qtEvent, MirPointerAction action)
 {
-    auto timestamp = std::chrono::milliseconds(qtEvent->timestamp());
+    auto timestamp = uncompressTimestamp<ulong>(qtEvent->timestamp());
 
     MirPointerButtons buttons = 0;
 
@@ -76,6 +88,18 @@
                                    buttons, qtEvent->posF().x(), qtEvent->posF().y(), 0, 0, 0, 0);
 }
 
+mir::EventUPtr makeMirEvent(QWheelEvent *qtEvent)
+{
+    auto timestamp = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds(qtEvent->timestamp()));
+    auto modifiers = getMirModifiersFromQt(qtEvent->modifiers());
+    auto buttons = getMirButtonsFromQt(qtEvent->buttons());
+
+    return mir::events::make_event(0 /*DeviceID */, timestamp, 0 /* mac */, modifiers, mir_pointer_action_motion,
+                                   buttons, qtEvent->x(), qtEvent->y(),
+                                   qtEvent->angleDelta().x(), qtEvent->angleDelta().y(),
+                                   0, 0);
+}
+
 mir::EventUPtr makeMirEvent(QKeyEvent *qtEvent)
 {
     MirKeyboardAction action = mir_keyboard_action_down;
@@ -93,7 +117,7 @@
     if (qtEvent->isAutoRepeat())
         action = mir_keyboard_action_repeat;
 
-    return mir::events::make_event(0 /* DeviceID */, std::chrono::milliseconds(qtEvent->timestamp()),
+    return mir::events::make_event(0 /* DeviceID */, uncompressTimestamp<ulong>(qtEvent->timestamp()),
                            0 /* mac */, action, qtEvent->nativeVirtualKey(),
                            qtEvent->nativeScanCode(),
                            qtEvent->nativeModifiers());
@@ -105,7 +129,7 @@
                             ulong qtTimestamp)
 {
     auto modifiers = getMirModifiersFromQt(qmods);
-    auto ev = mir::events::make_event(0, std::chrono::milliseconds(qtTimestamp),
+    auto ev = mir::events::make_event(0, uncompressTimestamp<ulong>(qtTimestamp),
                                       0 /* mac */, modifiers);
 
     for (int i = 0; i < qtTouchPoints.count(); ++i) {
@@ -309,21 +333,23 @@
     }
 }
 
-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());
 
+    if (m_textureUpdated) {
+        return texture->hasBuffer();
+    }
+
     const void* const userId = (void*)123;
     auto renderables = m_surface->generate_renderables(userId);
 
-    if (m_surface->buffers_ready_for_compositor(userId) > 0 && renderables.size() > 0) {
+    if (renderables.size() > 0 &&
+            (m_surface->buffers_ready_for_compositor(userId) > 0 || !texture->hasBuffer())
+        ) {
         // Avoid holding two buffers for the compositor at the same time. Thus free the current
         // before acquiring the next
         texture->freeBuffer();
@@ -343,6 +369,8 @@
     }
 
     m_textureUpdated = true;
+
+    return texture->hasBuffer();
 }
 
 void MirSurface::onCompositorSwappedBuffers()
@@ -569,6 +597,13 @@
     event->accept();
 }
 
+void MirSurface::wheelEvent(QWheelEvent *event)
+{
+    auto ev = makeMirEvent(event);
+    m_surface->consume(*ev);
+    event->accept();
+}
+
 void MirSurface::keyPressEvent(QKeyEvent *qtEvent)
 {
     auto ev = makeMirEvent(qtEvent);

=== 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-13 19:42:45 +0000
@@ -87,7 +87,7 @@
     // 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
@@ -100,6 +100,7 @@
     void hoverEnterEvent(QHoverEvent *event) override;
     void hoverLeaveEvent(QHoverEvent *event) override;
     void hoverMoveEvent(QHoverEvent *event) override;
+    void wheelEvent(QWheelEvent *event) override;
 
     void keyPressEvent(QKeyEvent *event) override;
     void keyReleaseEvent(QKeyEvent *event) override;

=== 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-13 19:42:45 +0000
@@ -54,7 +54,7 @@
     // 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
@@ -67,6 +67,7 @@
     virtual void hoverEnterEvent(QHoverEvent *event) = 0;
     virtual void hoverLeaveEvent(QHoverEvent *event) = 0;
     virtual void hoverMoveEvent(QHoverEvent *event) = 0;
+    virtual void wheelEvent(QWheelEvent *event) = 0;
 
     virtual void keyPressEvent(QKeyEvent *event) = 0;
     virtual void keyReleaseEvent(QKeyEvent *event) = 0;

=== 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-13 19:42:45 +0000
@@ -20,6 +20,8 @@
 #include "mirsurfaceitem.h"
 #include "logging.h"
 #include "ubuntukeyboardinfo.h"
+#include "tracepoints.h" // generated from tracepoints.tp
+#include "timestamp.h"
 
 // common
 #include <debughelpers.h>
@@ -216,17 +218,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);
@@ -298,7 +298,11 @@
 
 void MirSurfaceItem::wheelEvent(QWheelEvent *event)
 {
-    Q_UNUSED(event);
+    if (m_consumesInput && m_surface && m_surface->live()) {
+        m_surface->wheelEvent(event);
+    } else {
+        event->ignore();
+    }
 }
 
 void MirSurfaceItem::hoverEnterEvent(QHoverEvent *event)
@@ -411,10 +415,14 @@
     m_lastTouchEvent->timestamp = timestamp;
     m_lastTouchEvent->touchPoints = touchPoints;
     m_lastTouchEvent->touchPointStates = touchPointStates;
+
+    tracepoint(qtmir, touchEventConsume_end, uncompressTimestamp<ulong>(timestamp).count());
 }
 
 void MirSurfaceItem::touchEvent(QTouchEvent *event)
 {
+    tracepoint(qtmir, touchEventConsume_start, uncompressTimestamp<ulong>(event->timestamp()).count());
+
     bool accepted = processTouchEvent(event->type(),
             event->timestamp(),
             event->modifiers(),

=== modified file 'src/modules/Unity/Application/plugin.cpp'
--- src/modules/Unity/Application/plugin.cpp	2015-08-31 09:51:28 +0000
+++ src/modules/Unity/Application/plugin.cpp	2015-10-13 19:42:45 +0000
@@ -27,6 +27,9 @@
 #include "sessionmanager.h"
 #include "ubuntukeyboardinfo.h"
 
+// platforms/mirserver
+#include <mirsingleton.h>
+
 // qtmir
 #include "logging.h"
 
@@ -64,6 +67,10 @@
     }
     return UbuntuKeyboardInfo::instance();
 }
+
+QObject* mirSingleton(QQmlEngine* /*engine*/, QJSEngine* /*scriptEngine*/) {
+    return qtmir::Mir::instance();
+}
 } // anonymous namespace
 
 class UnityApplicationPlugin : public QQmlExtensionPlugin {
@@ -102,7 +109,7 @@
                     uri, 0, 1, "Session", "Session can't be instantiated from QML");
         qmlRegisterSingletonType<qtmir::UbuntuKeyboardInfo>(
                 uri, 0, 1, "UbuntuKeyboardInfo", ubuntuKeyboardInfoSingleton);
-        qmlRegisterUncreatableType<Mir>(uri, 0, 1, "Mir", "Mir provides enum values, it can't be instantiated");
+        qmlRegisterSingletonType<qtmir::Mir>(uri, 0, 1, "Mir", mirSingleton);
     }
 
     virtual void initializeEngine(QQmlEngine *engine, const char *uri)

=== modified file 'src/modules/Unity/Application/tracepoints.tp'
--- src/modules/Unity/Application/tracepoints.tp	2014-09-04 11:11:26 +0000
+++ src/modules/Unity/Application/tracepoints.tp	2015-10-13 19:42:45 +0000
@@ -1,3 +1,5 @@
+#include <stdint.h>
+
 TRACEPOINT_EVENT(qtmir, startApplication, TP_ARGS(0), TP_FIELDS())
 TRACEPOINT_EVENT(qtmir, onProcessStarting, TP_ARGS(0), TP_FIELDS())
 TRACEPOINT_EVENT(qtmir, authorizeSession, TP_ARGS(0), TP_FIELDS())
@@ -7,3 +9,6 @@
 TRACEPOINT_EVENT(qtmir, firstFrameDrawn, TP_ARGS(0), TP_FIELDS())
 TRACEPOINT_EVENT(qtmir, appIdHasProcessId_start, TP_ARGS(0), TP_FIELDS())
 TRACEPOINT_EVENT(qtmir, appIdHasProcessId_end, TP_ARGS(int, found), TP_FIELDS(ctf_integer(int, found, found)))
+
+TRACEPOINT_EVENT(qtmir, touchEventConsume_start, TP_ARGS(int64_t, event_time), TP_FIELDS(ctf_integer(int64_t, event_time, event_time)))
+TRACEPOINT_EVENT(qtmir, touchEventConsume_end, TP_ARGS(int64_t, event_time), TP_FIELDS(ctf_integer(int64_t, event_time, event_time)))

=== 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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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-08-11 19:25:04 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2015-10-13 19:42:45 +0000
@@ -30,6 +30,7 @@
     ${QT5PLATFORM_SUPPORT_INCLUDE_DIRS}
     ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
     ${QT5_PLATFORMSUPPORT_INCLUDE_DIRS}
+    ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
 
     ${APPLICATION_API_INCLUDE_DIRS}
 )
@@ -41,7 +42,10 @@
 
 set(MIRSERVER_QPA_PLUGIN_SRC
     ${CMAKE_SOURCE_DIR}/src/common/debughelpers.cpp
+    ${CMAKE_SOURCE_DIR}/src/common/timestamp.cpp
+    cursor.cpp
     mirwindowmanager.cpp
+    mirsingleton.cpp
     qteventfeeder.cpp
     plugin.cpp
     qmirserver.cpp
@@ -52,17 +56,21 @@
     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
     )
 
 add_library(qpa-mirserver SHARED
@@ -82,7 +90,7 @@
     ${QT5PLATFORM_SUPPORT_LDFLAGS}
     # TODO Qt5Platform support LDFLAGS dont provide actual required ldflags...
     # I found these were needed...perhaps there is some way to query qmake/qconfig?
-    -lfreetype 
+    -lfreetype
     ${GIO_LDFLAGS}
     ${FONTCONFIG_LDFLAGS}
 

=== added file 'src/platforms/mirserver/cursor.cpp'
--- src/platforms/mirserver/cursor.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/cursor.cpp	2015-10-13 19:42:45 +0000
@@ -0,0 +1,152 @@
+/*
+ * 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 "cursor.h"
+#include "logging.h"
+
+#include "mirsingleton.h"
+
+// Unity API
+#include <unity/shell/application/MirMousePointerInterface.h>
+
+using namespace qtmir;
+
+Cursor::Cursor()
+{
+    m_shapeToCursorName[Qt::ArrowCursor] = "left_ptr";
+    m_shapeToCursorName[Qt::UpArrowCursor] = "up_arrow";
+    m_shapeToCursorName[Qt::CrossCursor] = "cross";
+    m_shapeToCursorName[Qt::WaitCursor] = "watch";
+    m_shapeToCursorName[Qt::IBeamCursor] = "xterm";
+    m_shapeToCursorName[Qt::SizeVerCursor] = "size_ver";
+    m_shapeToCursorName[Qt::SizeHorCursor] = "size_hor";
+    m_shapeToCursorName[Qt::SizeBDiagCursor] = "size_bdiag";
+    m_shapeToCursorName[Qt::SizeFDiagCursor] = "size_fdiag";
+    m_shapeToCursorName[Qt::SizeAllCursor] = "size_all";
+    m_shapeToCursorName[Qt::BlankCursor] = "blank";
+    m_shapeToCursorName[Qt::SplitVCursor] = "split_v";
+    m_shapeToCursorName[Qt::SplitHCursor] = "split_h";
+    m_shapeToCursorName[Qt::PointingHandCursor] = "pointing_hand";
+    m_shapeToCursorName[Qt::ForbiddenCursor] = "forbidden";
+    m_shapeToCursorName[Qt::WhatsThisCursor] = "whats_this";
+    m_shapeToCursorName[Qt::BusyCursor] = "left_ptr_watch";
+    m_shapeToCursorName[Qt::OpenHandCursor] = "openhand";
+    m_shapeToCursorName[Qt::ClosedHandCursor] = "closedhand";
+    m_shapeToCursorName[Qt::DragCopyCursor] = "copy";
+    m_shapeToCursorName[Qt::DragMoveCursor] = "move";
+    m_shapeToCursorName[Qt::DragLinkCursor] = "link";
+
+    connect(Mir::instance(), &Mir::cursorNameChanged, this, &Cursor::setMirCursorName);
+}
+
+void Cursor::changeCursor(QCursor *windowCursor, QWindow * /*window*/)
+{
+    if (m_mousePointer.isNull()) {
+        return;
+    }
+
+    if (windowCursor) {
+        m_qtCursorName = m_shapeToCursorName.value(windowCursor->shape(), QString("left_ptr"));
+    } else {
+        m_qtCursorName.clear();
+    }
+
+    updateMousePointerCursorName();
+}
+
+void Cursor::setMirCursorName(const QString &mirCursorName)
+{
+    m_mirCursorName = mirCursorName;
+    updateMousePointerCursorName();
+}
+
+void Cursor::setMousePointer(MirMousePointerInterface *mousePointer)
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (mousePointer && !m_mousePointer.isNull()) {
+        qFatal("QPA mirserver: Only one MousePointer per screen is allowed!");
+    }
+
+    m_mousePointer = mousePointer;
+    updateMousePointerCursorName();
+}
+
+bool Cursor::handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,
+        Qt::KeyboardModifiers modifiers)
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (!m_mousePointer || !m_mousePointer->isVisible()) {
+        return false;
+    }
+
+    // Must not be called directly as we're most likely not in Qt's GUI (main) thread.
+    bool ok = QMetaObject::invokeMethod(m_mousePointer, "handleMouseEvent", Qt::AutoConnection,
+        Q_ARG(ulong, timestamp),
+        Q_ARG(QPointF, movement),
+        Q_ARG(Qt::MouseButton, static_cast<Qt::MouseButton>((int)buttons)), // FIXME in MirMousePointerInterface!!!
+        Q_ARG(Qt::KeyboardModifiers, modifiers));
+
+    if (!ok) {
+        qCWarning(QTMIR_MIR_INPUT) << "Failed to invoke MousePointer::handleMouseEvent";
+    }
+
+    return ok;
+}
+
+void Cursor::setPos(const QPoint &pos)
+{
+    if (!m_mousePointer) {
+        QPlatformCursor::setPos(pos);
+        return;
+    }
+
+    QPointF movement;
+    QPointF mouseScenePos = m_mousePointer->mapToItem(nullptr, QPointF(0, 0));
+
+    movement.setX(pos.x() - mouseScenePos.x());
+    movement.setY(pos.y() - mouseScenePos.y());
+
+    m_mousePointer->handleMouseEvent(0 /*timestamp*/, movement, Qt::NoButton, Qt::NoModifier);
+}
+
+QPoint Cursor::pos() const
+{
+    if (m_mousePointer) {
+        return m_mousePointer->mapToItem(nullptr, QPointF(0, 0)).toPoint();
+    } else {
+        return QPlatformCursor::pos();
+    }
+}
+
+void Cursor::updateMousePointerCursorName()
+{
+    if (!m_mousePointer) {
+        return;
+    }
+
+    if (m_mirCursorName.isEmpty()) {
+        if (m_qtCursorName.isEmpty()) {
+            m_mousePointer->setCursorName("left_ptr");
+        } else {
+            m_mousePointer->setCursorName(m_qtCursorName);
+        }
+    } else {
+        m_mousePointer->setCursorName(m_mirCursorName);
+    }
+}

=== added file 'src/platforms/mirserver/cursor.h'
--- src/platforms/mirserver/cursor.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/cursor.h	2015-10-13 19:42:45 +0000
@@ -0,0 +1,66 @@
+/*
+ * 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 QTMIR_CURSOR_H
+#define QTMIR_CURSOR_H
+
+#include <QMutex>
+#include <QPointer>
+
+// Unity API
+#include <unity/shell/application/MirPlatformCursor.h>
+
+namespace qtmir {
+
+class Cursor : public MirPlatformCursor
+{
+public:
+    Cursor();
+
+    // Called form Mir input thread
+    bool handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,
+            Qt::KeyboardModifiers modifiers);
+
+    ////
+    // MirPlatformCursor
+
+    // Called from Qt's GUI thread
+    void setMousePointer(MirMousePointerInterface *mousePointer) override;
+
+    ////
+    // QPlatformCursor
+
+    void changeCursor(QCursor *windowCursor, QWindow *window) override;
+
+    void setPos(const QPoint &pos) override;
+    QPoint pos() const override;
+
+private Q_SLOTS:
+    void setMirCursorName(const QString &mirCursorName);
+
+private:
+    void updateMousePointerCursorName();
+    QMutex m_mutex;
+    QPointer<MirMousePointerInterface> m_mousePointer;
+    QMap<int,QString> m_shapeToCursorName;
+    QString m_qtCursorName;
+    QString m_mirCursorName;
+};
+
+} // namespace qtmir
+
+#endif // QTMIR_CURSOR_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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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-08-11 12:08:32 +0000
+++ src/platforms/mirserver/mirserver.cpp	2015-10-13 19:42:45 +0000
@@ -23,15 +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;
@@ -45,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);
@@ -71,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([]
@@ -92,17 +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.
+    // 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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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/mirsingleton.cpp'
--- src/platforms/mirserver/mirsingleton.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/mirsingleton.cpp	2015-10-13 19:42:45 +0000
@@ -0,0 +1,33 @@
+#include "mirsingleton.h"
+
+qtmir::Mir *qtmir::Mir::m_instance = nullptr;
+
+qtmir::Mir::Mir()
+{
+}
+
+qtmir::Mir::~Mir()
+{
+    m_instance = nullptr;
+}
+
+qtmir::Mir *qtmir::Mir::instance()
+{
+    if (!m_instance) {
+        m_instance = new qtmir::Mir;
+    }
+    return m_instance;
+}
+
+void qtmir::Mir::setCursorName(const QString &cursorName)
+{
+    if (m_cursorName != cursorName) {
+        m_cursorName = cursorName;
+        Q_EMIT cursorNameChanged(m_cursorName);
+    }
+}
+
+QString qtmir::Mir::cursorName() const
+{
+    return m_cursorName;
+}

=== added file 'src/platforms/mirserver/mirsingleton.h'
--- src/platforms/mirserver/mirsingleton.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/mirsingleton.h	2015-10-13 19:42:45 +0000
@@ -0,0 +1,46 @@
+/*
+ * 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 QTMIR_MIRSINGLETON_H
+#define QTMIR_MIRSINGLETON_H
+
+// unity-api
+#include <unity/shell/application/Mir.h>
+
+namespace qtmir {
+
+class Mir : public ::Mir
+{
+    Q_OBJECT
+public:
+    virtual ~Mir();
+
+    static Mir *instance();
+
+    void setCursorName(const QString &cursorName) override;
+    QString cursorName() const override;
+
+private:
+    Mir();
+    Q_DISABLE_COPY(Mir)
+
+    QString m_cursorName;
+    static qtmir::Mir *m_instance;
+};
+
+} // namespace qtmir
+
+#endif // QTMIR_MIRSINGLETON_H

=== 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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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-13 19:42:45 +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-08-27 16:10:20 +0000
+++ src/platforms/mirserver/qteventfeeder.cpp	2015-10-13 19:42:45 +0000
@@ -15,7 +15,12 @@
  */
 
 #include "qteventfeeder.h"
+#include "cursor.h"
 #include "logging.h"
+#include "timestamp.h"
+#include "tracepoints.h" // generated from tracepoints.tp
+#include "screen.h" // NEEDED?
+#include "screencontroller.h"
 
 #include <qpa/qplatforminputcontext.h>
 #include <qpa/qplatformintegration.h>
@@ -365,20 +370,30 @@
 
 namespace {
 
-class QtWindowSystem : public QtEventFeeder::QtWindowSystemInterface {
-
-    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();
+class QtWindowSystem : public QtEventFeeder::QtWindowSystemInterface
+{
+public:
+    QtWindowSystem()
+    {
+        // because we're using QMetaObject::invoke with arguments of those types
+        qRegisterMetaType<Qt::KeyboardModifiers>("Qt::KeyboardModifiers");
+        qRegisterMetaType<Qt::MouseButton>("Qt::MouseButton");
+        qRegisterMetaType<Qt::MouseButtons>("Qt::MouseButtons");
+    }
+
+    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
@@ -386,47 +401,75 @@
         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);
-    }
-
-    void handleMouseEvent(ulong timestamp, QPointF point, Qt::MouseButton buttons, Qt::KeyboardModifiers modifiers) override
-    {
-        Q_ASSERT(!mTopLevelWindow.isNull());
-        QWindowSystemInterface::handleMouseEvent(mTopLevelWindow.data(), timestamp, point, point, // local and global point are the same
-            buttons, modifiers);
-    }
-
+        QWindowSystemInterface::handleTouchEvent(window, timestamp, device, points, mods);
+    }
+
+    void handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,
+                          Qt::KeyboardModifiers modifiers) override
+    {
+        // 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;
+        }
+    }
+
+    void handleWheelEvent(ulong timestamp, const QPointF &localPoint, const QPointF &globalPoint,
+                          QPoint pixelDelta, QPoint angleDelta,
+                          Qt::KeyboardModifiers mods, Qt::ScrollPhase phase) override
+    {
+        QWindowSystemInterface::handleWheelEvent(m_screenController->getWindowForPoint(localPoint.toPoint()),
+                                                 timestamp, localPoint, globalPoint,
+                                                 pixelDelta, angleDelta, mods, phase);
+    }
+
+    void handleEnterEvent(const QPointF &localPoint, const QPointF &globalPoint) override
+    {
+        QWindowSystemInterface::handleEnterEvent(m_screenController->getWindowForPoint(localPoint.toPoint()), localPoint, globalPoint);
+    }
+
+    void handleLeaveEvent(const QPointF &localPoint) override
+    {
+        QWindowSystemInterface::handleLeaveEvent(m_screenController->getWindowForPoint(localPoint.toPoint()));
+    }
 
 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
@@ -436,6 +479,7 @@
     mTouchDevice->setCapabilities(
             QTouchDevice::Position | QTouchDevice::Area | QTouchDevice::Pressure |
             QTouchDevice::NormalizedPosition);
+    mQtWindowSystem->setScreenController(screenController);
     mQtWindowSystem->registerTouchDevice(mTouchDevice);
 }
 
@@ -449,6 +493,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)) {
@@ -472,7 +517,7 @@
 
 Qt::KeyboardModifiers getQtModifiersFromMir(MirInputEventModifiers modifiers)
 {
-    int qtModifiers = Qt::NoModifier;
+    Qt::KeyboardModifiers qtModifiers = Qt::NoModifier;
     if (modifiers & mir_input_event_modifier_shift) {
         qtModifiers |= Qt::ShiftModifier;
     }
@@ -485,12 +530,12 @@
     if (modifiers & mir_input_event_modifier_meta) {
         qtModifiers |= Qt::MetaModifier;
     }
-    return static_cast<Qt::KeyboardModifiers>(qtModifiers);
+    return qtModifiers;
 }
 
-Qt::MouseButton getQtMouseButtonsfromMirPointerEvent(MirPointerEvent const* pev)
+Qt::MouseButtons getQtMouseButtonsfromMirPointerEvent(MirPointerEvent const* pev)
 {
-    int buttons = Qt::NoButton;
+    Qt::MouseButtons buttons = Qt::NoButton;
     if (mir_pointer_event_button_state(pev, mir_pointer_button_primary))
         buttons |= Qt::LeftButton;
     if (mir_pointer_event_button_state(pev, mir_pointer_button_secondary))
@@ -502,36 +547,56 @@
     if (mir_pointer_event_button_state(pev, mir_pointer_button_forward))
         buttons |= Qt::ForwardButton;
 
-    return static_cast<Qt::MouseButton>(buttons);
+    return buttons;
 }
 }
 
 void QtEventFeeder::dispatchPointer(MirInputEvent const* ev)
 {
-    if (!mQtWindowSystem->hasTargetWindow())
-        return;
-
-    auto timestamp = mir_input_event_get_event_time(ev) / 1000000;
-
+    auto timestamp = qtmir::compressTimestamp<ulong>(std::chrono::nanoseconds(mir_input_event_get_event_time(ev)));
     auto pev = mir_input_event_get_pointer_event(ev);
+    auto action = mir_pointer_event_action(pev);
     qCDebug(QTMIR_MIR_INPUT) << "Received" << qPrintable(mirPointerEventToString(pev));
 
     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));
     auto local_point = QPointF(mir_pointer_event_axis_value(pev, mir_pointer_axis_x),
                                mir_pointer_event_axis_value(pev, mir_pointer_axis_y));
 
-    mQtWindowSystem->handleMouseEvent(timestamp, local_point,
-                                      buttons, modifiers);
+    switch (action) {
+    case mir_pointer_action_button_up:
+    case mir_pointer_action_button_down:
+    case mir_pointer_action_motion:
+    {
+        const float hDelta = mir_pointer_event_axis_value(pev, mir_pointer_axis_hscroll);
+        const float vDelta = mir_pointer_event_axis_value(pev, mir_pointer_axis_vscroll);
+
+        if (hDelta != 0 || vDelta != 0) {
+            const QPoint angleDelta = QPoint(hDelta * 15, vDelta * 15);
+            mQtWindowSystem->handleWheelEvent(timestamp, local_point, local_point,
+                                              QPoint(), angleDelta, modifiers, Qt::ScrollUpdate);
+        } else {
+            auto buttons = getQtMouseButtonsfromMirPointerEvent(pev);
+            mQtWindowSystem->handleMouseEvent(timestamp, movement, buttons, modifiers);
+        }
+        break;
+    }
+    case mir_pointer_action_enter:
+        mQtWindowSystem->handleEnterEvent(local_point, local_point);
+        break;
+    case mir_pointer_action_leave:
+        mQtWindowSystem->handleLeaveEvent(local_point);
+        break;
+    default:
+        qCDebug(QTMIR_MIR_INPUT) << "Unrecognized pointer event";
+    }
 }
 
 void QtEventFeeder::dispatchKey(MirInputEvent const* event)
 {
-    if (!mQtWindowSystem->hasTargetWindow())
-        return;
-
-    ulong timestamp = mir_input_event_get_event_time(event) / 1000000;
+    auto timestamp = qtmir::compressTimestamp<ulong>(std::chrono::nanoseconds(mir_input_event_get_event_time(event)));
 
     auto kev = mir_input_event_get_keyboard_event(event);
     xkb_keysym_t xk_sym = mir_keyboard_event_key_code(kev);
@@ -572,12 +637,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);
@@ -585,8 +655,9 @@
 
 void QtEventFeeder::dispatchTouch(MirInputEvent const* event)
 {
-    if (!mQtWindowSystem->hasTargetWindow())
-        return;
+    auto timestamp = std::chrono::nanoseconds(mir_input_event_get_event_time(event));
+
+    tracepoint(qtmirserver, touchEventDispatch_start, timestamp.count());
 
     auto tev = mir_input_event_get_touch_event(event);
     qCDebug(QTMIR_MIR_INPUT) << "Received" << qPrintable(mirTouchEventToString(tev));
@@ -594,54 +665,71 @@
     // 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);
+        }
     }
 
+    auto compressedTimestamp = qtmir::compressTimestamp<ulong>(timestamp);
+
     // 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, compressedTimestamp, 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,
+        compressedTimestamp,
         mTouchDevice,
         touchPoints);
+
+    tracepoint(qtmirserver, touchEventDispatch_end, timestamp.count());
 }
 
 void QtEventFeeder::start()
@@ -654,7 +742,7 @@
     // not used
 }
 
-void QtEventFeeder::validateTouches(ulong timestamp,
+void QtEventFeeder::validateTouches(QWindow *window, ulong timestamp,
         QList<QWindowSystemInterface::TouchPoint> &touchPoints)
 {
     QSet<int> updatedTouches;
@@ -678,7 +766,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;
@@ -696,7 +784,7 @@
     }
 }
 
-void QtEventFeeder::sendActiveTouchRelease(ulong timestamp, int id)
+void QtEventFeeder::sendActiveTouchRelease(QWindow *window, ulong timestamp, int id)
 {
     QList<QWindowSystemInterface::TouchPoint> touchPoints = mActiveTouches.values();
 
@@ -710,7 +798,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-08-11 12:08:32 +0000
+++ src/platforms/mirserver/qteventfeeder.h	2015-10-13 19:42:45 +0000
@@ -23,6 +23,7 @@
 #include <qpa/qwindowsysteminterface.h>
 
 class QTouchDevice;
+class ScreenController;
 
 /*
   Fills Qt's event loop with input events from Mir
@@ -33,26 +34,34 @@
     // 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 point, Qt::MouseButton buttons, Qt::KeyboardModifiers modifiers) = 0;
+        virtual void handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) = 0;
+        virtual void handleWheelEvent(ulong timestamp, const QPointF &localPoint, const QPointF &globalPoint,
+                                      QPoint pixelDelta, QPoint angleDelta,
+                                      Qt::KeyboardModifiers mods = Qt::NoModifier,
+                                      Qt::ScrollPhase phase = Qt::ScrollUpdate) = 0;
+        virtual void handleEnterEvent(const QPointF &localPoint = QPointF(), const QPointF &globalPoint = QPointF()) = 0;
+        virtual void handleLeaveEvent(const QPointF &localPoint = QPointF()) = 0;
     };
 
-    QtEventFeeder(QtWindowSystemInterface *windowSystem = nullptr);
+    QtEventFeeder(const QSharedPointer<ScreenController> &screenController);
+    QtEventFeeder(const QSharedPointer<ScreenController> &screenController,
+                  QtWindowSystemInterface *windowSystem);
     virtual ~QtEventFeeder();
 
     static const int MirEventActionMask;
@@ -67,9 +76,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-08-11 12:08:32 +0000
+++ src/platforms/mirserver/screen.cpp	2015-10-13 19:42:45 +0000
@@ -20,12 +20,13 @@
 
 // Mir
 #include "mir/geometry/size.h"
+#include "mir/graphics/buffer.h"
+#include "mir/graphics/display_buffer.h"
+#include "mir/graphics/display.h"
 
 // Qt
 #include <QCoreApplication>
 #include <qpa/qwindowsysteminterface.h>
-#include <QtSensors/QOrientationSensor>
-#include <QtSensors/QOrientationReading>
 #include <QThread>
 
 // Qt sensors
@@ -102,12 +103,15 @@
 
 bool Screen::skipDBusRegistration = false;
 
-Screen::Screen(mir::graphics::DisplayConfigurationOutput const &screen)
+Screen::Screen(const mir::graphics::DisplayConfigurationOutput &screen)
     : QObject(nullptr)
+    , m_displayBuffer(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 +143,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 +162,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 +181,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
@@ -226,3 +267,58 @@
                                               OrientationReadingEvent::m_type,
                                               m_orientationSensor->reading()->orientation()));
 }
+
+QPlatformCursor *Screen::cursor() const
+{
+    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_displayBuffer = buffer;
+    m_displayGroup = group;
+}
+
+void Screen::swapBuffers()
+{
+    m_displayBuffer->gl_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_displayBuffer->make_current();
+}
+
+void Screen::doneCurrent()
+{
+    m_displayBuffer->release_current();
+}

=== modified file 'src/platforms/mirserver/screen.h'
--- src/platforms/mirserver/screen.h	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/screen.h	2015-10-13 19:42:45 +0000
@@ -17,20 +17,28 @@
 #ifndef SCREEN_H
 #define SCREEN_H
 
+// Qt
 #include <QObject>
 #include <QTimer>
 #include <QtDBus/QDBusInterface>
 #include <qpa/qplatformscreen.h>
 
-#include "mir/graphics/display_configuration.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; }}
 
 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; }
@@ -40,8 +48,12 @@
     qreal refreshRate() const override { return m_refreshRate; }
     Qt::ScreenOrientation nativeOrientation() const override { return m_nativeOrientation; }
     Qt::ScreenOrientation orientation() const override { return m_currentOrientation; }
+    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;
@@ -54,20 +66,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::graphics::DisplayBuffer *m_displayBuffer;
+    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-13 19:42:45 +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-13 19:42:45 +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-08-11 12:08:32 +0000
+++ src/platforms/mirserver/screenwindow.cpp	2015-10-13 19:42:45 +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,94 +40,74 @@
     return ++id;
 }
 
-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_displayBuffer(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_displayBuffer->gl_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_displayBuffer->make_current();
-}
-
-void DisplayWindow::doneCurrent()
-{
-    m_displayBuffer->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-08-11 12:08:32 +0000
+++ src/platforms/mirserver/screenwindow.h	2015-10-13 19:42:45 +0000
@@ -14,43 +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 <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::graphics::DisplayBuffer *m_displayBuffer;
 };
 
-#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-13 19:42:45 +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-13 19:42:45 +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

=== modified file 'src/platforms/mirserver/tracepoints.tp'
--- src/platforms/mirserver/tracepoints.tp	2014-09-22 18:06:58 +0000
+++ src/platforms/mirserver/tracepoints.tp	2015-10-13 19:42:45 +0000
@@ -1,3 +1,5 @@
+#include <stdint.h>
+
 TRACEPOINT_EVENT(qtmirserver, starting, TP_ARGS(0), TP_FIELDS())
 TRACEPOINT_EVENT(qtmirserver, stopping, TP_ARGS(0), TP_FIELDS())
 TRACEPOINT_EVENT(qtmirserver, surfaceCreated, TP_ARGS(0), TP_FIELDS())
@@ -8,3 +10,6 @@
 
 TRACEPOINT_EVENT(qtmirserver, surfacePlacementStart, TP_ARGS(0), TP_FIELDS())
 TRACEPOINT_EVENT(qtmirserver, surfacePlacementEnd, TP_ARGS(0), TP_FIELDS())
+
+TRACEPOINT_EVENT(qtmirserver, touchEventDispatch_start, TP_ARGS(int64_t, event_time), TP_FIELDS(ctf_integer(int64_t, event_time, event_time)))
+TRACEPOINT_EVENT(qtmirserver, touchEventDispatch_end, TP_ARGS(int64_t, event_time), TP_FIELDS(ctf_integer(int64_t, event_time, event_time)))

=== 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-13 19:42:45 +0000
@@ -0,0 +1,73 @@
+/*
+ * 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
+};
+
+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
+};
+
+#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-13 19:42:45 +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-13 19:42:45 +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_buffer.h'
--- tests/common/mock_display_buffer.h	1970-01-01 00:00:00 +0000
+++ tests/common/mock_display_buffer.h	2015-10-13 19:42:45 +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 MOCK_DISPLAY_BUFFER_H