Merge lp:~lukas-kde/unity8/activateWindows into lp:unity8

[Lukáš Tinkl]

Correctly activate windows from spread and when clicking their decoration

Activate/focus windows when clicking on their decoration and raise/restore them
when activating from the spread.

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

No

* 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

[Daniel d'Andrada (dandrader)]

Please follow the commit message format as explained here: https://wiki.ubuntu.com/Process/Merges/Checklists/Unity8

[Lukáš Tinkl (lukas-kde)]

> Please follow the commit message format as explained here:
> https://wiki.ubuntu.com/Process/Merges/Checklists/Unity8

Should be fine now

[Daniel d'Andrada (dandrader)]

Could you please add qml tests to cover those use cases you mention (ie active focus when clicking on decoration and raise/restore when activation from spread)?

I believe we already have a test for the first one (focus when clicking decoration). We had similar problems in the past before. Should investigate why it passes now even though there's a bug there (maybe it tests only with touches and not with mouse clicks, don't know).

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

Oh, and it's worth making lp:~unity-team/unity8/mousePointer from silo 022 a prerequisite as it makes a lot of changes in this code.

[Daniel d'Andrada (dandrader)]

> > Please follow the commit message format as explained here:
> > https://wiki.ubuntu.com/Process/Merges/Checklists/Unity8
>
> Should be fine now

Yes, thanks!

[lp:~lukas-kde/unity8/activateWindows]

2006. By Lukáš Tinkl on 2015-10-19

merge lp:~unity-team/unity8/mousePointer, fix conflicts, move the logic

2007. By Lukáš Tinkl on 2015-10-19

fix warning

2008. By Lukáš Tinkl on 2015-10-19

fix immediate grab cursor when just clicking

2009. By Lukáš Tinkl on 2015-10-19

merge lp:~unity-team/unity8/mousePointer

2010. By Lukáš Tinkl on 2015-10-19

reaise the window on resize click too

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2005
http://jenkins.qa.ubuntu.com/job/unity8-ci/6488/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/4701
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-wily-touch/870
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/1200
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-wily/516
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/1095
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/1096
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-wily-amd64-ci/727
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-wily-i386-ci/728
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/3794
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/4698
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/4698/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/24339
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-wily-mako/514
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-wily-armhf/870
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-wily-armhf/870/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/24336

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

review: Needs Fixing (continuous-integration)

[lp:~lukas-kde/unity8/activateWindows]

2011. By Lukáš Tinkl on 2015-10-19

rename unminimize() to restore()

maintan the focus stack to switch between the apps when an app
is minimized or restored

2012. By Lukáš Tinkl on 2015-10-19

update the focus stack when the focused app id changes

2013. By Lukáš Tinkl on 2015-10-19

add a test for clicking to get focus (instead of tap)

simplify the foreach loops

2014. By Lukáš Tinkl on 2015-10-20

provide shortcuts for common window operations

2015. By Lukáš Tinkl on 2015-10-20

don't special case for dash, clear and reset the focus stack when we minimizeAll()

2016. By Lukáš Tinkl on 2015-10-20

add tests for maximize and minimize an app

2017. By Lukáš Tinkl on 2015-10-20

always focus the first app in the stack, based on recency

2018. By Lukáš Tinkl on 2015-10-20

add tests for minimizeAll and close

2019. By Lukáš Tinkl on 2015-10-20

add tests for maximizeLeft/Right

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

simplify code, minimize delta

2021. By Lukáš Tinkl on 2015-10-26

merge trunk

2022. By Lukáš Tinkl on 2015-10-26

merge lp:~mzanetti/unity8/panel-button-fixes

2023. By Lukáš Tinkl on 2015-10-26

display the maximized window's title in the panel, next to the buttons

2024. By Lukáš Tinkl on 2015-10-27

merge prereq to fix failing tests

2025. By Lukáš Tinkl on 2015-10-27

elide the window title in the title bar

2026. By Lukáš Tinkl on 2015-10-29

silence warnings

2027. By Lukáš Tinkl on 2015-10-30

fix issues found by mzanetti

additionally properly restore windows from minimized state to the correct
previous state (maximized, maximizedLeft/Right)

2028. By Lukáš Tinkl on 2015-10-30

fix restoring the apps from spread to the correct state and size

potential fix for the Alt+F4 shortcut problem

2029. By Lukáš Tinkl on 2015-11-01

fix click to focus

2030. By Lukáš Tinkl on 2015-11-02

take the panel height into account when semimaximizing windows

2031. By Lukáš Tinkl on 2015-11-02

add a test to prove smashing all the 4 cursor keys together does nothing :)

2032. By Lukáš Tinkl on 2015-11-02

make sure to play the minimized animation before switching focus to next

2033. By Lukáš Tinkl on 2015-11-06

merge trunk

2034. By Lukáš Tinkl on 2015-11-06

cleanup

2035. By Lukáš Tinkl on 2015-11-06

cleanup

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-09-30 16:49:52 +0000
+++ CMakeLists.txt	2015-10-19 14:53:23 +0000
@@ -57,7 +57,7 @@
 find_package(Qt5Concurrent 5.2 REQUIRED)
 find_package(Qt5Sql 5.2 REQUIRED)
 
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application>=8)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=9)
 
 # Standard install paths
 include(GNUInstallDirs)
 
=== modified file 'debian/control'
--- debian/control	2015-09-23 18:15:40 +0000
+++ debian/control	2015-10-19 14:53:23 +0000
@@ -25,10 +25,11 @@
                libpay2-dev,
                libpulse-dev,
                libqmenumodel-dev (>= 0.2.9),
+               libqt5svg5-dev,
                libqt5xmlpatterns5-dev,
                libsystemsettings-dev,
                libudev-dev,
-               libunity-api-dev (>= 7.100),
+               libunity-api-dev (>= 7.101),
                libusermetricsoutput1-dev,
                libxcb1-dev,
                pkg-config,
@@ -87,7 +88,8 @@
 Package: unity8
 Architecture: any
 Provides: indicator-renderer,
-Depends: gsettings-desktop-schemas,
+Depends: dmz-cursor-theme,
+         gsettings-desktop-schemas,
          libcap2-bin,
          libglib2.0-bin,
          qmenumodel-qml (>= 0.2.9),
@@ -125,7 +127,7 @@
          qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.1.1239) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.1.1239),
          qtdeclarative5-unity-notifications-plugin (>= 0.1.2) | unity-notifications-impl,
          ubuntu-thumbnailer-impl-0,
-         unity-application-impl-8,
+         unity-application-impl-9,
          unity-notifications-impl-3,
          unity-plugin-scopes | unity-scopes-impl,
          unity-scopes-impl-7,
@@ -171,7 +173,7 @@
 Depends: ${misc:Depends},
          ${shlibs:Depends},
 Provides: unity-application-impl,
-          unity-application-impl-8,
+          unity-application-impl-9,
 Replaces: unity8-autopilot (<< 8.02+15.04.20150422-0ubuntu1)
 Description: Fake environment for running Unity 8 shell
  Provides fake implementations of some QML modules used by Unity 8 shell
 
=== modified file 'debian/copyright'
--- debian/copyright	2014-06-11 15:36:51 +0000
+++ debian/copyright	2015-10-19 14:53:23 +0000
@@ -60,3 +60,24 @@
  packaging of this file.  Please review the following information to
  ensure the GNU General Public License version 3.0 requirements will be
  met: http://www.gnu.org/copyleft/gpl.html.
+
+Files: plugins/Cursor/3rd_party/xcursor/xcursor.*
+Copyright: 2002 Keith Packard
+License: Keith Packard
+ Permission to use, copy, modify, distribute, and sell this software and its
+ documentation for any purpose is hereby granted without fee, provided that
+ the above copyright notice appear in all copies and that both that
+ copyright notice and this permission notice appear in supporting
+ documentation, and that the name of Keith Packard not be used in
+ advertising or publicity pertaining to distribution of the software without
+ specific, written prior permission.  Keith Packard makes no
+ representations about the suitability of this software for any purpose.  It
+ is provided "as is" without express or implied warranty.
+ .
+ KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ PERFORMANCE OF THIS SOFTWARE.
 
=== modified file 'debian/unity8-private.install'
--- debian/unity8-private.install	2015-09-02 09:30:32 +0000
+++ debian/unity8-private.install	2015-10-19 14:53:23 +0000
@@ -1,6 +1,7 @@
 usr/lib/*/libunity8-private.*
 usr/lib/*/unity8/libUbuntuGestures*
 usr/lib/*/unity8/qml/AccountsService
+usr/lib/*/unity8/qml/Cursor
 usr/lib/*/unity8/qml/Dash
 usr/lib/*/unity8/qml/GlobalShortcut
 usr/lib/*/unity8/qml/Greeter
 
=== modified file 'plugins/CMakeLists.txt'
--- plugins/CMakeLists.txt	2015-09-02 09:30:32 +0000
+++ plugins/CMakeLists.txt	2015-10-19 14:53:23 +0000
@@ -12,6 +12,7 @@
 endmacro()
 
 add_subdirectory(AccountsService)
+add_subdirectory(Cursor)
 add_subdirectory(GlobalShortcut)
 add_subdirectory(Greeter)
 add_subdirectory(IntegratedLightDM)
 
=== added directory 'plugins/Cursor'
=== added directory 'plugins/Cursor/3rd_party'
=== added file 'plugins/Cursor/3rd_party/CMakeLists.txt'
--- plugins/Cursor/3rd_party/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/3rd_party/CMakeLists.txt	2015-10-19 14:53:23 +0000
@@ -0,0 +1,1 @@
+add_subdirectory(xcursor)
 
=== added directory 'plugins/Cursor/3rd_party/xcursor'
=== added file 'plugins/Cursor/3rd_party/xcursor/CMakeLists.txt'
--- plugins/Cursor/3rd_party/xcursor/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/3rd_party/xcursor/CMakeLists.txt	2015-10-19 14:53:23 +0000
@@ -0,0 +1,15 @@
+add_definitions(-D_DEFAULT_SOURCE=1)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+
+set(
+  XCURSOR_SOURCES
+
+  xcursor.c
+)
+
+add_library(
+  xcursorloader-static STATIC
+
+  ${XCURSOR_SOURCES}
+)
 
=== added file 'plugins/Cursor/3rd_party/xcursor/xcursor.c'
--- plugins/Cursor/3rd_party/xcursor/xcursor.c	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/3rd_party/xcursor/xcursor.c	2015-10-19 14:53:23 +0000
@@ -0,0 +1,968 @@
+/*
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "xcursor.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+
+/*
+ * From libXcursor/include/X11/extensions/Xcursor.h
+ */
+
+#define XcursorTrue    1
+#define XcursorFalse    0
+
+/*
+ * Cursor files start with a header.  The header
+ * contains a magic number, a version number and a
+ * table of contents which has type and offset information
+ * for the remaining tables in the file.
+ *
+ * File minor versions increment for compatible changes
+ * File major versions increment for incompatible changes (never, we hope)
+ *
+ * Chunks of the same type are always upward compatible.  Incompatible
+ * changes are made with new chunk types; the old data can remain under
+ * the old type.  Upward compatible changes can add header data as the
+ * header lengths are specified in the file.
+ *
+ *  File:
+ *    FileHeader
+ *    LISTofChunk
+ *
+ *  FileHeader:
+ *    CARD32        magic        magic number
+ *    CARD32        header        bytes in file header
+ *    CARD32        version        file version
+ *    CARD32        ntoc        number of toc entries
+ *    LISTofFileToc   toc        table of contents
+ *
+ *  FileToc:
+ *    CARD32        type        entry type
+ *    CARD32        subtype        entry subtype (size for images)
+ *    CARD32        position    absolute file position
+ */
+
+#define XCURSOR_MAGIC    0x72756358  /* "Xcur" LSBFirst */
+
+/*
+ * Current Xcursor version number.  Will be substituted by configure
+ * from the version in the libXcursor configure.ac file.
+ */
+
+#define XCURSOR_LIB_MAJOR 1
+#define XCURSOR_LIB_MINOR 1
+#define XCURSOR_LIB_REVISION 13
+#define XCURSOR_LIB_VERSION    ((XCURSOR_LIB_MAJOR * 10000) + \
+                 (XCURSOR_LIB_MINOR * 100) + \
+                 (XCURSOR_LIB_REVISION))
+
+/*
+ * This version number is stored in cursor files; changes to the
+ * file format require updating this version number
+ */
+#define XCURSOR_FILE_MAJOR    1
+#define XCURSOR_FILE_MINOR    0
+#define XCURSOR_FILE_VERSION    ((XCURSOR_FILE_MAJOR << 16) | (XCURSOR_FILE_MINOR))
+#define XCURSOR_FILE_HEADER_LEN    (4 * 4)
+#define XCURSOR_FILE_TOC_LEN    (3 * 4)
+
+typedef struct _XcursorFileToc {
+    XcursorUInt        type;    /* chunk type */
+    XcursorUInt        subtype;    /* subtype (size for images) */
+    XcursorUInt        position;    /* absolute position in file */
+} XcursorFileToc;
+
+typedef struct _XcursorFileHeader {
+    XcursorUInt        magic;    /* magic number */
+    XcursorUInt        header;    /* byte length of header */
+    XcursorUInt        version;    /* file version number */
+    XcursorUInt        ntoc;    /* number of toc entries */
+    XcursorFileToc  *tocs;    /* table of contents */
+} XcursorFileHeader;
+
+/*
+ * The rest of the file is a list of chunks, each tagged by type
+ * and version.
+ *
+ *  Chunk:
+ *    ChunkHeader
+ *    <extra type-specific header fields>
+ *    <type-specific data>
+ *
+ *  ChunkHeader:
+ *    CARD32        header    bytes in chunk header + type header
+ *    CARD32        type    chunk type
+ *    CARD32        subtype    chunk subtype
+ *    CARD32        version    chunk type version
+ */
+
+#define XCURSOR_CHUNK_HEADER_LEN    (4 * 4)
+
+typedef struct _XcursorChunkHeader {
+    XcursorUInt        header;    /* bytes in chunk header */
+    XcursorUInt        type;    /* chunk type */
+    XcursorUInt        subtype;    /* chunk subtype (size for images) */
+    XcursorUInt        version;    /* version of this type */
+} XcursorChunkHeader;
+
+/*
+ * Here's a list of the known chunk types
+ */
+
+/*
+ * Comments consist of a 4-byte length field followed by
+ * UTF-8 encoded text
+ *
+ *  Comment:
+ *    ChunkHeader header    chunk header
+ *    CARD32        length    bytes in text
+ *    LISTofCARD8 text    UTF-8 encoded text
+ */
+
+#define XCURSOR_COMMENT_TYPE        0xfffe0001
+#define XCURSOR_COMMENT_VERSION        1
+#define XCURSOR_COMMENT_HEADER_LEN  (XCURSOR_CHUNK_HEADER_LEN + (1 *4))
+#define XCURSOR_COMMENT_COPYRIGHT   1
+#define XCURSOR_COMMENT_LICENSE        2
+#define XCURSOR_COMMENT_OTHER        3
+#define XCURSOR_COMMENT_MAX_LEN        0x100000
+
+typedef struct _XcursorComment {
+    XcursorUInt        version;
+    XcursorUInt        comment_type;
+    char        *comment;
+} XcursorComment;
+
+/*
+ * Each cursor image occupies a separate image chunk.
+ * The length of the image header follows the chunk header
+ * so that future versions can extend the header without
+ * breaking older applications
+ *
+ *  Image:
+ *    ChunkHeader    header    chunk header
+ *    CARD32        width    actual width
+ *    CARD32        height    actual height
+ *    CARD32        xhot    hot spot x
+ *    CARD32        yhot    hot spot y
+ *    CARD32        delay    animation delay
+ *    LISTofCARD32    pixels    ARGB pixels
+ */
+
+#define XCURSOR_IMAGE_TYPE            0xfffd0002
+#define XCURSOR_IMAGE_VERSION        1
+#define XCURSOR_IMAGE_HEADER_LEN    (XCURSOR_CHUNK_HEADER_LEN + (5*4))
+#define XCURSOR_IMAGE_MAX_SIZE        0x7fff    /* 32767x32767 max cursor size */
+
+typedef struct _XcursorFile XcursorFile;
+
+struct _XcursorFile {
+    void    *closure;
+    int        (*read)  (XcursorFile *file, unsigned char *buf, int len);
+    int        (*write) (XcursorFile *file, unsigned char *buf, int len);
+    int        (*seek)  (XcursorFile *file, long offset, int whence);
+};
+
+typedef struct _XcursorComments {
+    int            ncomment;    /* number of comments */
+    XcursorComment  **comments;    /* array of XcursorComment pointers */
+} XcursorComments;
+
+/*
+ * From libXcursor/src/file.c
+ */
+
+static XcursorImage *
+XcursorImageCreate (int width, int height)
+{
+    XcursorImage    *image;
+
+    image = malloc (sizeof (XcursorImage) +
+            width * height * sizeof (XcursorPixel));
+    if (!image)
+    return NULL;
+    image->version = XCURSOR_IMAGE_VERSION;
+    image->pixels = (XcursorPixel *) (image + 1);
+    image->size = width > height ? width : height;
+    image->width = width;
+    image->height = height;
+    image->delay = 0;
+    return image;
+}
+
+static void
+XcursorImageDestroy (XcursorImage *image)
+{
+    free (image);
+}
+
+static XcursorImages *
+XcursorImagesCreate (int size)
+{
+    XcursorImages   *images;
+
+    images = malloc (sizeof (XcursorImages) +
+             size * sizeof (XcursorImage *));
+    if (!images)
+    return NULL;
+    images->nimage = 0;
+    images->images = (XcursorImage **) (images + 1);
+    images->name = NULL;
+    return images;
+}
+
+void
+XcursorImagesDestroy (XcursorImages *images)
+{
+    int    n;
+
+    if (!images)
+        return;
+
+    for (n = 0; n < images->nimage; n++)
+    XcursorImageDestroy (images->images[n]);
+    if (images->name)
+    free (images->name);
+    free (images);
+}
+
+static void
+XcursorImagesSetName (XcursorImages *images, const char *name)
+{
+    char    *new;
+
+    if (!images || !name)
+        return;
+
+    new = malloc (strlen (name) + 1);
+
+    if (!new)
+    return;
+
+    strcpy (new, name);
+    if (images->name)
+    free (images->name);
+    images->name = new;
+}
+
+static XcursorBool
+_XcursorReadUInt (XcursorFile *file, XcursorUInt *u)
+{
+    unsigned char   bytes[4];
+
+    if (!file || !u)
+        return XcursorFalse;
+
+    if ((*file->read) (file, bytes, 4) != 4)
+    return XcursorFalse;
+    *u = ((bytes[0] << 0) |
+      (bytes[1] << 8) |
+      (bytes[2] << 16) |
+      (bytes[3] << 24));
+    return XcursorTrue;
+}
+
+static void
+_XcursorFileHeaderDestroy (XcursorFileHeader *fileHeader)
+{
+    free (fileHeader);
+}
+
+static XcursorFileHeader *
+_XcursorFileHeaderCreate (int ntoc)
+{
+    XcursorFileHeader    *fileHeader;
+
+    if (ntoc > 0x10000)
+    return NULL;
+    fileHeader = malloc (sizeof (XcursorFileHeader) +
+             ntoc * sizeof (XcursorFileToc));
+    if (!fileHeader)
+    return NULL;
+    fileHeader->magic = XCURSOR_MAGIC;
+    fileHeader->header = XCURSOR_FILE_HEADER_LEN;
+    fileHeader->version = XCURSOR_FILE_VERSION;
+    fileHeader->ntoc = ntoc;
+    fileHeader->tocs = (XcursorFileToc *) (fileHeader + 1);
+    return fileHeader;
+}
+
+static XcursorFileHeader *
+_XcursorReadFileHeader (XcursorFile *file)
+{
+    XcursorFileHeader    head, *fileHeader;
+    XcursorUInt        skip;
+    unsigned int    n;
+
+    if (!file)
+        return NULL;
+
+    if (!_XcursorReadUInt (file, &head.magic))
+    return NULL;
+    if (head.magic != XCURSOR_MAGIC)
+    return NULL;
+    if (!_XcursorReadUInt (file, &head.header))
+    return NULL;
+    if (!_XcursorReadUInt (file, &head.version))
+    return NULL;
+    if (!_XcursorReadUInt (file, &head.ntoc))
+    return NULL;
+    skip = head.header - XCURSOR_FILE_HEADER_LEN;
+    if (skip)
+    if ((*file->seek) (file, skip, SEEK_CUR) == EOF)
+        return NULL;
+    fileHeader = _XcursorFileHeaderCreate (head.ntoc);
+    if (!fileHeader)
+    return NULL;
+    fileHeader->magic = head.magic;
+    fileHeader->header = head.header;
+    fileHeader->version = head.version;
+    fileHeader->ntoc = head.ntoc;
+    for (n = 0; n < fileHeader->ntoc; n++)
+    {
+    if (!_XcursorReadUInt (file, &fileHeader->tocs[n].type))
+        break;
+    if (!_XcursorReadUInt (file, &fileHeader->tocs[n].subtype))
+        break;
+    if (!_XcursorReadUInt (file, &fileHeader->tocs[n].position))
+        break;
+    }
+    if (n != fileHeader->ntoc)
+    {
+    _XcursorFileHeaderDestroy (fileHeader);
+    return NULL;
+    }
+    return fileHeader;
+}
+
+static XcursorBool
+_XcursorSeekToToc (XcursorFile        *file,
+           XcursorFileHeader    *fileHeader,
+           int            toc)
+{
+    if (!file || !fileHeader || \
+        (*file->seek) (file, fileHeader->tocs[toc].position, SEEK_SET) == EOF)
+    return XcursorFalse;
+    return XcursorTrue;
+}
+
+static XcursorBool
+_XcursorFileReadChunkHeader (XcursorFile    *file,
+                 XcursorFileHeader    *fileHeader,
+                 int        toc,
+                 XcursorChunkHeader    *chunkHeader)
+{
+    if (!file || !fileHeader || !chunkHeader)
+        return XcursorFalse;
+    if (!_XcursorSeekToToc (file, fileHeader, toc))
+    return XcursorFalse;
+    if (!_XcursorReadUInt (file, &chunkHeader->header))
+    return XcursorFalse;
+    if (!_XcursorReadUInt (file, &chunkHeader->type))
+    return XcursorFalse;
+    if (!_XcursorReadUInt (file, &chunkHeader->subtype))
+    return XcursorFalse;
+    if (!_XcursorReadUInt (file, &chunkHeader->version))
+    return XcursorFalse;
+    /* sanity check */
+    if (chunkHeader->type != fileHeader->tocs[toc].type ||
+    chunkHeader->subtype != fileHeader->tocs[toc].subtype)
+    return XcursorFalse;
+    return XcursorTrue;
+}
+
+#define dist(a,b)   ((a) > (b) ? (a) - (b) : (b) - (a))
+
+static XcursorDim
+_XcursorFindBestSize (XcursorFileHeader *fileHeader,
+              XcursorDim    size,
+              int        *nsizesp)
+{
+    unsigned int n;
+    int        nsizes = 0;
+    XcursorDim    bestSize = 0;
+    XcursorDim    thisSize;
+
+    if (!fileHeader || !nsizesp)
+        return 0;
+
+    for (n = 0; n < fileHeader->ntoc; n++)
+    {
+    if (fileHeader->tocs[n].type != XCURSOR_IMAGE_TYPE)
+        continue;
+    thisSize = fileHeader->tocs[n].subtype;
+    if (!bestSize || dist (thisSize, size) < dist (bestSize, size))
+    {
+        bestSize = thisSize;
+        nsizes = 1;
+    }
+    else if (thisSize == bestSize)
+        nsizes++;
+    }
+    *nsizesp = nsizes;
+    return bestSize;
+}
+
+static int
+_XcursorFindImageToc (XcursorFileHeader    *fileHeader,
+              XcursorDim    size,
+              int        count)
+{
+    unsigned int    toc;
+    XcursorDim        thisSize;
+
+    if (!fileHeader)
+        return 0;
+
+    for (toc = 0; toc < fileHeader->ntoc; toc++)
+    {
+    if (fileHeader->tocs[toc].type != XCURSOR_IMAGE_TYPE)
+        continue;
+    thisSize = fileHeader->tocs[toc].subtype;
+    if (thisSize != size)
+        continue;
+    if (!count)
+        break;
+    count--;
+    }
+    if (toc == fileHeader->ntoc)
+    return -1;
+    return toc;
+}
+
+static XcursorImage *
+_XcursorReadImage (XcursorFile        *file,
+           XcursorFileHeader    *fileHeader,
+           int            toc)
+{
+    XcursorChunkHeader    chunkHeader;
+    XcursorImage    head;
+    XcursorImage    *image;
+    int            n;
+    XcursorPixel    *p;
+
+    if (!file || !fileHeader)
+        return NULL;
+
+    if (!_XcursorFileReadChunkHeader (file, fileHeader, toc, &chunkHeader))
+    return NULL;
+    if (!_XcursorReadUInt (file, &head.width))
+    return NULL;
+    if (!_XcursorReadUInt (file, &head.height))
+    return NULL;
+    if (!_XcursorReadUInt (file, &head.xhot))
+    return NULL;
+    if (!_XcursorReadUInt (file, &head.yhot))
+    return NULL;
+    if (!_XcursorReadUInt (file, &head.delay))
+    return NULL;
+    /* sanity check data */
+    if (head.width >= 0x10000 || head.height > 0x10000)
+    return NULL;
+    if (head.width == 0 || head.height == 0)
+    return NULL;
+    if (head.xhot > head.width || head.yhot > head.height)
+    return NULL;
+
+    /* Create the image and initialize it */
+    image = XcursorImageCreate (head.width, head.height);
+    if (image == NULL)
+        return NULL;
+    if (chunkHeader.version < image->version)
+    image->version = chunkHeader.version;
+    image->size = chunkHeader.subtype;
+    image->xhot = head.xhot;
+    image->yhot = head.yhot;
+    image->delay = head.delay;
+    n = image->width * image->height;
+    p = image->pixels;
+    while (n--)
+    {
+    if (!_XcursorReadUInt (file, p))
+    {
+        XcursorImageDestroy (image);
+        return NULL;
+    }
+    p++;
+    }
+    return image;
+}
+
+static XcursorImages *
+XcursorXcFileLoadImages (XcursorFile *file, int size)
+{
+    XcursorFileHeader    *fileHeader;
+    XcursorDim        bestSize;
+    int            nsize;
+    XcursorImages    *images;
+    int            n;
+    int            toc;
+
+    if (!file || size < 0)
+    return NULL;
+    fileHeader = _XcursorReadFileHeader (file);
+    if (!fileHeader)
+    return NULL;
+    bestSize = _XcursorFindBestSize (fileHeader, (XcursorDim) size, &nsize);
+    if (!bestSize)
+    {
+        _XcursorFileHeaderDestroy (fileHeader);
+    return NULL;
+    }
+    images = XcursorImagesCreate (nsize);
+    if (!images)
+    {
+        _XcursorFileHeaderDestroy (fileHeader);
+    return NULL;
+    }
+    for (n = 0; n < nsize; n++)
+    {
+    toc = _XcursorFindImageToc (fileHeader, bestSize, n);
+    if (toc < 0)
+        break;
+    images->images[images->nimage] = _XcursorReadImage (file, fileHeader,
+                                toc);
+    if (!images->images[images->nimage])
+        break;
+    images->nimage++;
+    }
+    _XcursorFileHeaderDestroy (fileHeader);
+    if (images->nimage != nsize)
+    {
+    XcursorImagesDestroy (images);
+    images = NULL;
+    }
+    return images;
+}
+
+static int
+_XcursorStdioFileRead (XcursorFile *file, unsigned char *buf, int len)
+{
+    FILE    *f = file->closure;
+    return fread (buf, 1, len, f);
+}
+
+static int
+_XcursorStdioFileWrite (XcursorFile *file, unsigned char *buf, int len)
+{
+    FILE    *f = file->closure;
+    return fwrite (buf, 1, len, f);
+}
+
+static int
+_XcursorStdioFileSeek (XcursorFile *file, long offset, int whence)
+{
+    FILE    *f = file->closure;
+    return fseek (f, offset, whence);
+}
+
+static void
+_XcursorStdioFileInitialize (FILE *stdfile, XcursorFile *file)
+{
+    file->closure = stdfile;
+    file->read = _XcursorStdioFileRead;
+    file->write = _XcursorStdioFileWrite;
+    file->seek = _XcursorStdioFileSeek;
+}
+
+static XcursorImages *
+XcursorFileLoadImages (FILE *file, int size)
+{
+    XcursorFile    f;
+
+    if (!file)
+        return NULL;
+
+    _XcursorStdioFileInitialize (file, &f);
+    return XcursorXcFileLoadImages (&f, size);
+}
+
+/*
+ * From libXcursor/src/library.c
+ */
+
+#ifndef ICONDIR
+#define ICONDIR "/usr/X11R6/lib/X11/icons"
+#endif
+
+#ifndef XCURSORPATH
+#define XCURSORPATH "~/.icons:/usr/share/icons:/usr/share/pixmaps:~/.cursors:/usr/share/cursors/xorg-x11:"ICONDIR
+#endif
+
+static const char *
+XcursorLibraryPath (void)
+{
+    static const char    *path;
+
+    if (!path)
+    {
+    path = getenv ("XCURSOR_PATH");
+    if (!path)
+        path = XCURSORPATH;
+    }
+    return path;
+}
+
+static  void
+_XcursorAddPathElt (char *path, const char *elt, int len)
+{
+    int        pathlen = strlen (path);
+
+    /* append / if the path doesn't currently have one */
+    if (path[0] == '\0' || path[pathlen - 1] != '/')
+    {
+    strcat (path, "/");
+    pathlen++;
+    }
+    if (len == -1)
+    len = strlen (elt);
+    /* strip leading slashes */
+    while (len && elt[0] == '/')
+    {
+    elt++;
+    len--;
+    }
+    strncpy (path + pathlen, elt, len);
+    path[pathlen + len] = '\0';
+}
+
+static char *
+_XcursorBuildThemeDir (const char *dir, const char *theme)
+{
+    const char        *colon;
+    const char        *tcolon;
+    char        *full;
+    char        *home;
+    int            dirlen;
+    int            homelen;
+    int            themelen;
+    int            len;
+
+    if (!dir || !theme)
+        return NULL;
+
+    colon = strchr (dir, ':');
+    if (!colon)
+    colon = dir + strlen (dir);
+
+    dirlen = colon - dir;
+
+    tcolon = strchr (theme, ':');
+    if (!tcolon)
+    tcolon = theme + strlen (theme);
+
+    themelen = tcolon - theme;
+
+    home = NULL;
+    homelen = 0;
+    if (*dir == '~')
+    {
+    home = getenv ("HOME");
+    if (!home)
+        return NULL;
+    homelen = strlen (home);
+    dir++;
+    dirlen--;
+    }
+
+    /*
+     * add space for any needed directory separators, one per component,
+     * and one for the trailing null
+     */
+    len = 1 + homelen + 1 + dirlen + 1 + themelen + 1;
+
+    full = malloc (len);
+    if (!full)
+    return NULL;
+    full[0] = '\0';
+
+    if (home)
+    _XcursorAddPathElt (full, home, -1);
+    _XcursorAddPathElt (full, dir, dirlen);
+    _XcursorAddPathElt (full, theme, themelen);
+    return full;
+}
+
+static char *
+_XcursorBuildFullname (const char *dir, const char *subdir, const char *file)
+{
+    char    *full;
+
+    if (!dir || !subdir || !file)
+        return NULL;
+
+    full = malloc (strlen (dir) + 1 + strlen (subdir) + 1 + strlen (file) + 1);
+    if (!full)
+    return NULL;
+    full[0] = '\0';
+    _XcursorAddPathElt (full, dir, -1);
+    _XcursorAddPathElt (full, subdir, -1);
+    _XcursorAddPathElt (full, file, -1);
+    return full;
+}
+
+static const char *
+_XcursorNextPath (const char *path)
+{
+    char    *colon = strchr (path, ':');
+
+    if (!colon)
+    return NULL;
+    return colon + 1;
+}
+
+#define XcursorWhite(c)    ((c) == ' ' || (c) == '\t' || (c) == '\n')
+#define XcursorSep(c) ((c) == ';' || (c) == ',')
+
+static char *
+_XcursorThemeInherits (const char *full)
+{
+    char    line[8192];
+    char    *result = NULL;
+    FILE    *f;
+
+    if (!full)
+        return NULL;
+
+    f = fopen (full, "r");
+    if (f)
+    {
+    while (fgets (line, sizeof (line), f))
+    {
+        if (!strncmp (line, "Inherits", 8))
+        {
+        char    *l = line + 8;
+        char    *r;
+        while (*l == ' ') l++;
+        if (*l != '=') continue;
+        l++;
+        while (*l == ' ') l++;
+        result = malloc (strlen (l) + 1);
+        if (result)
+        {
+            r = result;
+            while (*l)
+            {
+            while (XcursorSep(*l) || XcursorWhite (*l)) l++;
+            if (!*l)
+                break;
+            if (r != result)
+                *r++ = ':';
+            while (*l && !XcursorWhite(*l) &&
+                   !XcursorSep(*l))
+                *r++ = *l++;
+            }
+            *r++ = '\0';
+        }
+        break;
+        }
+    }
+    fclose (f);
+    }
+    return result;
+}
+
+static FILE *
+XcursorScanTheme (const char *theme, const char *name)
+{
+    FILE    *f = NULL;
+    char    *full;
+    char    *dir;
+    const char  *path;
+    char    *inherits = NULL;
+    const char    *i;
+
+    if (!theme || !name)
+        return NULL;
+
+    /*
+     * Scan this theme
+     */
+    for (path = XcursorLibraryPath ();
+     path && f == NULL;
+     path = _XcursorNextPath (path))
+    {
+    dir = _XcursorBuildThemeDir (path, theme);
+    if (dir)
+    {
+        full = _XcursorBuildFullname (dir, "cursors", name);
+        if (full)
+        {
+        f = fopen (full, "r");
+        free (full);
+        }
+        if (!f && !inherits)
+        {
+        full = _XcursorBuildFullname (dir, "", "index.theme");
+        if (full)
+        {
+            inherits = _XcursorThemeInherits (full);
+            free (full);
+        }
+        }
+        free (dir);
+    }
+    }
+    /*
+     * Recurse to scan inherited themes
+     */
+    for (i = inherits; i && f == NULL; i = _XcursorNextPath (i))
+    f = XcursorScanTheme (i, name);
+    if (inherits != NULL)
+    free (inherits);
+    return f;
+}
+
+XcursorImages *
+XcursorLibraryLoadImages (const char *file, const char *theme, int size)
+{
+    FILE        *f = NULL;
+    XcursorImages   *images = NULL;
+
+    if (!file)
+        return NULL;
+
+    if (theme)
+    f = XcursorScanTheme (theme, file);
+    if (!f)
+    f = XcursorScanTheme ("default", file);
+    if (f)
+    {
+    images = XcursorFileLoadImages (f, size);
+    if (images)
+        XcursorImagesSetName (images, file);
+    fclose (f);
+    }
+    return images;
+}
+
+static void
+load_all_cursors_from_dir(const char *path, int size,
+              void (*load_callback)(XcursorImages *, void *),
+              void *user_data)
+{
+    FILE *f;
+    DIR *dir = opendir(path);
+    struct dirent *ent;
+    char *full;
+    XcursorImages *images;
+
+    if (!dir)
+        return;
+
+    for(ent = readdir(dir); ent; ent = readdir(dir)) {
+#ifdef _DIRENT_HAVE_D_TYPE
+        if (ent->d_type != DT_UNKNOWN &&
+            (ent->d_type != DT_REG && ent->d_type != DT_LNK))
+            continue;
+#endif
+
+        full = _XcursorBuildFullname(path, "", ent->d_name);
+        if (!full)
+            continue;
+
+        f = fopen(full, "r");
+        if (!f) {
+            free(full);
+            continue;
+        }
+
+        images = XcursorFileLoadImages(f, size);
+
+        if (images) {
+            XcursorImagesSetName(images, ent->d_name);
+            load_callback(images, user_data);
+        }
+
+        fclose (f);
+        free(full);
+    }
+
+    closedir(dir);
+}
+
+/** Load all the cursor of a theme
+ *
+ * This function loads all the cursor images of a given theme and its
+ * inherited themes. Each cursor is loaded into an XcursorImages object
+ * which is passed to the caller's load callback. If a cursor appears
+ * more than once across all the inherited themes, the load callback
+ * will be called multiple times, with possibly different XcursorImages
+ * object which have the same name. The user is expected to destroy the
+ * XcursorImages objects passed to the callback with
+ * XcursorImagesDestroy().
+ *
+ * \param theme The name of theme that should be loaded
+ * \param size The desired size of the cursor images
+ * \param load_callback A callback function that will be called
+ * for each cursor loaded. The first parameter is the XcursorImages
+ * object representing the loaded cursor and the second is a pointer
+ * to data provided by the user.
+ * \param user_data The data that should be passed to the load callback
+ */
+void
+xcursor_load_theme(const char *theme, int size,
+            void (*load_callback)(XcursorImages *, void *),
+            void *user_data)
+{
+    char *full, *dir;
+    char *inherits = NULL;
+    const char *path, *i;
+
+    if (!theme)
+        theme = "default";
+
+    for (path = XcursorLibraryPath();
+         path;
+         path = _XcursorNextPath(path)) {
+        dir = _XcursorBuildThemeDir(path, theme);
+        if (!dir)
+            continue;
+
+        full = _XcursorBuildFullname(dir, "cursors", "");
+
+        if (full) {
+            load_all_cursors_from_dir(full, size, load_callback,
+                          user_data);
+            free(full);
+        }
+
+        if (!inherits) {
+            full = _XcursorBuildFullname(dir, "", "index.theme");
+            if (full) {
+                inherits = _XcursorThemeInherits(full);
+                free(full);
+            }
+        }
+
+        free(dir);
+    }
+
+    for (i = inherits; i; i = _XcursorNextPath(i))
+        xcursor_load_theme(i, size, load_callback, user_data);
+
+    if (inherits)
+        free(inherits);
+}
 
=== added file 'plugins/Cursor/3rd_party/xcursor/xcursor.h'
--- plugins/Cursor/3rd_party/xcursor/xcursor.h	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/3rd_party/xcursor/xcursor.h	2015-10-19 14:53:23 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef XCURSOR_H
+#define XCURSOR_H
+
+#include <stdint.h>
+
+
+typedef int        XcursorBool;
+typedef uint32_t XcursorUInt;
+
+typedef XcursorUInt    XcursorDim;
+typedef XcursorUInt    XcursorPixel;
+
+typedef struct _XcursorImage {
+    XcursorUInt        version;    /* version of the image data */
+    XcursorDim        size;    /* nominal size for matching */
+    XcursorDim        width;    /* actual width */
+    XcursorDim        height;    /* actual height */
+    XcursorDim        xhot;    /* hot spot x (must be inside image) */
+    XcursorDim        yhot;    /* hot spot y (must be inside image) */
+    XcursorUInt        delay;    /* animation delay to next frame (ms) */
+    XcursorPixel    *pixels;    /* pointer to pixels */
+} XcursorImage;
+
+/*
+ * Other data structures exposed by the library API
+ */
+typedef struct _XcursorImages {
+    int            nimage;    /* number of images */
+    XcursorImage    **images;    /* array of XcursorImage pointers */
+    char        *name;    /* name used to load images */
+} XcursorImages;
+
+XcursorImages *
+XcursorLibraryLoadImages (const char *file, const char *theme, int size);
+
+void
+XcursorImagesDestroy (XcursorImages *images);
+
+void
+xcursor_load_theme(const char *theme, int size,
+        void (*load_callback)(XcursorImages *, void *),
+        void *user_data);
+#endif
 
=== added file 'plugins/Cursor/CMakeLists.txt'
--- plugins/Cursor/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/CMakeLists.txt	2015-10-19 14:53:23 +0000
@@ -0,0 +1,28 @@
+add_subdirectory(3rd_party)
+
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/3rd_party/xcursor
+    ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
+)
+
+set(QMLPLUGIN_SRC
+    plugin.cpp
+    MousePointer.cpp
+    CursorImageProvider.cpp
+    # We need to run moc on this header
+    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h
+    )
+
+add_library(Cursor-qml SHARED
+    ${QMLPLUGIN_SRC}
+    )
+
+target_link_libraries(Cursor-qml
+    xcursorloader-static
+    ${QT5PLATFORM_SUPPORT_LDFLAGS}
+)
+
+qt5_use_modules(Cursor-qml Qml Quick DBus Network Gui Sql Concurrent Svg)
+
+add_unity8_plugin(Cursor 1.0 Cursor TARGETS Cursor-qml)
 
=== added file 'plugins/Cursor/Cursor.qml'
--- plugins/Cursor/Cursor.qml	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/Cursor.qml	2015-10-19 14:53:23 +0000
@@ -0,0 +1,12 @@
+import QtQuick 2.4
+import Cursor 1.0 // For MousePointer
+
+MousePointer {
+    id: mousePointer
+
+    Image {
+        x: -mousePointer.hotspotX
+        y: -mousePointer.hotspotY
+        source: "image://cursor/" + mousePointer.themeName + "/" + mousePointer.cursorName
+    }
+}
 
=== added file 'plugins/Cursor/CursorImageProvider.cpp'
--- plugins/Cursor/CursorImageProvider.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/CursorImageProvider.cpp	2015-10-19 14:53:23 +0000
@@ -0,0 +1,191 @@
+/*
+ * 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 "CursorImageProvider.h"
+
+#include <QDebug>
+#include <QFile>
+#include <QPainter>
+#include <QSvgRenderer>
+
+CursorImageProvider *CursorImageProvider::m_instance = nullptr;
+
+/////
+// BuiltInCursorImage
+
+BuiltInCursorImage::BuiltInCursorImage()
+{
+    const char *svgString =
+        "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>"
+         "<svg"
+         "   xmlns:dc=\"http://purl.org/dc/elements/1.1/\""
+         "   xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\""
+         "   xmlns:svg=\"http://www.w3.org/2000/svg\""
+         "   xmlns=\"http://www.w3.org/2000/svg\""
+         "   version=\"1.1\">"
+         "    <path"
+         "       style=\"fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:40;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1\""
+         "       d=\"M 20.504,50.94931 460.42533,518.14486 266.47603,515.61948 366.48114,719.16522 274.05218,770.68296 172.53185,559.56112 20.504,716.13476 Z\" />"
+         "</svg>";
+
+    qimage = QImage(20, 32, QImage::Format_ARGB32);
+    QPainter imagePainter(&qimage);
+
+    QSvgRenderer *svgRenderer = new QSvgRenderer(QByteArray(svgString));
+    svgRenderer->render(&imagePainter);
+    delete svgRenderer;
+}
+
+/////
+// XCursorImage
+
+XCursorImage::XCursorImage(const QString &theme, const QString &file)
+    : xcursorImages(nullptr)
+{
+    xcursorImages = XcursorLibraryLoadImages(QFile::encodeName(file), QFile::encodeName(theme), 32);
+    if (!xcursorImages) {
+        return;
+    }
+
+    bool loaded = false;
+    for (int i = 0; i < xcursorImages->nimage && !loaded; ++i) {
+        XcursorImage *xcursorImage = xcursorImages->images[i];
+        if (xcursorImage->size == 32) {
+
+            qimage = QImage((uchar*)xcursorImage->pixels,
+                    xcursorImage->width, xcursorImage->height, QImage::Format_ARGB32);
+
+            hotspot.setX(xcursorImage->xhot);
+            hotspot.setY(xcursorImage->yhot);
+
+            loaded = true;
+        }
+    }
+}
+
+XCursorImage::~XCursorImage()
+{
+    XcursorImagesDestroy(xcursorImages);
+}
+
+/////
+// CursorImageProvider
+
+CursorImageProvider::CursorImageProvider()
+    : QQuickImageProvider(QQuickImageProvider::Image)
+{
+    if (m_instance) {
+        qFatal("Cannot have multiple CursorImageProvider instances");
+    }
+    m_instance = this;
+}
+
+CursorImageProvider::~CursorImageProvider()
+{
+    {
+        QList< QMap<QString, CursorImage*> > cursorList = m_cursors.values();
+
+        for (int i = 0; i < cursorList.count(); ++i) {
+            QList<CursorImage*> cursorImageList = cursorList[i].values();
+            for (int j = 0; j < cursorImageList.count(); ++j) {
+                delete cursorImageList[j];
+            }
+        }
+    }
+
+    m_cursors.clear();
+    m_instance = nullptr;
+}
+
+QImage CursorImageProvider::requestImage(const QString &cursorThemeAndName, QSize *size, const QSize & /*requestedSize*/)
+{
+    CursorImage *cursorImage = fetchCursor(cursorThemeAndName);
+    size->setWidth(cursorImage->qimage.width());
+    size->setHeight(cursorImage->qimage.height());
+
+    return cursorImage->qimage;
+}
+
+QPoint CursorImageProvider::hotspot(const QString &themeName, const QString &cursorName)
+{
+    CursorImage *cursorImage = fetchCursor(themeName, cursorName);
+    if (cursorImage) {
+        return cursorImage->hotspot;
+    } else {
+        return QPoint(0,0);
+    }
+}
+
+CursorImage *CursorImageProvider::fetchCursor(const QString &cursorThemeAndName)
+{
+    QString themeName;
+    QString cursorName;
+    {
+        QStringList themeAndNameList = cursorThemeAndName.split("/");
+        if (themeAndNameList.size() != 2) {
+            return nullptr;
+        }
+        themeName = themeAndNameList[0];
+        cursorName = themeAndNameList[1];
+    }
+
+    return fetchCursor(themeName, cursorName);
+}
+
+CursorImage *CursorImageProvider::fetchCursor(const QString &themeName, const QString &cursorName)
+{
+    CursorImage *cursorImage = fetchCursorHelper(themeName, cursorName);
+
+    // Try some fallbacks
+    if (cursorImage->qimage.isNull()) {
+        if (cursorName == "ibeam") {
+            qDebug() << "CursorImageProvider: \"ibeam\" not found, falling back to \"xterm\"";
+            cursorImage = fetchCursorHelper(themeName, "xterm");
+        } else if (cursorName == "xterm") {
+            qDebug() << "CursorImageProvider: \"xterm\" not found, falling back to \"ibeam\"";
+            cursorImage = fetchCursorHelper(themeName, "ibeam");
+        }
+    }
+
+    // if it all fails, there must be at least a left_ptr
+    if (cursorImage->qimage.isNull() && cursorName != "left_ptr") {
+        qDebug() << "CursorImageProvider:" << cursorName
+            << "not found (nor its fallbacks, if any). Going for \"left_ptr\" as a last resort.";
+        cursorImage = fetchCursorHelper(themeName, "left_ptr");
+    }
+
+    if (cursorImage->qimage.isNull()) {
+        // finally, go for the built-in cursor
+        qWarning() << "CursorImageProvider: couldn't find any cursors. Using the built-in one";
+        if (!m_builtInCursorImage) {
+            m_builtInCursorImage.reset(new BuiltInCursorImage);
+        }
+        cursorImage = m_builtInCursorImage.data();
+    }
+
+    return cursorImage;
+}
+
+CursorImage *CursorImageProvider::fetchCursorHelper(const QString &themeName, const QString &cursorName)
+{
+    QMap<QString, CursorImage*> &themeCursors = m_cursors[themeName];
+
+    if (!themeCursors.contains(cursorName)) {
+        themeCursors[cursorName] = new XCursorImage(themeName, cursorName);
+    }
+
+    return themeCursors[cursorName];
+}
 
=== added file 'plugins/Cursor/CursorImageProvider.h'
--- plugins/Cursor/CursorImageProvider.h	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/CursorImageProvider.h	2015-10-19 14:53:23 +0000
@@ -0,0 +1,76 @@
+/*
+ * 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 CURSORIMAGEPROVIDER_H
+#define CURSORIMAGEPROVIDER_H
+
+#include <QQuickImageProvider>
+#include <QScopedPointer>
+
+// xcursor static lib
+extern "C"
+{
+#include <xcursor.h>
+}
+
+class CursorImage {
+public:
+    virtual ~CursorImage() {}
+
+    QImage qimage;
+    QPoint hotspot;
+};
+
+class XCursorImage : public CursorImage {
+public:
+    XCursorImage(const QString &theme, const QString &file);
+    virtual ~XCursorImage();
+
+    XcursorImages *xcursorImages;
+};
+
+class BuiltInCursorImage : public CursorImage {
+public:
+    BuiltInCursorImage();
+};
+
+class CursorImageProvider : public QQuickImageProvider
+{
+public:
+    CursorImageProvider();
+    virtual ~CursorImageProvider();
+
+    static CursorImageProvider *instance() { return m_instance; }
+
+
+    QImage requestImage(const QString &cursorName, QSize *size, const QSize &requestedSize) override;
+
+    QPoint hotspot(const QString &themeName, const QString &cursorName);
+
+private:
+    CursorImage *fetchCursor(const QString &cursorThemeAndName);
+    CursorImage *fetchCursor(const QString &themeName, const QString &cursorName);
+    CursorImage *fetchCursorHelper(const QString &themeName, const QString &cursorName);
+
+    // themeName -> (cursorName -> cursorImage)
+    QMap<QString, QMap<QString, CursorImage*> > m_cursors;
+
+    QScopedPointer<CursorImage> m_builtInCursorImage;
+
+    static CursorImageProvider *m_instance;
+};
+
+#endif // CURSORIMAGEPROVIDER_H
 
=== added file 'plugins/Cursor/MousePointer.cpp'
--- plugins/Cursor/MousePointer.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/MousePointer.cpp	2015-10-19 14:53:23 +0000
@@ -0,0 +1,125 @@
+/*
+ * 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 "MousePointer.h"
+#include "CursorImageProvider.h"
+
+// Unity API
+#include <unity/shell/application/MirPlatformCursor.h>
+
+#include <QQuickWindow>
+#include <QGuiApplication>
+
+#include <qpa/qwindowsysteminterface.h>
+
+MousePointer::MousePointer(QQuickItem *parent)
+    : MirMousePointerInterface(parent)
+    , m_cursorName("left_ptr")
+    , m_themeName("default")
+    , m_hotspotX(0)
+    , m_hotspotY(0)
+{
+}
+
+void MousePointer::handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,
+        Qt::KeyboardModifiers modifiers)
+{
+    if (!parentItem()) {
+        return;
+    }
+
+    qreal newX = x() + movement.x();
+    if (newX < 0) {
+        newX = 0;
+    } else if (newX > parentItem()->width()) {
+        newX = parentItem()->width();
+    }
+    setX(newX);
+
+    qreal newY = y() + movement.y();
+    if (newY < 0) {
+        newY = 0;
+    } else if (newY > parentItem()->height()) {
+        newY = parentItem()->height();
+    }
+    setY(newY);
+
+    QPointF scenePosition = mapToItem(nullptr, QPointF(0, 0));
+    QWindowSystemInterface::handleMouseEvent(window(), timestamp, scenePosition /*local*/, scenePosition /*global*/,
+        buttons, modifiers);
+}
+
+void MousePointer::itemChange(ItemChange change, const ItemChangeData &value)
+{
+    if (change == ItemSceneChange) {
+        registerWindow(value.window);
+    }
+}
+
+void MousePointer::registerWindow(QWindow *window)
+{
+    if (m_registeredWindow && window != m_registeredWindow) {
+        auto previousCursor = dynamic_cast<MirPlatformCursor*>(m_registeredWindow->screen()->handle()->cursor());
+        if (previousCursor) {
+            previousCursor->setMousePointer(nullptr);
+        } else {
+            qCritical("QPlatformCursor is not a MirPlatformCursor! Cursor module only works in a Mir server.");
+        }
+    }
+
+    m_registeredWindow = window;
+
+    if (m_registeredWindow) {
+        auto cursor = dynamic_cast<MirPlatformCursor*>(window->screen()->handle()->cursor());
+        if (cursor) {
+            cursor->setMousePointer(this);
+        } else {
+            qCritical("QPlaformCursor is not a MirPlatformCursor! Cursor module only works in Mir.");
+        }
+    }
+}
+
+void MousePointer::setCursorName(const QString &cursorName)
+{
+    if (cursorName != m_cursorName) {
+        m_cursorName = cursorName;
+        Q_EMIT cursorNameChanged(m_cursorName);
+        updateHotspot();
+    }
+}
+
+void MousePointer::updateHotspot()
+{
+    QPoint newHotspot = CursorImageProvider::instance()->hotspot(m_themeName, m_cursorName);
+
+    if (m_hotspotX != newHotspot.x()) {
+        m_hotspotX = newHotspot.x();
+        Q_EMIT hotspotXChanged(m_hotspotX);
+    }
+
+    if (m_hotspotY != newHotspot.y()) {
+        m_hotspotY = newHotspot.y();
+        Q_EMIT hotspotYChanged(m_hotspotY);
+    }
+}
+
+void MousePointer::setThemeName(const QString &themeName)
+{
+    if (m_themeName != themeName) {
+        m_themeName = themeName;
+        Q_EMIT themeNameChanged(m_themeName);
+    }
+}
 
=== added file 'plugins/Cursor/MousePointer.h'
--- plugins/Cursor/MousePointer.h	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/MousePointer.h	2015-10-19 14:53:23 +0000
@@ -0,0 +1,59 @@
+/*
+ * 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 MOUSEPOINTER_H
+#define MOUSEPOINTER_H
+
+// Qt
+#include <QPointer>
+#include <QWindow>
+
+// Unity API
+#include <unity/shell/application/MirMousePointerInterface.h>
+
+class MousePointer : public MirMousePointerInterface {
+    Q_OBJECT
+public:
+    MousePointer(QQuickItem *parent = nullptr);
+
+    void setCursorName(const QString &qtCursorName) override;
+    QString cursorName() const override { return m_cursorName; }
+
+    void setThemeName(const QString &themeName) override;
+    QString themeName() const override { return m_themeName; }
+
+    qreal hotspotX() const override { return m_hotspotX; }
+    qreal hotspotY() const override { return m_hotspotY; }
+
+public Q_SLOTS:
+    void handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,
+            Qt::KeyboardModifiers modifiers) override;
+
+protected:
+    void itemChange(ItemChange change, const ItemChangeData &value) override;
+
+private:
+    void registerWindow(QWindow *window);
+    void updateHotspot();
+
+    QPointer<QWindow> m_registeredWindow;
+    QString m_cursorName;
+    QString m_themeName;
+    int m_hotspotX;
+    int m_hotspotY;
+};
+
+#endif // MOUSEPOINTER_H
 
=== added file 'plugins/Cursor/plugin.cpp'
--- plugins/Cursor/plugin.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/plugin.cpp	2015-10-19 14:53:23 +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 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 <QtQml/qqml.h>
+#include <QQmlContext>
+
+// self
+#include "plugin.h"
+
+// local
+#include "CursorImageProvider.h"
+#include "MousePointer.h"
+
+void CursorPlugin::registerTypes(const char *uri)
+{
+    Q_ASSERT(uri == QLatin1String("Cursor"));
+    qmlRegisterType<MousePointer>(uri, 1, 0, "MousePointer");
+}
+
+void CursorPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
+{
+    QQmlExtensionPlugin::initializeEngine(engine, uri);
+
+    engine->addImageProvider(QLatin1String("cursor"), new CursorImageProvider());
+}
 
=== added file 'plugins/Cursor/plugin.h'
--- plugins/Cursor/plugin.h	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/plugin.h	2015-10-19 14:53:23 +0000
@@ -0,0 +1,33 @@
+/*
+ * 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 CURSOR_PLUGIN_H
+#define CURSOR_PLUGIN_H
+
+#include <QtQml/QQmlEngine>
+#include <QtQml/QQmlExtensionPlugin>
+
+class CursorPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
+
+public:
+    void registerTypes(const char *uri) override;
+    void initializeEngine(QQmlEngine *engine, const char *uri) override;
+};
+
+#endif // CURSOR_PLUGIN_H
 
=== added file 'plugins/Cursor/qmldir'
--- plugins/Cursor/qmldir	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/qmldir	2015-10-19 14:53:23 +0000
@@ -0,0 +1,3 @@
+module Cursor
+plugin Cursor-qml
+Cursor 1.0 Cursor.qml
 
=== modified file 'qml/Greeter/Greeter.qml'
--- qml/Greeter/Greeter.qml	2015-09-02 13:06:56 +0000
+++ qml/Greeter/Greeter.qml	2015-10-19 14:53:23 +0000
@@ -251,7 +251,7 @@
 
     // event eater
     // Nothing should leak to items behind the greeter
-    MouseArea { anchors.fill: parent }
+    MouseArea { anchors.fill: parent; hoverEnabled: true }
 
     Loader {
         id: loader
 
=== modified file 'qml/Launcher/Launcher.qml'
--- qml/Launcher/Launcher.qml	2015-09-02 14:18:40 +0000
+++ qml/Launcher/Launcher.qml	2015-10-19 14:53:23 +0000
@@ -188,6 +188,7 @@
             bottom: parent.bottom
         }
         enabled: root.shadeBackground && root.state == "visible"
+        visible: enabled // otherwise it will get in the way of cursor selection for some reason
         onPressed: {
             root.state = ""
         }
 
=== modified file 'qml/Panel/Panel.qml'
--- qml/Panel/Panel.qml	2015-06-29 03:58:22 +0000
+++ qml/Panel/Panel.qml	2015-10-19 14:53:23 +0000
@@ -48,6 +48,7 @@
         MouseArea {
             anchors.fill: parent
             onClicked: if (indicators.fullyOpened) indicators.hide();
+            hoverEnabled: true // should also eat hover events, otherwise they will pass through
         }
     }
 
 
=== modified file 'qml/Shell.qml'
--- qml/Shell.qml	2015-09-22 14:23:44 +0000
+++ qml/Shell.qml	2015-10-19 14:53:23 +0000
@@ -41,6 +41,7 @@
 import Unity.Session 0.1
 import Unity.DashCommunicator 0.1
 import Unity.Indicators 0.1 as Indicators
+import Cursor 1.0
 
 
 Item {
@@ -63,7 +64,7 @@
     function updateFocusedAppOrientationAnimated() {
         applicationsDisplayLoader.item.updateFocusedAppOrientationAnimated();
     }
-    property bool hasMouse
+    property bool hasMouse: false
 
     // to be read from outside
     readonly property int mainAppWindowOrientationAngle:
@@ -190,11 +191,6 @@
         onScreenshotTriggered: screenGrabber.capture();
     }
 
-    ScreenGrabber {
-        id: screenGrabber
-        z: dialogs.z + 10
-    }
-
     GlobalShortcut {
         // dummy shortcut to force creation of GlobalShortcutRegistry before WindowKeyFilter
     }
@@ -684,9 +680,20 @@
         onShowHome: showHome()
     }
 
+    ScreenGrabber {
+        id: screenGrabber
+        z: dialogs.z + 10
+    }
+
+    Cursor {
+        id: cursor
+        visible: shell.hasMouse
+        z: screenGrabber.z + 1
+    }
+
     Rectangle {
         id: shutdownFadeOutRectangle
-        z: screenGrabber.z + 10
+        z: cursor.z + 1
         enabled: false
         visible: false
         color: "black"
 
=== modified file 'qml/Stages/DecoratedWindow.qml'
--- qml/Stages/DecoratedWindow.qml	2015-09-08 10:32:28 +0000
+++ qml/Stages/DecoratedWindow.qml	2015-10-19 14:53:23 +0000
@@ -31,9 +31,10 @@
     property bool highlightShown: false
     property real shadowOpacity: 1
 
-    signal close();
-    signal maximize();
-    signal minimize();
+    signal close()
+    signal maximize()
+    signal minimize()
+    signal decorationPressed()
 
     BorderImage {
         anchors {
@@ -61,6 +62,7 @@
 
     WindowDecoration {
         id: decoration
+        target: root.parent
         objectName: application ? "appWindowDecoration_" + application.appId : "appWindowDecoration_null"
         anchors { left: parent.left; top: parent.top; right: parent.right }
         height: units.gu(3)
@@ -68,6 +70,7 @@
         onClose: root.close();
         onMaximize: root.maximize();
         onMinimize: root.minimize();
+        onPressed: root.decorationPressed();
         visible: decorationShown
     }
 
 
=== modified file 'qml/Stages/DesktopStage.qml'
--- qml/Stages/DesktopStage.qml	2015-09-18 15:28:07 +0000
+++ qml/Stages/DesktopStage.qml	2015-10-19 14:53:23 +0000
@@ -86,6 +86,11 @@
             var index = indexOf(focusedAppId);
             return index >= 0 && index < appRepeater.count ? appRepeater.itemAt(index) : null
         }
+        onFocusedAppDelegateChanged: { // restore the window from minimization when we focus it (e.g. using spread)
+            if (priv.focusedAppDelegate && priv.focusedAppDelegate.minimized) {
+                priv.focusedAppDelegate.unmaximize()
+            }
+        }
 
         function indexOf(appId) {
             for (var i = 0; i < ApplicationManager.count; i++) {
@@ -138,9 +143,6 @@
                 height: units.gu(50)
                 focus: model.appId === priv.focusedAppId
 
-                readonly property int minWidth: units.gu(10)
-                readonly property int minHeight: units.gu(10)
-
                 property bool maximized: false
                 property bool minimized: false
 
@@ -215,15 +217,12 @@
                     when: index == spread.highlightedIndex && blurLayer.ready
                 }
 
-                WindowMoveResizeArea {
-                    id: windowMoveResizeArea
+                WindowResizeArea {
                     target: appDelegate
-                    minWidth: appDelegate.minWidth
-                    minHeight: appDelegate.minHeight
-                    resizeHandleWidth: units.gu(2)
+                    minWidth: units.gu(10)
+                    minHeight: units.gu(10)
+                    borderThickness: units.gu(2)
                     windowId: model.appId // FIXME: Change this to point to windowId once we have such a thing
-
-                    onPressed: { ApplicationManager.focusApplication(model.appId) }
                 }
 
                 DecoratedWindow {
@@ -240,6 +239,7 @@
                     onClose: ApplicationManager.stopApplication(model.appId)
                     onMaximize: appDelegate.maximize()
                     onMinimize: appDelegate.minimize()
+                    onDecorationPressed: ApplicationManager.focusApplication(model.appId)
                 }
             }
         }
 
=== modified file 'qml/Stages/WindowDecoration.qml'
--- qml/Stages/WindowDecoration.qml	2015-03-13 19:18:35 +0000
+++ qml/Stages/WindowDecoration.qml	2015-10-19 14:53:23 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-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
@@ -12,25 +12,54 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Michael Zanetti <[e-mail]>
  */
 
 import QtQuick 2.3
+import Unity.Application 0.1 // For Mir singleton
 import Ubuntu.Components 1.1
 import "../Components"
 
-Item {
+MouseArea {
     id: root
     clip: true
 
+    property Item target
     property alias title: titleLabel.text
     property bool active: false
+    hoverEnabled: true
 
     signal close()
     signal minimize()
     signal maximize()
 
+    QtObject {
+        id: priv
+        property real distanceX
+        property real distanceY
+        property bool dragging
+    }
+
+    onPressedChanged: {
+        if (pressed) {
+            var pos = mapToItem(root.target, mouseX, mouseY);
+            priv.distanceX = pos.x;
+            priv.distanceY = pos.y;
+            priv.dragging = true;
+        } else {
+            priv.dragging = false;
+            Mir.cursorName = "";
+        }
+    }
+
+    onPositionChanged: {
+        if (priv.dragging) {
+            Mir.cursorName = "grabbing";
+            var pos = mapToItem(root.target.parent, mouseX, mouseY);
+            root.target.x = pos.x - priv.distanceX;
+            root.target.y = pos.y - priv.distanceY;
+        }
+    }
+
     Rectangle {
         anchors.fill: parent
         anchors.bottomMargin: -radius
 
=== renamed file 'qml/Stages/WindowMoveResizeArea.qml' => 'qml/Stages/WindowResizeArea.qml'
--- qml/Stages/WindowMoveResizeArea.qml	2015-09-08 10:32:28 +0000
+++ qml/Stages/WindowResizeArea.qml	2015-10-19 14:53:23 +0000
@@ -12,18 +12,19 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Michael Zanetti <[e-mail]>
  */
 
 import QtQuick 2.3
 import Ubuntu.Components 1.1
 import Utils 0.1
+import Unity.Application 0.1 // for Mir.cursorName
 
 MouseArea {
     id: root
     anchors.fill: target
-    anchors.margins: -resizeHandleWidth
+    anchors.margins: -borderThickness
+
+    hoverEnabled: true
 
     property var windowStateStorage: WindowStateStorage
 
@@ -31,24 +32,10 @@
     // The area will anchor to it and manage move and resize events
     property Item target: null
     property string windowId: ""
-    property int resizeHandleWidth: 0
+    property int borderThickness: 0
     property int minWidth: 0
     property int minHeight: 0
 
-    QtObject {
-        id: priv
-        readonly property int windowWidth: root.width - root.resizeHandleWidth * 2
-        readonly property int windowHeight: root.height - resizeHandleWidth * 2
-
-        property var startPoint
-
-        property bool resizeTop: false
-        property bool resizeBottom: false
-        property bool resizeLeft: false
-        property bool resizeRight: false
-
-    }
-
     Component.onCompleted: {
         var windowState = windowStateStorage.getGeometry(root.windowId, Qt.rect(target.x, target.y, target.width, target.height))
         if (windowState !== undefined) {
@@ -59,51 +46,137 @@
         }
     }
 
-    onPressed: {
-        priv.startPoint = Qt.point(mouse.x, mouse.y);
-        priv.resizeTop = mouseY < root.resizeHandleWidth;
-        priv.resizeBottom = mouseY > (root.height - root.resizeHandleWidth);
-        priv.resizeLeft = mouseX < root.resizeHandleWidth;
-        priv.resizeRight = mouseX > (root.width - root.resizeHandleWidth);
-    }
-
-    onPositionChanged: {
-        var currentPoint = Qt.point(mouse.x, mouse.y);
-        var mouseDiff = Qt.point(currentPoint.x - priv.startPoint.x, currentPoint.y - priv.startPoint.y);
-        var moveDiff = Qt.point(0, 0);
-        var sizeDiff = Qt.point(0, 0);
-        var maxSizeDiff = Qt.point(root.minWidth - root.target.width, root.minHeight - root.target.height)
-
-        if (priv.resizeTop || priv.resizeBottom || priv.resizeLeft || priv.resizeRight) {
-            if (priv.resizeTop) {
-                sizeDiff.y = Math.max(maxSizeDiff.y, -currentPoint.y + priv.startPoint.y)
-                moveDiff.y = -sizeDiff.y
-            }
-            if (priv.resizeBottom) {
-                sizeDiff.y = Math.max(maxSizeDiff.y, currentPoint.y - priv.startPoint.y)
-                priv.startPoint.y += sizeDiff.y
-            }
-            if (priv.resizeLeft) {
-                sizeDiff.x = Math.max(maxSizeDiff.x, -currentPoint.x + priv.startPoint.x)
-                moveDiff.x = -sizeDiff.x
-            }
-            if (priv.resizeRight) {
-                sizeDiff.x = Math.max(maxSizeDiff.x, currentPoint.x - priv.startPoint.x)
-                priv.startPoint.x += sizeDiff.x
-            }
-
-            target.x += moveDiff.x;
-            target.y += moveDiff.y;
-            target.width += sizeDiff.x;
-            target.height += sizeDiff.y;
-        } else {
-            target.x += mouseDiff.x;
-            target.y += mouseDiff.y;
-        }
-
-    }
-
     Component.onDestruction: {
         windowStateStorage.saveGeometry(root.windowId, Qt.rect(target.x, target.y, target.width, target.height))
     }
+
+    QtObject {
+        id: d
+        property bool leftBorder: false
+        property bool rightBorder: false
+        property bool topBorder: false
+        property bool bottomBorder: false
+
+        property bool dragging: false
+        property real startMousePosX
+        property real startMousePosY
+        property real startX
+        property real startY
+        property real startWidth
+        property real startHeight
+
+        property string cursorName: {
+            if (root.containsMouse || root.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: {
+        var pos = mapToItem(target.parent, mouseX, mouseY);
+
+        if (pressed) {
+            d.updateBorders();
+            var pos = mapToItem(root.target.parent, mouseX, mouseY);
+            d.startMousePosX = pos.x;
+            d.startMousePosY = pos.y;
+            d.startX = target.x;
+            d.startY = target.y;
+            d.startWidth = target.width;
+            d.startHeight = target.height;
+            d.dragging = true;
+        } else {
+            d.dragging = false;
+            if (containsMouse) {
+                d.updateBorders();
+            }
+        }
+    }
+
+    onEntered: {
+        if (!pressed) {
+            d.updateBorders();
+        }
+    }
+
+    onPositionChanged: {
+        if (!pressed) {
+            d.updateBorders();
+        }
+
+        if (!d.dragging) {
+            return;
+        }
+
+        var pos = mapToItem(target.parent, mouse.x, mouse.y);
+
+        var deltaX = pos.x - d.startMousePosX;
+        var deltaY = pos.y - d.startMousePosY;
+
+        if (d.leftBorder) {
+            var newTargetX = d.startX + deltaX;
+            if (target.x + target.width > newTargetX + minWidth) {
+                target.width = target.x + target.width - newTargetX;
+                target.x = newTargetX;
+            } else {
+                target.x = target.x + target.width - minWidth;
+                target.width = minWidth;
+            }
+
+        } else if (d.rightBorder) {
+            if (d.startWidth + deltaX >= minWidth) {
+                target.width = d.startWidth + deltaX;
+            } else {
+                target.width = minWidth;
+            }
+        }
+
+        if (d.topBorder) {
+            var newTargetY = d.startY + deltaY;
+            if (target.y + target.height > newTargetY + minHeight) {
+                target.height = target.y + target.height - newTargetY;
+                target.y = newTargetY;
+            } else {
+                target.y = target.y + target.height - minHeight;
+                target.height = minHeight;
+            }
+
+        } else if (d.bottomBorder) {
+            if (d.startHeight + deltaY >= minHeight) {
+                target.height = d.startHeight + deltaY;
+            } else {
+                target.height = minHeight;
+            }
+        }
+    }
 }
 
=== modified file 'tests/mocks/CMakeLists.txt'
--- tests/mocks/CMakeLists.txt	2015-08-06 22:45:56 +0000
+++ tests/mocks/CMakeLists.txt	2015-10-19 14:53:23 +0000
@@ -29,6 +29,7 @@
 endmacro()
 
 add_subdirectory(AccountsService)
+add_subdirectory(Cursor)
 add_subdirectory(GSettings.1.0)
 add_subdirectory(indicator-service)
 add_subdirectory(libusermetrics)
 
=== added directory 'tests/mocks/Cursor'
=== added file 'tests/mocks/Cursor/CMakeLists.txt'
--- tests/mocks/Cursor/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/mocks/Cursor/CMakeLists.txt	2015-10-19 14:53:23 +0000
@@ -0,0 +1,1 @@
+add_unity8_mock(Cursor 1.0 Cursor PREFIX mocks)
 
=== added file 'tests/mocks/Cursor/Cursor.qml'
--- tests/mocks/Cursor/Cursor.qml	1970-01-01 00:00:00 +0000
+++ tests/mocks/Cursor/Cursor.qml	2015-10-19 14:53:23 +0000
@@ -0,0 +1,20 @@
+/*
+ * 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/>.
+ */
+
+import QtQuick 2.4
+
+Item {
+}
 
=== added file 'tests/mocks/Cursor/qmldir'
--- tests/mocks/Cursor/qmldir	1970-01-01 00:00:00 +0000
+++ tests/mocks/Cursor/qmldir	2015-10-19 14:53:23 +0000
@@ -0,0 +1,2 @@
+module Cursor
+Cursor 1.0 Cursor.qml
 
=== modified file 'tests/qmltests/CMakeLists.txt'
--- tests/qmltests/CMakeLists.txt	2015-09-19 07:37:52 +0000
+++ tests/qmltests/CMakeLists.txt	2015-10-19 14:53:23 +0000
@@ -78,7 +78,7 @@
 add_unity8_qmltest(Stages SurfaceContainer)
 add_unity8_qmltest(Stages SessionContainer)
 add_unity8_qmltest(Stages TabletStage)
-add_unity8_qmltest(Stages WindowMoveResizeArea)
+add_unity8_qmltest(Stages WindowResizeArea)
 add_unity8_qmltest(Stages Splash)
 add_unity8_qmltest(Tutorial Tutorial LIGHTDM)
 add_unity8_qmltest(Wizard Wizard ENVIRONMENT "OXIDE_NO_SANDBOX=1")
 
=== renamed file 'tests/qmltests/Stages/tst_WindowMoveResizeArea.qml' => 'tests/qmltests/Stages/tst_WindowResizeArea.qml'
--- tests/qmltests/Stages/tst_WindowMoveResizeArea.qml	2015-09-07 13:45:50 +0000
+++ tests/qmltests/Stages/tst_WindowResizeArea.qml	2015-10-19 14:53:23 +0000
@@ -17,7 +17,7 @@
 import QtQuick 2.1
 import QtQuick.Layouts 1.1
 import QtTest 1.0
-import Unity.Test 0.1 as UT
+import Unity.Test 0.1
 import ".."
 import "../../../qml/Stages"
 import Ubuntu.Components 0.1
@@ -36,8 +36,8 @@
 
         Item {
             id: fakeWindow
-            property alias minWidth: moveResizeArea.minWidth
-            property alias minHeight: moveResizeArea.minHeight
+            property alias minWidth: windowResizeArea.minWidth
+            property alias minHeight: windowResizeArea.minHeight
             x: units.gu(20)
             y: units.gu(20)
             height: units.gu(20)
@@ -47,23 +47,27 @@
             onWindowHeightChanged: height = windowHeight
             onWindowWidthChanged: width = windowWidth
 
-            WindowMoveResizeArea {
-                id: moveResizeArea
+            WindowResizeArea {
+                id: windowResizeArea
                 target: fakeWindow
-                resizeHandleWidth: units.gu(0.5)
+                borderThickness: units.gu(2)
                 minWidth: units.gu(15)
                 minHeight: units.gu(10)
                 windowId: "test-window-id"
             }
 
             Rectangle {
-                anchors.fill: moveResizeArea
+                anchors.fill: windowResizeArea
                 color: "red"
             }
 
             Rectangle {
                 anchors.fill: fakeWindow
                 color: "blue"
+                MouseArea {
+                    anchors.fill: parent
+                    hoverEnabled: true
+                }
             }
         }
     }
@@ -73,8 +77,13 @@
         sourceComponent: fakeWindowComponent
     }
 
-    UT.UnityTestCase {
-        name: "WindowMoveResizeArea"
+    MouseTouchEmulationCheckbox {
+        checked: false
+        color: "black"
+    }
+
+    UnityTestCase {
+        name: "WindowResizeArea"
         when: windowShown
 
         function init() {
@@ -84,34 +93,6 @@
             fakeWindow.height = units.gu(20)
         }
 
-        function test_dragWindow_data() {
-            return [
-                { tag: "up", dx: 0, dy: units.gu(-10) },
-                { tag: "down", dx: 0, dy: units.gu(10) },
-                { tag: "left", dx: units.gu(-10), dy: 0 },
-                { tag: "right", dx: units.gu(10), dy: 0 },
-                { tag: "right/down", dx: units.gu(10), dy: units.gu(10) },
-                { tag: "left/down", dx: units.gu(-10), dy: units.gu(10) }
-            ]
-        }
-
-        function test_dragWindow(data) {
-            var initialWindowX = fakeWindow.x;
-            var initialWindowY = fakeWindow.y;
-            var initialWindowWidth = fakeWindow.width
-            var initialWindowHeight = fakeWindow.height
-
-            var startDragX = initialWindowX + fakeWindow.width / 2;
-            var startDragY = initialWindowY + fakeWindow.height / 2;
-            mouseFlick(root, startDragX, startDragY, startDragX + data.dx, startDragY + data.dy, true, true, units.gu(.5), 10)
-
-            tryCompare(fakeWindow, "x", initialWindowX + data.dx)
-            tryCompare(fakeWindow, "y", initialWindowX + data.dy)
-
-            compare(fakeWindow.height, initialWindowHeight);
-            compare(fakeWindow.width, initialWindowWidth);
-        }
-
         function test_resizeWindowRightBottom_data() {
             return [
                 { tag: "width", dx: units.gu(10), dy: 0 },
@@ -166,30 +147,6 @@
             compare(fakeWindow.y, Math.min(initialWindowY + data.dy, initialWindowY + maxMoveY));
         }
 
-        function test_saveRestorePosition() {
-            var initialWindowX = fakeWindow.x;
-            var initialWindowY = fakeWindow.y;
-            var initialWindowWidth = fakeWindow.width;
-            var initialWindowHeight = fakeWindow.height;
-
-            var moveDelta = units.gu(5);
-            var startDragX = initialWindowX + fakeWindow.width / 2;
-            var startDragY = initialWindowY + fakeWindow.height / 2;
-            mouseFlick(root, startDragX, startDragY, startDragX + moveDelta, startDragY + moveDelta, true, true, units.gu(.5), 10)
-
-            tryCompare(fakeWindow, "x", initialWindowX + moveDelta)
-            tryCompare(fakeWindow, "y", initialWindowX + moveDelta)
-
-            // This will destroy the window and recreate it
-            windowLoader.active = false;
-            waitForRendering(root);
-            windowLoader.active = true;
-
-            // Make sure it's again where we left it before destroying
-            tryCompare(fakeWindow, "x", initialWindowX + moveDelta)
-            tryCompare(fakeWindow, "y", initialWindowX + moveDelta)
-        }
-
         function test_saveRestoreSize() {
             var initialWindowX = fakeWindow.x;
             var initialWindowY = fakeWindow.y;
 
=== modified file 'tests/qmltests/tst_OrientedShell.qml'
--- tests/qmltests/tst_OrientedShell.qml	2015-09-21 13:37:47 +0000
+++ tests/qmltests/tst_OrientedShell.qml	2015-10-19 14:53:23 +0000
@@ -264,6 +264,10 @@
                 text: "Usage Mode"
                 model: ["Staged", "Windowed", "Automatic"]
             }
+            MouseTouchEmulationCheckbox {
+                checked: true
+                color: "white"
+            }
             Button {
                 text: "Switch fullscreen"
                 activeFocusOnPress: false