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

[Daniel d'Andrada]

Shell draws its own cursor using the new Cursor QML element

* Are there any related MPs required for this MP to build/function as expected? Please list.
https://code.launchpad.net/~dandrader/unity-api/mousePointer/+merge/271620
https://code.launchpad.net/~unity-team/unity8/mousePointer/+merge/273369

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

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

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

=== added file 'src/modules/Unity/Application/Cursor.qml'
=== added file 'src/modules/Unity/Application/cursorimageprovider.cpp'
I'm beginning to wonder if most of this code needs to live in qtmir at all. Since Unity8 draws it, why does QtMir need to do this work to find the image for it?

I also don't think it's QtMir's job to know anything about cursor themes.

Why doesn't QtMir just inform the shell of:
1. the position the cursor should be located at
2. the name of the desired cursor
Then unity8 can find the themed cursor image, figure out the hotspot and draw the cursor itself.

review: Needs Information

[Gerry Boland (gerboland)]

=== added file 'demos/qml-demo-shell/ResizeArea.qml'
I like your code, neat and clean as always. But if I was writing this, I would have a single MouseArea behind the surface, instead of 8. It's ok for a demo, but that's a lot for a real shell.

[Daniel d'Andrada (dandrader)]

> === added file 'demos/qml-demo-shell/ResizeArea.qml'
> I like your code, neat and clean as always. But if I was writing this, I would
> have a single MouseArea behind the surface, instead of 8. It's ok for a demo,
> but that's a lot for a real shell.

If I recall correctly, the main reason was because of the MouseArea.cursorShape property. If you set it, the cursor will automatically assume the given shape when hovering the mouse area. So I cannot be a single one.

But later on the cursor shape enumeration proved insufficient for exposing all the different shapes unity uses, forcing me to introduce the Mir.cursorName API.

So yeah, now that I've given up using MouseArea.cursorShape, maybe I could use a single mouse area.

[Daniel d'Andrada (dandrader)]

> > === added file 'demos/qml-demo-shell/ResizeArea.qml'
> > I like your code, neat and clean as always. But if I was writing this, I
> would
> > have a single MouseArea behind the surface, instead of 8. It's ok for a
> demo,
> > but that's a lot for a real shell.
>
> If I recall correctly, the main reason was because of the
> MouseArea.cursorShape property. If you set it, the cursor will automatically
> assume the given shape when hovering the mouse area. So I cannot be a single
> one.
>
> But later on the cursor shape enumeration proved insufficient for exposing all
> the different shapes unity uses, forcing me to introduce the Mir.cursorName
> API.
>
> So yeah, now that I've given up using MouseArea.cursorShape, maybe I could use
> a single mouse area.

FYI: I also copy-pasted ResizeArea.qml into unity8/mousePointer

[Daniel d'Andrada (dandrader)]

> === added file 'src/modules/Unity/Application/Cursor.qml'
> === added file 'src/modules/Unity/Application/cursorimageprovider.cpp'
> I'm beginning to wonder if most of this code needs to live in qtmir at all.
> Since Unity8 draws it, why does QtMir need to do this work to find the image
> for it?
>
> I also don't think it's QtMir's job to know anything about cursor themes.
>
>
> Why doesn't QtMir just inform the shell of:
> 1. the position the cursor should be located at
> 2. the name of the desired cursor
> Then unity8 can find the themed cursor image, figure out the hotspot and draw
> the cursor itself.

Following the same rationale, one might also argue: "Why does qtmir has to know about application processes and upstart at all? let unity8 figure it out. qtmir should just spit out Sessions, MirSurfaces and MirSurfaceItems".

Also, by having this in qtmir, we pretty much shield unity8 from architectural changes down the road, once we ditch the QML cursor approach in favor of a unity-system-settings one.

[Daniel d'Andrada (dandrader)]

On 02/09/15 13:16, Gerry Boland wrote:
> === added file 'demos/qml-demo-shell/ResizeArea.qml'
> I like your code, neat and clean as always. But if I was writing this, I would have a single MouseArea behind the surface, instead of 8. It's ok for a demo, but that's a lot for a real shell.
>
>

Fixed. Will do likewise in untiy8 tomorrow.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

> > === added file 'src/modules/Unity/Application/Cursor.qml'
> > === added file 'src/modules/Unity/Application/cursorimageprovider.cpp'
> > I'm beginning to wonder if most of this code needs to live in qtmir at all.
> > Since Unity8 draws it, why does QtMir need to do this work to find the image
> > for it?
> >
> > I also don't think it's QtMir's job to know anything about cursor themes.
> >
> >
> > Why doesn't QtMir just inform the shell of:
> > 1. the position the cursor should be located at
> > 2. the name of the desired cursor
> > Then unity8 can find the themed cursor image, figure out the hotspot and
> draw
> > the cursor itself.
>
> Following the same rationale, one might also argue: "Why does qtmir has to
> know about application processes and upstart at all? let unity8 figure it out.
> qtmir should just spit out Sessions, MirSurfaces and MirSurfaceItems".

Actually that's the longer-term goal.
https://trello.com/c/4uBsKNVT/133-split-applicationmanager-out-of-qtmir
Zanetti wants to move such logic into Unity itself. This will make QtMir a thin wrapper of Mir functionality for Qt users, which is a much clearer purpose than what it currently has.

If somebody would like to make their own shell, then can make use of QtMir without being forced to use upstart for instance. If they want to use upstart, then they can use the Unity.Application plugin.

> Also, by having this in qtmir, we pretty much shield unity8 from architectural
> changes down the road, once we ditch the QML cursor approach in favor of a
> unity-system-settings one.

I don't think that will happen. We need the shell to manage the cursor position, in order to do fancy things like edge-push detection, slowing cursor over buttons (a11y) or moving cursor with keyboard (a11y).

My main reasons for wanting USC to draw cursor were:
1. latency, cursor will react as quickly as possible
2. hardware compositing, cursor lives in a special hardware buffer which the hardware composites on top of everything. Means moving cursor doesn't require entire screen re-renders.

Mir team have plans for both problems
1. not use the mir protobuf for input, but have unity8 open socket with event stream coming in. Should reduce latency
2. Mir adding API to allow shell to designate certain buffers/surfaces as being hardware composable. Cursor will definitely be one of those, if available.

[Daniel d'Andrada (dandrader)]

Ok, moved all Cursor stuff from qtmir to unity8.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

=== modified file 'debian/copyright'
can undo this.

[Daniel d'Andrada (dandrader)]

On 09/09/15 07:57, Gerry Boland wrote:
> === modified file 'debian/copyright'
> can undo this.
Done.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

Ok ignore my relativeMovement thing. I'll not object to the usual terminology.

However I fear I need to ask you to rebase on top of
https://code.launchpad.net/~gerboland/qtmir/multimonitor/+merge/269906
as there's a few conflicts, and the concept of multiple qwindows does make this more complex.

+ // We will draw our own cursor.
+ add_init_callback([this](){ the_cursor()->hide(); });
This isn't great, as the mir cursor object is still being created. Can we replace Mir's implementation with our own one? -- not a blocker on this MR, can consider this later.

++ src/platforms/mirserver/mirsingleton.cpp
+qtmir::Mir::~Mir()
+{
+ m_instance = nullptr;
+}
You're not deleting what you potentially "new"ed. QScopedPointer helps prevent such accidents...

+++ src/platforms/mirserver/mirsingleton.h
+private:
+ Mir();
maybe http://doc.qt.io/qt-5/qobject.html#Q_DISABLE_COPY

Using this Mir singleton to save the cursorName will do fine for now, but I'm wary of it being a dumping ground for lots of little things.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[Daniel d'Andrada (dandrader)]

On 09/09/15 10:36, Gerry Boland wrote:
> Review: Needs Fixing
>
> Ok ignore my relativeMovement thing. I'll not object to the usual terminology.
>
> However I fear I need to ask you to rebase on top of
> https://code.launchpad.net/~gerboland/qtmir/multimonitor/+merge/269906
> as there's a few conflicts, and the concept of multiple qwindows does make this more complex.

Done.

>
> + // We will draw our own cursor.
> + add_init_callback([this](){ the_cursor()->hide(); });
> This isn't great, as the mir cursor object is still being created. Can we replace Mir's implementation with our own one? -- not a blocker on this MR, can consider this later.

This will be the u-s-c cursor, and u-s-c will always have its own cursor
no matter what, I think. Don't think it's worth investigating this idea.

>
> ++ src/platforms/mirserver/mirsingleton.cpp
> +qtmir::Mir::~Mir()
> +{
> + m_instance = nullptr;
> +}
> You're not deleting what you potentially "new"ed. QScopedPointer helps prevent such accidents...

I am. The only place that does "new Mir" is Mir::instance() and it's
done only once. This is a simple, no-nonsense, singleton implementation
that does its job AFAICT. You want the global, static, Mir::m_instance
to be a QScopedPointer? I fail to see how would that work and how it
would be better than the current code. If you really want to see a
QScopedPointer there please give me a diff as I didn't get the point.

>
> +++ src/platforms/mirserver/mirsingleton.h
> +private:
> + Mir();
> maybe http://doc.qt.io/qt-5/qobject.html#Q_DISABLE_COPY

Done.

> Using this Mir singleton to save the cursorName will do fine for now, but I'm wary of it being a dumping ground for lots of little things.

Yes, Mir.cursorName is surely not the best solution but anything better
would require way more work. This is like a stop-gap measure. Also given
the uncertainty of the current cursor approach (as we will eventually
move to u-s-c cursor) I didn't want to invest a lot of effort on
something that could evaporate in the near term.

[Daniel d'Andrada (dandrader)]

removed the multimonitor branch as a prerequisite as it still has issues.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:376
http://jenkins.qa.ubuntu.com/job/qtmir-ci/436/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/132/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/132/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/14/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/169/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/169/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/14/console

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

review: Needs Fixing (continuous-integration)

[Lukáš Tinkl (lukas-kde)]

The text input cursor (ibeam) is not mapped correctly; to xterm?

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

Replied to inline comment

[Daniel d'Andrada (dandrader)]

> The text input cursor (ibeam) is not mapped correctly; to xterm?

It's mapped correctly, as I commented in the inline diff.

PS: Could please refrain from using inline comments in the future (for my MPs at least). I find it a badly implemented feature in launchpad. It's disjointed from the main comments and is kinda lost in the middle of the diff (there are hotkeys to jump between diff comments, but I find it gimmicky)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:377
http://jenkins.qa.ubuntu.com/job/qtmir-ci/439/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/135/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/135/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/17/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/172/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/172/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/17/console

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

review: Needs Fixing (continuous-integration)

[Lukáš Tinkl (lukas-kde)]

> > The text input cursor (ibeam) is not mapped correctly; to xterm?
>
> It's mapped correctly, as I commented in the inline diff.

I see, thanks for the explanation

> PS: Could please refrain from using inline comments in the future (for my MPs
> at least). I find it a badly implemented feature in launchpad. It's disjointed
> from the main comments and is kinda lost in the middle of the diff (there are
> hotkeys to jump between diff comments, but I find it gimmicky)

Noted

review: Abstain

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:378
http://jenkins.qa.ubuntu.com/job/qtmir-ci/440/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/136/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/136/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/18/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/173/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/173/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/18/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:379
http://jenkins.qa.ubuntu.com/job/qtmir-ci/450/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/146/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/146/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/28/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/183/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/183/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/28/console

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

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

Have tested this with silo22, it's working good. Code is good. LGTM

review: Approve

[Lukáš Tinkl (lukas-kde)]

bool Cursor::handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButton buttons,...)

Needs changing from Qt::MouseButton -> Qt::MouseButtons as the latter is expected by methods in QWindowSystemInterface. A single "button" would prevent stuff like emulating middle mouse click by pressing both left and right mouse buttons at once.

review: Needs Fixing

[lp:~dandrader/qtmir/mousePointer]

380. By Daniel d'Andrada on 2015-10-13

s/Qt::MouseButton/Qt::MouseButtons

[Daniel d'Andrada (dandrader)]

> bool Cursor::handleMouseEvent(ulong timestamp, QPointF movement,
> Qt::MouseButton buttons,...)
>
> Needs changing from Qt::MouseButton -> Qt::MouseButtons as the latter is
> expected by methods in QWindowSystemInterface. A single "button" would prevent
> stuff like emulating middle mouse click by pressing both left and right mouse
> buttons at once.

Fixed.

[Lukáš Tinkl (lukas-kde)]

LGTM

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:380
http://jenkins.qa.ubuntu.com/job/qtmir-ci/512/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/208/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/208/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/90/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/245/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/245/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/90/console

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

review: Needs Fixing (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-09-17 20:17:17 +0000
+++ CMakeLists.txt	2015-10-13 20:19:37 +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})
 

=== modified file 'debian/control'
--- debian/control	2015-09-25 12:11:08 +0000
+++ debian/control	2015-10-13 20:19:37 +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,7 +93,7 @@
 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

=== 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 20:19:37 +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;
+            }
+        }
+    }
+}
+

=== 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 20:19:37 +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 20:19:37 +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 {

=== modified file 'demos/qml-demo-shell/qml-demo-shell.qml'
--- demos/qml-demo-shell/qml-demo-shell.qml	2015-08-31 09:51:28 +0000
+++ demos/qml-demo-shell/qml-demo-shell.qml	2015-10-13 20:19:37 +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 '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 20:19:37 +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/plugin.cpp'
--- src/modules/Unity/Application/plugin.cpp	2015-08-31 09:51:28 +0000
+++ src/modules/Unity/Application/plugin.cpp	2015-10-13 20:19:37 +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/platforms/mirserver/CMakeLists.txt'
--- src/platforms/mirserver/CMakeLists.txt	2015-08-11 19:25:04 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2015-10-13 20:19:37 +0000
@@ -41,7 +41,9 @@
 
 set(MIRSERVER_QPA_PLUGIN_SRC
     ${CMAKE_SOURCE_DIR}/src/common/debughelpers.cpp
+    cursor.cpp
     mirwindowmanager.cpp
+    mirsingleton.cpp
     qteventfeeder.cpp
     plugin.cpp
     qmirserver.cpp
@@ -63,6 +65,8 @@
     ubuntutheme.cpp
     clipboard.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 +86,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 20:19:37 +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::MouseButtons, buttons),
+        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 20:19:37 +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

=== 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 20:19:37 +0000
@@ -32,6 +32,9 @@
 // egl
 #include <EGL/egl.h>
 
+// mir
+#include <mir/graphics/cursor.h>
+
 namespace mo  = mir::options;
 namespace msh = mir::shell;
 namespace ms = mir::scene;
@@ -100,6 +103,9 @@
 
     apply_settings();
 
+    // We will draw our own cursor.
+    add_init_callback([this](){ the_cursor()->hide(); });
+
     qCDebug(QTMIR_MIR_MESSAGES) << "MirServer created";
 }
 

=== 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 20:19:37 +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 20:19:37 +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

=== 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 20:19:37 +0000
@@ -15,7 +15,9 @@
  */
 
 #include "qteventfeeder.h"
+#include "cursor.h"
 #include "logging.h"
+#include "screen.h"
 
 #include <qpa/qplatforminputcontext.h>
 #include <qpa/qplatformintegration.h>
@@ -366,6 +368,13 @@
 namespace {
 
 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::MouseButtons>("Qt::MouseButtons");
+    }
 
     bool hasTargetWindow() override
     {
@@ -404,11 +413,11 @@
         QWindowSystemInterface::handleTouchEvent(mTopLevelWindow.data(), timestamp, device, points, mods);
     }
 
-    void handleMouseEvent(ulong timestamp, QPointF point, Qt::MouseButton buttons, Qt::KeyboardModifiers modifiers) override
+    void handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons 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);
+        auto platformCursor = static_cast<qtmir::Cursor*>(mTopLevelWindow->screen()->handle()->cursor());
+        platformCursor->handleMouseEvent(timestamp, movement, buttons, modifiers);
     }
 
 
@@ -488,9 +497,9 @@
     return static_cast<Qt::KeyboardModifiers>(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,7 +511,7 @@
     if (mir_pointer_event_button_state(pev, mir_pointer_button_forward))
         buttons |= Qt::ForwardButton;
 
-    return static_cast<Qt::MouseButton>(buttons);
+    return buttons;
 }
 }
 
@@ -518,12 +527,10 @@
 
     auto modifiers = getQtModifiersFromMir(mir_pointer_event_modifiers(pev));
     auto buttons = getQtMouseButtonsfromMirPointerEvent(pev);
-
-    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);
+    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));
+
+    mQtWindowSystem->handleMouseEvent(timestamp, movement, buttons, modifiers);
 }
 
 void QtEventFeeder::dispatchKey(MirInputEvent const* event)

=== 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 20:19:37 +0000
@@ -49,7 +49,8 @@
         virtual void handleTouchEvent(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;
     };
 
     QtEventFeeder(QtWindowSystemInterface *windowSystem = nullptr);

=== 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 20:19:37 +0000
@@ -226,3 +226,9 @@
                                               OrientationReadingEvent::m_type,
                                               m_orientationSensor->reading()->orientation()));
 }
+
+QPlatformCursor *Screen::cursor() const
+{
+    const QPlatformCursor *platformCursor = &m_cursor;
+    return const_cast<QPlatformCursor *>(platformCursor);
+}

=== 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 20:19:37 +0000
@@ -22,7 +22,9 @@
 #include <QtDBus/QDBusInterface>
 #include <qpa/qplatformscreen.h>
 
-#include "mir/graphics/display_configuration.h"
+#include <mir/graphics/display_configuration.h>
+
+#include "cursor.h"
 
 class QOrientationSensor;
 
@@ -40,6 +42,7 @@
     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;
 
@@ -68,6 +71,8 @@
     QOrientationSensor *m_orientationSensor;
 
     QDBusInterface *m_unityScreen;
+
+    qtmir::Cursor m_cursor;
 };
 
 #endif // SCREEN_H

=== modified file 'tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h'
--- tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2015-04-01 15:02:36 +0000
+++ tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2015-10-13 20:19:37 +0000
@@ -34,7 +34,7 @@
     MOCK_METHOD4(handleTouchEvent, void(ulong timestamp, QTouchDevice *device,
             const QList<struct QWindowSystemInterface::TouchPoint> &points,
             Qt::KeyboardModifiers mods));
-    MOCK_METHOD4(handleMouseEvent, void(ulong, QPointF, Qt::MouseButton, Qt::KeyboardModifiers));
+    MOCK_METHOD4(handleMouseEvent, void(ulong, QPointF, Qt::MouseButtons, Qt::KeyboardModifiers));
 };
 
 namespace testing