Merge lp:~saviq/unity8/add-cursor-copyright into lp:unity8

[Michał Sawicz]

Add missing copyright to Cursor.qml

[Albert Astals Cid (aacid)]

 * Did you perform an exploratory manual test run of the code change and any related functionality?
No, it's just copyright addition

 * Did CI run pass? If not, please explain why.
Doesn't matter since it's just copyright addition

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

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2008
http://jenkins.qa.ubuntu.com/job/unity8-ci/6538/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/4810
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-wily-touch/921/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/1250
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-wily/566/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/1145
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/1146
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-wily-amd64-ci/777/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-wily-i386-ci/778/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/3874
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/4807
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/4807/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/24545
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-wily-armhf/921/console

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

review: Needs Fixing (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-09-30 16:49:52 +0000
+++ CMakeLists.txt	2015-10-26 12:04:03 +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)
@@ -101,6 +101,9 @@
 # Save a few container detach and conversions
 add_definitions(-DQT_STRICT_ITERATORS)
 
+# Use the fast string builder
+add_definitions(-DQT_USE_QSTRINGBUILDER)
+
 # Autopilot tests
 include(autopilot)
 declare_autopilot_test(shell unity8.shell ${CMAKE_SOURCE_DIR}/tests/autopilot/)

=== modified file 'data/unity8.conf'
--- data/unity8.conf	2015-09-01 12:41:57 +0000
+++ data/unity8.conf	2015-10-26 12:04:03 +0000
@@ -46,6 +46,16 @@
     initctl set-env --global MIR_SERVER_PROMPT_FILE=1
 
     initctl emit --no-wait indicator-services-start
+
+    # Disable Qt's stuttering 'touch compression' to fix scrolling smoothness
+    # issues (LP: #1486341). As a bonus, this eliminates most of the
+    # lag seen in the indicator panel pull-down (LP: #1488327) and also
+    # reduces lag seen in apps:
+    initctl set-env --global QML_NO_TOUCH_COMPRESSION=1
+
+    # For twice the fun and half the latency, try this (Warning: not all
+    # devices are fast enough to keep up smoothly yet)...
+    # initctl set-env MIR_SERVER_NBUFFERS=2
 end script
 
 exec ${BINARY:-unity8} $ARGS

=== modified file 'debian/changelog'
--- debian/changelog	2015-10-09 09:13:03 +0000
+++ debian/changelog	2015-10-26 12:04:03 +0000
@@ -1,3 +1,39 @@
+unity8 (8.11+15.10.20151021-0ubuntu1) wily; urgency=medium
+
+  [ Albert Astals Cid ]
+  * Clazy fixes
+  * Enable Efficient String Construction by default
+
+  [ CI Train Bot ]
+  * New rebuild forced.
+
+  [ Daniel d'Andrada ]
+  * Have unity8 drawing its own cursor (LP: #1488417)
+  * Initial multi-monitor support
+
+  [ Daniel van Vugt ]
+  * Disable Qt's stuttering 'touch compression' to fix scrolling
+    smoothness (LP: #1486341, #1488327)
+
+  [ Lukáš Tinkl ]
+  * Fix autopilot wizard test skipping the reporting page
+  * Implement Unity.Platform plugin wrapping org.freedesktop.hostname1
+    (LP: #1504318)
+  * React to window title (aka surface name) changes (LP: #1497092)
+  * Rotate the screenshots according to the actual orientation
+
+  [ Michał Sawicz ]
+  * Fix application API dependency
+  * Have unity8 drawing its own cursor (LP: #1488417)
+  * Initial multi-monitor support
+  * Rotate the screenshots according to the actual orientation
+
+  [ Nick Dedekind ]
+  * Fixed leak in UnityMenuModelStackTest
+  * Moved time translation to SDK (LP: #1372061)
+
+ -- Michał Sawicz <[e-mail]>  Wed, 21 Oct 2015 11:51:53 +0000
+
 unity8 (8.11+15.10.20151009-0ubuntu1) wily; urgency=medium
 
   [ CI Train Bot ]

=== modified file 'debian/control'
--- debian/control	2015-09-23 18:15:40 +0000
+++ debian/control	2015-10-26 12:04:03 +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,
@@ -49,7 +50,7 @@
                qtdeclarative5-private-dev (>= 5.2.1),
                qtdeclarative5-qtmultimedia-plugin,
                qtdeclarative5-ubuntu-settings-components (>= 0.6),
-               qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.1.1239) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.1.1239),
+               qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1627) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1627),
                qtdeclarative5-ubuntu-web-plugin,
                ttf-ubuntu-font-family,
 Standards-Version: 3.9.4
@@ -64,7 +65,7 @@
 Package: indicators-client
 Architecture: amd64 armhf i386
 Depends: qmenumodel-qml (>= 0.2.9),
-         qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.1.1239) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.1.1239),
+         qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1627) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1627),
          unity8 (= ${binary:Version}),
          ${misc:Depends},
          ${shlibs:Depends},
@@ -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),
@@ -122,10 +124,10 @@
 Depends: qml-module-qtquick-layouts,
          qtdeclarative5-ubuntu-settings-components (>= 0.6),
          qtdeclarative5-ubuntu-thumbnailer0.1 | ubuntu-thumbnailer-impl,
-         qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.1.1239) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.1.1239),
+         qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1627) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1627),
          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-26 12:04:03 +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-26 12:04:03 +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 'debian/unity8.install'
--- debian/unity8.install	2015-10-01 13:10:32 +0000
+++ debian/unity8.install	2015-10-26 12:04:03 +0000
@@ -12,6 +12,7 @@
 usr/share/unity8/Rotation
 usr/share/unity8/DeviceConfiguration.qml
 usr/share/unity8/OrientedShell.qml
+usr/share/unity8/DisabledScreenNotice.qml
 usr/share/unity8/Shell.qml
 usr/share/unity8/Stages
 usr/share/unity8/Tutorial

=== modified file 'plugins/CMakeLists.txt'
--- plugins/CMakeLists.txt	2015-09-02 09:30:32 +0000
+++ plugins/CMakeLists.txt	2015-10-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +0000
@@ -0,0 +1,28 @@
+/*
+ * 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
+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-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +0000
@@ -0,0 +1,3 @@
+module Cursor
+plugin Cursor-qml
+Cursor 1.0 Cursor.qml

=== modified file 'plugins/IntegratedLightDM/UsersModel.cpp'
--- plugins/IntegratedLightDM/UsersModel.cpp	2015-04-30 09:31:51 +0000
+++ plugins/IntegratedLightDM/UsersModel.cpp	2015-10-26 12:04:03 +0000
@@ -43,16 +43,17 @@
 
 QVariant MangleModel::data(const QModelIndex &index, int role) const
 {
-    QVariant data = QSortFilterProxyModel::data(index, role);
+    QVariant variantData = QSortFilterProxyModel::data(index, role);
 
     // If user's real name is empty, switch to unix name
-    if (role == QLightDM::UsersModel::RealNameRole && data.toString().isEmpty()) {
-        data = QSortFilterProxyModel::data(index, QLightDM::UsersModel::NameRole);
-    } else if (role == QLightDM::UsersModel::BackgroundPathRole && data.toString().startsWith('#')) {
-        data = "data:image/svg+xml,<svg><rect width='100%' height='100%' fill='" + data.toString() + "'/></svg>";
+    if (role == QLightDM::UsersModel::RealNameRole && variantData.toString().isEmpty()) {
+        variantData = QSortFilterProxyModel::data(index, QLightDM::UsersModel::NameRole);
+    } else if (role == QLightDM::UsersModel::BackgroundPathRole && variantData.toString().startsWith('#')) {
+        const QString stringData = "data:image/svg+xml,<svg><rect width='100%' height='100%' fill='" + variantData.toString() + "'/></svg>";
+        variantData = stringData;
     }
 
-    return data;
+    return variantData;
 }
 
 // **** Now we continue with actual UsersModel class ****

=== modified file 'plugins/IntegratedLightDM/liblightdm/UsersModelPrivate.cpp'
--- plugins/IntegratedLightDM/liblightdm/UsersModelPrivate.cpp	2015-09-14 09:11:08 +0000
+++ plugins/IntegratedLightDM/liblightdm/UsersModelPrivate.cpp	2015-10-26 12:04:03 +0000
@@ -34,7 +34,8 @@
     entries.reserve(users.count());
     Q_FOREACH(const QString &user, users)
     {
-        QString name = settings.value(user + "/name", user[0].toUpper() + user.mid(1)).toString();
+        QVariant defaultValue = QString(user[0].toUpper() + user.mid(1));
+        QString name = settings.value(user + "/name", defaultValue).toString();
         entries.append({user, name, 0, 0, false, false, 0, 0});
     }
 }

=== modified file 'plugins/ScreenGrabber/screengrabber.cpp'
--- plugins/ScreenGrabber/screengrabber.cpp	2015-09-23 15:14:01 +0000
+++ plugins/ScreenGrabber/screengrabber.cpp	2015-10-26 12:04:03 +0000
@@ -60,7 +60,7 @@
     }
 }
 
-void ScreenGrabber::captureAndSave()
+void ScreenGrabber::captureAndSave(int angle)
 {
     if (fileNamePrefix.isEmpty())
     {
@@ -82,7 +82,7 @@
         return;
     }
 
-    const QImage screenshot = main_window->grabWindow();
+    const QImage screenshot = main_window->grabWindow().transformed(QTransform().rotate(angle));
     const QString filename = makeFileName();
     qDebug() << "Saving screenshot to" << filename;
     auto saveOp = QtConcurrent::run(saveScreenshot, screenshot, filename, getFormat(), screenshotQuality);

=== modified file 'plugins/ScreenGrabber/screengrabber.h'
--- plugins/ScreenGrabber/screengrabber.h	2015-07-17 19:59:31 +0000
+++ plugins/ScreenGrabber/screengrabber.h	2015-10-26 12:04:03 +0000
@@ -29,7 +29,7 @@
     ~ScreenGrabber() = default;
 
 public Q_SLOTS:
-    void captureAndSave();
+    void captureAndSave(int angle = 0);
 
 Q_SIGNALS:
     void screenshotSaved(const QString &filename);

=== modified file 'plugins/Unity/CMakeLists.txt'
--- plugins/Unity/CMakeLists.txt	2015-05-05 11:19:15 +0000
+++ plugins/Unity/CMakeLists.txt	2015-10-26 12:04:03 +0000
@@ -4,3 +4,4 @@
 add_subdirectory(Session)
 add_subdirectory(DashCommunicator)
 add_subdirectory(InputInfo)
+add_subdirectory(Platform)

=== modified file 'plugins/Unity/Launcher/desktopfilehandler.cpp'
--- plugins/Unity/Launcher/desktopfilehandler.cpp	2015-09-14 09:41:55 +0000
+++ plugins/Unity/Launcher/desktopfilehandler.cpp	2015-10-26 12:04:03 +0000
@@ -111,8 +111,9 @@
     settings.beginGroup(QStringLiteral("Desktop Entry"));
 
     // First try to find Name[xx_YY] and Name[xx] in .desktop file
-    QString locale = QLocale().name();
-    QString shortLocale = locale.split('_').first();
+    const QString locale = QLocale().name();
+    const QStringList splitLocale = locale.split(QLatin1Char('_'));
+    const QString shortLocale = splitLocale.first();
 
     if (locale != shortLocale && settings.contains(QStringLiteral("Name[%1]").arg(locale))) {
         return settings.value(QStringLiteral("Name[%1]").arg(locale)).toString();

=== added directory 'plugins/Unity/Platform'
=== added file 'plugins/Unity/Platform/CMakeLists.txt'
--- plugins/Unity/Platform/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/Unity/Platform/CMakeLists.txt	2015-10-26 12:04:03 +0000
@@ -0,0 +1,9 @@
+set(platformplugin_SRCS
+    platform.cpp
+    plugin.cpp)
+
+add_library(Platform-qml SHARED ${platformplugin_SRCS})
+
+qt5_use_modules(Platform-qml DBus Qml)
+
+add_unity8_plugin(Unity.Platform 1.0 Unity/Platform TARGETS Platform-qml)

=== added file 'plugins/Unity/Platform/platform.cpp'
--- plugins/Unity/Platform/platform.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Unity/Platform/platform.cpp	2015-10-26 12:04:03 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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/>.
+ */
+
+#include "platform.h"
+
+#include <QDBusConnection>
+
+Platform::Platform(QObject *parent)
+    : QObject(parent)
+    , m_iface("org.freedesktop.hostname1", "/org/freedesktop/hostname1", "org.freedesktop.hostname1",
+              QDBusConnection::systemBus(), this)
+{
+    QMetaObject::invokeMethod(this, "init");
+}
+
+void Platform::init()
+{
+    m_chassis = m_iface.property("Chassis").toString();
+    m_isPC = (m_chassis == "desktop" || m_chassis == "laptop" || m_chassis == "server");
+}
+
+QString Platform::chassis() const
+{
+    return m_chassis;
+}
+
+bool Platform::isPC() const
+{
+    return m_isPC;
+}

=== added file 'plugins/Unity/Platform/platform.h'
--- plugins/Unity/Platform/platform.h	1970-01-01 00:00:00 +0000
+++ plugins/Unity/Platform/platform.h	2015-10-26 12:04:03 +0000
@@ -0,0 +1,58 @@
+/*
+ * 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 PLATFORM_H
+#define PLATFORM_H
+
+#include <QDBusInterface>
+
+/**
+ * @brief The Platform class
+ *
+ * Wrapper around platform detection support (org.freedesktop.hostname1)
+ */
+class Platform: public QObject
+{
+    Q_OBJECT
+    /**
+     * The chassis property
+     *
+     * Supported values include: "laptop", "computer", "handset" or "tablet"
+     * For full list see: http://www.freedesktop.org/wiki/Software/systemd/hostnamed/
+     */
+    Q_PROPERTY(QString chassis READ chassis CONSTANT)
+    /**
+     * Whether the machine is an ordinary PC (desktop, laptop or server)
+     */
+    Q_PROPERTY(bool isPC READ isPC CONSTANT)
+
+public:
+    Platform(QObject *parent = nullptr);
+    ~Platform() = default;
+
+    QString chassis() const;
+    bool isPC() const;
+
+private Q_SLOTS:
+    void init();
+
+private:
+    QDBusInterface m_iface;
+    QString m_chassis;
+    bool m_isPC;
+};
+
+#endif // PLATFORM_H

=== added file 'plugins/Unity/Platform/plugin.cpp'
--- plugins/Unity/Platform/plugin.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Unity/Platform/plugin.cpp	2015-10-26 12:04:03 +0000
@@ -0,0 +1,27 @@
+/*
+ * 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/>.
+ */
+
+#include "plugin.h"
+#include "platform.h"
+
+#include <QtQml>
+
+void GlobalShortcutPlugin::registerTypes(const char *uri)
+{
+    Q_ASSERT(uri == QLatin1String("Unity.Platform"));
+
+    qmlRegisterSingletonType<Platform>(uri, 1, 0, "Platform", [](QQmlEngine*, QJSEngine*) -> QObject* { return new Platform; });
+}

=== added file 'plugins/Unity/Platform/plugin.h'
--- plugins/Unity/Platform/plugin.h	1970-01-01 00:00:00 +0000
+++ plugins/Unity/Platform/plugin.h	2015-10-26 12:04:03 +0000
@@ -0,0 +1,32 @@
+/*
+ * 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 PLATFORMPLUGIN_H
+#define PLATFORMPLUGIN_H
+
+#include <QQmlExtensionPlugin>
+
+class GlobalShortcutPlugin: public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid)
+
+public:
+    void registerTypes(const char *uri) override;
+};
+
+
+#endif // PLATFORMPLUGIN_H

=== added file 'plugins/Unity/Platform/qmldir'
--- plugins/Unity/Platform/qmldir	1970-01-01 00:00:00 +0000
+++ plugins/Unity/Platform/qmldir	2015-10-26 12:04:03 +0000
@@ -0,0 +1,2 @@
+module Unity.Platform
+plugin Platform-qml

=== modified file 'plugins/Unity/Session/dbusunitysessionservice.cpp'
--- plugins/Unity/Session/dbusunitysessionservice.cpp	2015-09-14 09:11:08 +0000
+++ plugins/Unity/Session/dbusunitysessionservice.cpp	2015-10-26 12:04:03 +0000
@@ -292,7 +292,8 @@
     if (p) {
         const QString gecos = QString::fromLocal8Bit(p->pw_gecos);
         if (!gecos.isEmpty()) {
-            return gecos.split(QLatin1Char(',')).first();
+            const QStringList splitGecos = gecos.split(QLatin1Char(','));
+            return splitGecos.first();
         }
     }
 

=== modified file 'plugins/Utils/CMakeLists.txt'
--- plugins/Utils/CMakeLists.txt	2015-09-25 12:13:13 +0000
+++ plugins/Utils/CMakeLists.txt	2015-10-26 12:04:03 +0000
@@ -15,8 +15,6 @@
     inputwatcher.cpp
     qlimitproxymodelqml.cpp
     unitysortfilterproxymodelqml.cpp
-    relativetimeformatter.cpp
-    timeformatter.cpp
     Timer.cpp
     unitymenumodelpaths.cpp
     windowkeysfilter.cpp

=== modified file 'plugins/Utils/plugin.cpp'
--- plugins/Utils/plugin.cpp	2015-09-25 12:13:13 +0000
+++ plugins/Utils/plugin.cpp	2015-10-26 12:04:03 +0000
@@ -29,8 +29,6 @@
 #include "inputwatcher.h"
 #include "qlimitproxymodelqml.h"
 #include "unitysortfilterproxymodelqml.h"
-#include "relativetimeformatter.h"
-#include "timeformatter.h"
 #include "unitymenumodelpaths.h"
 #include "windowkeysfilter.h"
 #include "windowscreenshotprovider.h"
@@ -60,11 +58,8 @@
     qmlRegisterType<QLimitProxyModelQML>(uri, 0, 1, "LimitProxyModel");
     qmlRegisterType<UnitySortFilterProxyModelQML>(uri, 0, 1, "UnitySortFilterProxyModel");
     qmlRegisterType<UnityMenuModelPaths>(uri, 0, 1, "UnityMenuModelPaths");
-    qmlRegisterType<TimeFormatter>(uri, 0, 1, "TimeFormatter");
     qmlRegisterType<WindowKeysFilter>(uri, 0, 1, "WindowKeysFilter");
-    qmlRegisterType<GDateTimeFormatter>(uri, 0, 1, "GDateTimeFormatter");
     qmlRegisterType<EasingCurve>(uri, 0, 1, "EasingCurve");
-    qmlRegisterType<RelativeTimeFormatter>(uri, 0, 1, "RelativeTimeFormatter");
     qmlRegisterSingletonType<WindowStateStorage>(uri, 0, 1, "WindowStateStorage", createWindowStateStorage);
     qmlRegisterType<InputWatcher>(uri, 0, 1, "InputWatcher");
     qmlRegisterSingletonType<Constants>(uri, 0, 1, "Constants", createConstants);

=== removed file 'plugins/Utils/relativetimeformatter.cpp'
--- plugins/Utils/relativetimeformatter.cpp	2015-09-21 13:17:30 +0000
+++ plugins/Utils/relativetimeformatter.cpp	1970-01-01 00:00:00 +0000
@@ -1,260 +0,0 @@
-/*
- * Copyright 2014 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/>.
- *
- */
-
-// Local
-#include "relativetimeformatter.h"
-
-// Qt
-#include <QDateTime>
-
-// Other
-#include <glib.h>
-#include <glib/gi18n.h>
-#include <locale.h>
-#include <langinfo.h>
-#include <string.h>
-
-RelativeTimeFormatter::RelativeTimeFormatter(QObject *parent)
-    : GDateTimeFormatter(parent)
-{
-}
-
- /* Check the system locale setting to see if the format is 24-hour
-   time or 12-hour time */
-gboolean
-is_locale_12h(void)
-{
-    int i;
-    static const char *formats_24h[] = {"%H", "%R", "%T", "%OH", "%k", nullptr};
-    const char* t_fmt = nl_langinfo(T_FMT);
-
-    for (i=0; formats_24h[i]!=nullptr; i++)
-        if (strstr(t_fmt, formats_24h[i]) != nullptr)
-            return FALSE;
-
-    return TRUE;
-}
-
-typedef enum
-{
-    DATE_PROXIMITY_YESTERDAY,
-    DATE_PROXIMITY_TODAY,
-    DATE_PROXIMITY_TOMORROW,
-    DATE_PROXIMITY_LAST_WEEK,
-    DATE_PROXIMITY_NEXT_WEEK,
-    DATE_PROXIMITY_FAR
-} date_proximity_t;
-
-static date_proximity_t
-getDateProximity(GDateTime* now, GDateTime* time)
-{
-    date_proximity_t prox = DATE_PROXIMITY_FAR;
-    gint now_year, now_month, now_day;
-    gint time_year, time_month, time_day;
-
-    // does it happen today?
-    g_date_time_get_ymd(now, &now_year, &now_month, &now_day);
-    g_date_time_get_ymd(time, &time_year, &time_month, &time_day);
-    if ((now_year == time_year) && (now_month == time_month) && (now_day == time_day)) {
-        return DATE_PROXIMITY_TODAY;
-    }
-
-    // did it happen yesterday?
-    GDateTime* yesterday = g_date_time_add_days(now, -1);
-    gint tom_year, tom_month, tom_day;
-    g_date_time_get_ymd(yesterday, &tom_year, &tom_month, &tom_day);
-    g_date_time_unref(yesterday);
-    if ((tom_year == time_year) && (tom_month == time_month) && (tom_day == time_day)) {
-        return DATE_PROXIMITY_YESTERDAY;
-    }
-
-    // does it happen tomorrow?
-    GDateTime* tomorrow = g_date_time_add_days(now, 1);
-    g_date_time_get_ymd(tomorrow, &tom_year, &tom_month, &tom_day);
-    g_date_time_unref(tomorrow);
-    if ((tom_year == time_year) && (tom_month == time_month) && (tom_day == time_day)) {
-        return DATE_PROXIMITY_TOMORROW;
-    }
-
-    // does it happen this week?
-    if (g_date_time_compare(time, now) < 0) {
-        GDateTime* last_week = g_date_time_add_days(now, -6);
-        GDateTime* last_week_bound = g_date_time_new_local(g_date_time_get_year(last_week),
-                                                           g_date_time_get_month(last_week),
-                                                           g_date_time_get_day_of_month(last_week),
-                                                           0, 0, 0);
-        if (g_date_time_compare(time, last_week_bound) >= 0)
-            prox = DATE_PROXIMITY_LAST_WEEK;
-
-        g_date_time_unref(last_week);
-        g_date_time_unref(last_week_bound);
-    } else {
-        GDateTime* next_week = g_date_time_add_days(now, 6);
-        GDateTime* next_week_bound = g_date_time_new_local(g_date_time_get_year(next_week),
-                                                           g_date_time_get_month(next_week),
-                                                           g_date_time_get_day_of_month(next_week),
-                                                           23, 59, 59.9);
-        if (g_date_time_compare(time, next_week_bound) <= 0)
-            prox = DATE_PROXIMITY_NEXT_WEEK;
-
-        g_date_time_unref(next_week);
-        g_date_time_unref(next_week_bound);
-    }
-
-    return prox;
-}
-
-const char*
-dgettext_datetime(const char *text)
-{
-    return dgettext("unity8", text);
-}
-
-/**
- * _ a time yesterday should be shown as (e.g. “Yesterday 3:55 PM”)
- * _ a time today should be shown as just the time (e.g. “3:55 PM”)
- * _ a time tomorrow should be shown as(e.g. “Tomorrow 3:55 PM”)
- * _ a time any other day this week should be shown as the short version of the
- *   day and time (e.g. “Wed 3:55 PM”)
- *   weekday (e.g. “Friday”)
- * _ a time after this week should be shown as the short version of the day,
- *   date, and time (e.g. “Wed 21 Apr 3:55 PM”)
- * _ in addition, when presenting the times of upcoming events, the time should
- *   be followed by the timezone if it is different from the one the computer
- *   is currently set to. For example, “Wed 3:55 PM UTC−5”.
- *
- *   TODO - keep inline with indicator-datetime
- */
-char* generate_full_format_string_at_time (GDateTime* now,
-                                           GDateTime* then)
-{
-    GString* ret = g_string_new (nullptr);
-
-    if (then != nullptr) {
-        const date_proximity_t prox = getDateProximity(now, then);
-
-        if (is_locale_12h()) {
-            switch (prox)  {
-                case DATE_PROXIMITY_YESTERDAY:
-                    /* Translators, please edit/rearrange these strftime(3) tokens to suit your locale!
-                       This format string is used for showing, on a 12-hour clock, times that happen yesterday.
-                       (\u2003 is a unicode em space which is slightly wider than a normal space.)
-                       en_US example: "Yesterday\u2003%l:%M %p" --> "Yesterday  1:00 PM" */
-                    g_string_assign (ret, dgettext_datetime("Yesterday\u2003%l:%M %p"));
-                    break;
-
-                case DATE_PROXIMITY_TODAY:
-                    /* Translators, please edit/rearrange these strftime(3) tokens to suit your locale!
-                       This format string is used for showing, on a 12-hour clock, times that happened today.
-                       en_US example: "%l:%M %p" --> "1:00 PM" */
-                    g_string_assign (ret, dgettext_datetime("%l:%M %p"));
-                    break;
-
-                case DATE_PROXIMITY_TOMORROW:
-                    /* Translators, please edit/rearrange these strftime(3) tokens to suit your locale!
-                       This format string is used for showing, on a 12-hour clock, events/appointments that happen tomorrow.
-                       (\u2003 is a unicode em space which is slightly wider than a normal space.)
-                       en_US example: "Tomorrow\u2003%l:%M %p" --> "Tomorrow  1:00 PM" */
-                    g_string_assign (ret, dgettext_datetime("Tomorrow\u2003%l:%M %p"));
-                    break;
-
-                case DATE_PROXIMITY_LAST_WEEK:
-                case DATE_PROXIMITY_NEXT_WEEK:
-                    /* Translators, please edit/rearrange these strftime(3) tokens to suit your locale!
-                       This format string is used for showing, on a 12-hour clock, times that happened in the last week.
-                       (\u2003 is a unicode em space which is slightly wider than a normal space.)
-                       en_US example: "%a\u2003%l:%M %p" --> "Fri  1:00 PM" */
-                    g_string_assign (ret, dgettext_datetime("%a\u2003%l:%M %p"));
-                    break;
-
-                case DATE_PROXIMITY_FAR:
-                    /* Translators, please edit/rearrange these strftime(3) tokens to suit your locale!
-                       This format string is used for showing, on a 12-hour clock, times that happened before a week from now.
-                       (\u2003 is a unicode em space which is slightly wider than a normal space.)
-                       en_US example: "%a %b %d\u2003%l:%M %p" --> "Fri Oct 31  1:00 PM"
-                       en_GB example: "%a %d %b\u2003%l:%M %p" --> "Fri 31 Oct  1:00 PM" */
-                    g_string_assign (ret, dgettext_datetime("%a %d %b\u2003%l:%M %p"));
-                    break;
-            }
-        } else {
-            switch (prox) {
-
-                case DATE_PROXIMITY_YESTERDAY:
-                    /* Translators, please edit/rearrange these strftime(3) tokens to suit your locale!
-                       This format string is used for showing, on a 24-hour clock, times that happen yesterday.
-                       (\u2003 is a unicode em space which is slightly wider than a normal space.)
-                       en_US example: "Yesterday\u2003%l:%M %p" --> "Yesterday  13:00" */
-                    g_string_assign (ret, dgettext_datetime("Yesterday\u2003%H:%M"));
-                    break;
-
-                case DATE_PROXIMITY_TODAY:
-                    /* Translators, please edit/rearrange these strftime(3) tokens to suit your locale!
-                       This format string is used for showing, on a 24-hour clock, times that happened today.
-                       en_US example: "%H:%M" --> "13:00" */
-                    g_string_assign (ret, dgettext_datetime("%H:%M"));
-                    break;
-
-                case DATE_PROXIMITY_TOMORROW:
-                    /* Translators, please edit/rearrange these strftime(3) tokens to suit your locale!
-                       This format string is used for showing, on a 24-hour clock, events/appointments that happen tomorrow.
-                       (\u2003 is a unicode em space which is slightly wider than a normal space.)
-                       en_US example: "Tomorrow\u2003%l:%M %p" --> "Tomorrow  13:00" */
-                    g_string_assign (ret, dgettext_datetime("Tomorrow\u2003%H:%M"));
-                    break;
-
-                case DATE_PROXIMITY_LAST_WEEK:
-                case DATE_PROXIMITY_NEXT_WEEK:
-                    /* Translators, please edit/rearrange these strftime(3) tokens to suit your locale!
-                       This format string is used for showing, on a 24-hour clock, times that happened in the last week.
-                       (\u2003 is a unicode em space which is slightly wider than a normal space.)
-                       en_US example: "%a\u2003%H:%M" --> "Fri  13:00" */
-                    g_string_assign (ret, dgettext_datetime("%a\u2003%H:%M"));
-                    break;
-
-                case DATE_PROXIMITY_FAR:
-                    /* Translators, please edit/rearrange these strftime(3) tokens to suit your locale!
-                       This format string is used for showing, on a 24-hour clock, times that happened before a week from now.
-                       (\u2003 is a unicode em space which is slightly wider than a normal space.)
-                       en_US example: "%a %b %d\u2003%H:%M" --> "Fri Oct 31  13:00"
-                       en_GB example: "%a %d %b\u2003%H:%M" --> "Fri 31 Oct  13:00" */
-                    g_string_assign (ret, dgettext_datetime("%a %d %b\u2003%H:%M"));
-                    break;
-            }
-        }
-    }
-
-    return g_string_free (ret, FALSE);
-}
-
-QString RelativeTimeFormatter::format() const
-{
-    GDateTime* now = g_date_time_new_now_local();
-    if (!now) { return QString(); }
-
-    GDateTime* then = g_date_time_new_from_unix_local(time());
-    if (!then) { return QString(); }
-
-    char* time_format = generate_full_format_string_at_time(now, then);
-
-    QString str(QString::fromUtf8(time_format));
-    g_free(time_format);
-
-    g_date_time_unref(now);
-    g_date_time_unref(then);
-
-    return str;
-}

=== removed file 'plugins/Utils/relativetimeformatter.h'
--- plugins/Utils/relativetimeformatter.h	2014-09-19 14:46:53 +0000
+++ plugins/Utils/relativetimeformatter.h	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-/*
- * Copyright 2014 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 RELATIVETIMEFORMATTER_H
-#define RELATIVETIMEFORMATTER_H
-
-#include "timeformatter.h"
-
-// TODO - move this to the sdk
-// https://blueprints.launchpad.net/ubuntu-ui-toolkit/+spec/time-formatter
-class RelativeTimeFormatter : public GDateTimeFormatter
-{
-    Q_OBJECT
-public:
-    RelativeTimeFormatter(QObject *parent = 0);
-
-    QString format() const override;
-};
-
-#endif // RELATIVETIMEFORMATTER_H

=== removed file 'plugins/Utils/timeformatter.cpp'
--- plugins/Utils/timeformatter.cpp	2015-09-24 14:02:25 +0000
+++ plugins/Utils/timeformatter.cpp	1970-01-01 00:00:00 +0000
@@ -1,206 +0,0 @@
-/*
- * Copyright 2013 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/>.
- *
- * Author: Lars Uebernickel <[e-mail]>
- */
-
-#include "timeformatter.h"
-
-#include <gio/gio.h>
-#include <QDateTime>
-
-struct TimeFormatterPrivate
-{
-    TimeFormatter *formatter;
-
-    QString format;
-    QString timeString;
-    qint64 time;
-
-    GDBusConnection *system_bus;
-    guint subscription_id;
-    GCancellable *cancellable;
-};
-
-static void
-timedate1_properties_changed (GDBusConnection *connection,
-                              const gchar *sender_name,
-                              const gchar *object_path,
-                              const gchar *interface_name,
-                              const gchar *signal_name,
-                              GVariant *parameters,
-                              gpointer user_data)
-{
-    Q_UNUSED(connection);
-    Q_UNUSED(sender_name);
-    Q_UNUSED(object_path);
-    Q_UNUSED(interface_name);
-    Q_UNUSED(signal_name);
-
-    TimeFormatterPrivate *priv = (TimeFormatterPrivate *)user_data;
-    GVariant *changed;
-    GVariantIter *iter;
-    const gchar *name;
-
-    if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(sa{sv}as)")))
-        return;
-
-    g_variant_get (parameters, "(s@a{sv}as)", nullptr, &changed, &iter);
-
-    if (g_variant_lookup (changed, "Timezone", "s", nullptr)) {
-        priv->formatter->update();
-    }
-    else {
-        while (g_variant_iter_next (iter, "&s", &name)) {
-            if (g_str_equal (name, "Timezone")) {
-                priv->formatter->update();
-                break;
-            }
-        }
-    }
-
-    g_variant_unref (changed);
-    g_variant_iter_free (iter);
-}
-
-static void
-got_bus(GObject *object, GAsyncResult *result, gpointer user_data)
-{
-    Q_UNUSED(object);
-
-    TimeFormatterPrivate *priv = (TimeFormatterPrivate *)user_data;
-    GError *error = nullptr;
-
-    priv->system_bus = g_bus_get_finish (result, &error);
-    if (priv->system_bus == nullptr) {
-        if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-            qWarning("TimeFormatter: cannot connect to the system bus: %s", error->message);
-        g_error_free (error);
-        return;
-    }
-
-    /* Listen to the PropertiesChanged on the org.freedesktop.timedate1
-     * interface from any sender. In practice, this signal will only be sent
-     * from timedated (we can trust other processes on the system bus to behave
-     * nicely). That way, we don't have to watch timedated's well-known name
-     * and keep the process alive.
-     */
-    priv->subscription_id = g_dbus_connection_signal_subscribe (priv->system_bus,
-                                                                nullptr,   /* sender */
-                                                                "org.freedesktop.DBus.Properties",
-                                                                "PropertiesChanged",
-                                                                nullptr,
-                                                                "org.freedesktop.timedate1",
-                                                                G_DBUS_SIGNAL_FLAGS_NONE,
-                                                                timedate1_properties_changed,
-                                                                priv, nullptr);
-}
-
-TimeFormatter::TimeFormatter(QObject *parent): QObject(parent)
-{
-    priv = new TimeFormatterPrivate;
-    priv->formatter = this;
-    priv->time = 0;
-    priv->format = QStringLiteral("yyyy-MM-dd hh:mm");
-    priv->system_bus = nullptr;
-    priv->subscription_id = 0;
-    priv->cancellable = g_cancellable_new ();
-
-    g_bus_get (G_BUS_TYPE_SYSTEM, priv->cancellable, got_bus, priv);
-}
-
-TimeFormatter::TimeFormatter(const QString &initialFormat, QObject *parent): TimeFormatter(parent)
-{
-    priv->format = initialFormat;
-}
-
-TimeFormatter::~TimeFormatter()
-{
-    if (priv->system_bus) {
-        g_dbus_connection_signal_unsubscribe (priv->system_bus, priv->subscription_id);
-        g_object_unref (priv->system_bus);
-    }
-
-    g_cancellable_cancel (priv->cancellable);
-    g_object_unref (priv->cancellable);
-}
-
-QString TimeFormatter::format() const
-{
-    return priv->format;
-}
-
-QString TimeFormatter::timeString() const
-{
-    return priv->timeString;
-}
-
-qint64 TimeFormatter::time() const
-{
-    return priv->time;
-}
-
-void TimeFormatter::setFormat(const QString &format)
-{
-    if (priv->format != format) {
-        priv->format = format;
-        Q_EMIT formatChanged(priv->format);
-        update();
-    }
-}
-
-void TimeFormatter::setTime(qint64 time)
-{
-    if (priv->time != time) {
-        priv->time = time;
-        Q_EMIT timeChanged(priv->time);
-        update();
-    }
-}
-
-void TimeFormatter::update()
-{
-    priv->timeString = formatTime();
-    Q_EMIT timeStringChanged(priv->timeString);
-}
-
-QString TimeFormatter::formatTime() const
-{
-    return QDateTime::fromMSecsSinceEpoch(time() / 1000).toString(format());
-}
-
-GDateTimeFormatter::GDateTimeFormatter(QObject* parent)
-: TimeFormatter(QStringLiteral("%d-%m-%Y %I:%M%p"), parent)
-{
-}
-
-QString GDateTimeFormatter::formatTime() const
-{
-    gchar* time_string;
-    GDateTime* datetime;
-    QByteArray formatBytes = format().toUtf8();
-
-    datetime = g_date_time_new_from_unix_local(time());
-    if (!datetime) {
-        return QLatin1String("");
-    }
-
-    time_string = g_date_time_format(datetime, formatBytes.constData());
-    QString formattedTime(QString::fromUtf8(time_string));
-
-    g_free(time_string);
-    g_date_time_unref(datetime);
-    return formattedTime;
-}

=== removed file 'plugins/Utils/timeformatter.h'
--- plugins/Utils/timeformatter.h	2015-09-17 13:42:15 +0000
+++ plugins/Utils/timeformatter.h	1970-01-01 00:00:00 +0000
@@ -1,68 +0,0 @@
-/*
- * Copyright 2013 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/>.
- *
- * Author: Lars Uebernickel <[e-mail]>
- */
-
-#ifndef TIME_FORMATTER_H
-#define TIME_FORMATTER_H
-
-#include <QObject>
-
-// TODO - bug #1260728
-class TimeFormatter : public QObject
-{
-    Q_OBJECT
-    Q_PROPERTY(QString format READ format WRITE setFormat NOTIFY formatChanged)
-    Q_PROPERTY(QString timeString READ timeString NOTIFY timeStringChanged)
-    Q_PROPERTY(qint64 time READ time WRITE setTime NOTIFY timeChanged)
-
-public:
-    TimeFormatter(QObject *parent = 0);
-    virtual ~TimeFormatter();
-
-    virtual QString format() const;
-    QString timeString() const;
-    qint64 time() const;
-
-    void setFormat(const QString &format);
-    void setTime(qint64 time);
-
-    void update();
-
-Q_SIGNALS:
-    void formatChanged(const QString &format);
-    void timeStringChanged(const QString &timeString);
-    void timeChanged(qint64 time);
-
-protected:
-    TimeFormatter(const QString &initialFormat, QObject *parent = 0);
-
-    virtual QString formatTime() const;
-
-private:
-    struct TimeFormatterPrivate *priv;
-};
-
-class GDateTimeFormatter : public TimeFormatter
-{
-public:
-    GDateTimeFormatter(QObject *parent = 0);
-
-protected:
-    QString formatTime() const override;
-};
-
-#endif

=== modified file 'plugins/Utils/timezoneFormatter.cpp'
--- plugins/Utils/timezoneFormatter.cpp	2015-09-17 13:42:15 +0000
+++ plugins/Utils/timezoneFormatter.cpp	2015-10-26 12:04:03 +0000
@@ -29,7 +29,7 @@
     if (tz.isValid()) {
         const QDateTime now = QDateTime::currentDateTime().toTimeZone(tz);
         // return locale-aware string in the form "day, hh:mm", e.g. "Mon 14:30" or "Mon 1:30 pm"
-        return QStringLiteral("%1 %2").arg(now.toString("ddd")).arg(now.time().toString(Qt::DefaultLocaleShortDate));
+        return QStringLiteral("%1 %2").arg(now.toString(QStringLiteral("ddd"))).arg(now.time().toString(Qt::DefaultLocaleShortDate));
     }
     return QString();
 }

=== modified file 'qml/Components/Dialogs.qml'
--- qml/Components/Dialogs.qml	2015-09-02 09:30:32 +0000
+++ qml/Components/Dialogs.qml	2015-10-26 12:04:03 +0000
@@ -20,6 +20,7 @@
 import Unity.Session 0.1
 import Ubuntu.Components 1.1
 import GlobalShortcut 1.0
+import Unity.Platform 1.0
 import "../Greeter"
 
 Item {
@@ -46,13 +47,13 @@
 
     GlobalShortcut { // reboot/shutdown dialog
         shortcut: Qt.Key_PowerDown
-        active: root.usageScenario === "desktop"
+        active: Platform.isPC
         onTriggered: root.unitySessionService.RequestShutdown()
     }
 
     GlobalShortcut { // reboot/shutdown dialog
         shortcut: Qt.Key_PowerOff
-        active: root.usageScenario === "desktop"
+        active: Platform.isPC
         onTriggered: root.unitySessionService.RequestShutdown()
     }
 

=== modified file 'qml/Components/ScreenGrabber.qml'
--- qml/Components/ScreenGrabber.qml	2015-08-24 15:39:53 +0000
+++ qml/Components/ScreenGrabber.qml	2015-10-26 12:04:03 +0000
@@ -26,6 +26,9 @@
     anchors.fill: parent
     opacity: 0.0
 
+    // to be set from outside
+    property int rotationAngle: 0
+
     ScreenGrabber {
         id: screenGrabber
         objectName: "screenGrabber"
@@ -67,7 +70,7 @@
         to: 0.0
         onStopped: {
             if (visible) {
-                screenGrabber.captureAndSave();
+                screenGrabber.captureAndSave(root.rotationAngle);
                 visible = false;
             }
         }

=== added file 'qml/Components/WallpaperResolver.qml'
--- qml/Components/WallpaperResolver.qml	1970-01-01 00:00:00 +0000
+++ qml/Components/WallpaperResolver.qml	2015-10-26 12:04:03 +0000
@@ -0,0 +1,63 @@
+/*
+ * 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
+import AccountsService 0.1
+import GSettings 1.0
+import Ubuntu.Components 1.3
+
+/*
+    Defines the background URL based on several factors, such as:
+        - default, fallback, background
+        - Background set in AccountSettings, if any
+        - Background set in GSettings, if any
+ */
+QtObject {
+    // Users should set their UI width here.
+    property real width
+
+    property url defaultBackground: Qt.resolvedUrl(width >= units.gu(60) ? "../graphics/tablet_background.jpg"
+                                                                         : "../graphics/phone_background.jpg")
+
+    // That's the property users of this component are going to consume.
+    readonly property url background: asImageTester.status == Image.Ready ? asImageTester.source
+                                    : gsImageTester.status == Image.Ready ? gsImageTester.source : defaultBackground
+
+    // This is a dummy image to detect if the custom AS set wallpaper loads successfully.
+    property var _asImageTester: Image {
+        id: asImageTester
+        source: AccountsService.backgroundFile != undefined && AccountsService.backgroundFile.length > 0 ? AccountsService.backgroundFile : ""
+        height: 0
+        width: 0
+        sourceSize.height: 0
+        sourceSize.width: 0
+    }
+
+    // This is a dummy image to detect if the custom GSettings set wallpaper loads successfully.
+    property var _gsImageTester: Image {
+        id: gsImageTester
+        source: backgroundSettings.pictureUri && backgroundSettings.pictureUri.length > 0 ? backgroundSettings.pictureUri : ""
+        height: 0
+        width: 0
+        sourceSize.height: 0
+        sourceSize.width: 0
+    }
+
+    property var _gsettings: GSettings {
+        id: backgroundSettings
+        schema.id: "org.gnome.desktop.background"
+    }
+}

=== modified file 'qml/DeviceConfiguration.qml'
--- qml/DeviceConfiguration.qml	2015-07-01 17:52:34 +0000
+++ qml/DeviceConfiguration.qml	2015-10-26 12:04:03 +0000
@@ -86,6 +86,7 @@
             PropertyChanges {
                 target: root
                 category: "desktop"
+                supportedOrientations: root.useNativeOrientation
             }
         }
     ]

=== added file 'qml/DisabledScreenNotice.qml'
--- qml/DisabledScreenNotice.qml	1970-01-01 00:00:00 +0000
+++ qml/DisabledScreenNotice.qml	2015-10-26 12:04:03 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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
+import Ubuntu.Components 1.3
+import "Components"
+
+Image {
+    id: root
+
+    WallpaperResolver {
+        width: root.width
+        id: wallpaperResolver
+    }
+
+    source: wallpaperResolver.background
+
+    UbuntuShape {
+        anchors.fill: text
+        anchors.margins: -units.gu(2)
+        backgroundColor: "black"
+        opacity: 0.4
+    }
+
+    Label {
+        id: text
+        anchors.centerIn: parent
+        width: parent.width / 2
+        text: i18n.tr("Your device is now connected to an external display.")
+        color: "white"
+        horizontalAlignment: Text.AlignHCenter
+        verticalAlignment: Text.AlignVCenter
+        fontSize: "x-large"
+        wrapMode: Text.Wrap
+    }
+}

=== modified file 'qml/Greeter/Greeter.qml'
--- qml/Greeter/Greeter.qml	2015-09-02 13:06:56 +0000
+++ qml/Greeter/Greeter.qml	2015-10-26 12:04:03 +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-26 12:04:03 +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/Notifications/Notification.qml'
--- qml/Notifications/Notification.qml	2015-10-08 19:30:59 +0000
+++ qml/Notifications/Notification.qml	2015-10-26 12:04:03 +0000
@@ -50,6 +50,7 @@
     readonly property real contentSpacing: units.gu(2)
     readonly property bool canBeClosed: type === Notification.Ephemeral
     property bool hasMouse
+    property url background: ""
 
     objectName: "background"
     implicitHeight: type !== Notification.PlaceHolder ? (fullscreen ? maxHeight : outterColumn.height - shapedBack.anchors.topMargin + contentSpacing * 2) : 0
@@ -401,6 +402,7 @@
                         menuData: model
                         menuIndex: index
                         maxHeight: notification.maxHeight
+                        background: notification.background
 
                         onLoaded: {
                             notification.fullscreen = Qt.binding(function() { return fullscreen; });

=== modified file 'qml/Notifications/NotificationMenuItemFactory.qml'
--- qml/Notifications/NotificationMenuItemFactory.qml	2014-11-17 13:46:56 +0000
+++ qml/Notifications/NotificationMenuItemFactory.qml	2015-10-26 12:04:03 +0000
@@ -30,6 +30,7 @@
     property int menuIndex : -1
     property int maxHeight
     readonly property bool fullscreen: menuData.type === "com.canonical.snapdecision.pinlock"
+    property url background: ""
 
     signal accepted()
 
@@ -149,7 +150,7 @@
             infoText: notification.summary
             errorText: errorAction.valid ? errorAction.state : ""
             retryText: notification.body
-            background: shell.background
+            background: menuFactory.background
             darkenBackground: 0.4
 
             onEntered: {

=== modified file 'qml/Notifications/Notifications.qml'
--- qml/Notifications/Notifications.qml	2015-09-22 14:23:44 +0000
+++ qml/Notifications/Notifications.qml	2015-10-26 12:04:03 +0000
@@ -29,6 +29,7 @@
     property real margin
     property bool useModal: snapDecisionProxyModel.count > 0
     property bool hasMouse
+    property url background: ""
 
     UnitySortFilterProxyModel {
         id: snapDecisionProxyModel
@@ -60,6 +61,7 @@
         maxHeight: notificationList.height
         margins: notificationList.margin
         hasMouse: notificationList.hasMouse
+        background: notificationList.background
 
         // make sure there's no opacity-difference between the several
         // elements in a notification

=== modified file 'qml/OrientedShell.qml'
--- qml/OrientedShell.qml	2015-09-22 14:23:44 +0000
+++ qml/OrientedShell.qml	2015-10-26 12:04:03 +0000
@@ -76,6 +76,12 @@
         oskSettings.disableHeight = shell.usageScenario == "desktop"
     }
 
+    // we must rotate to a supported orientation regardless of shell's preference
+    property bool orientationChangesEnabled:
+        (orientation & supportedOrientations) === 0 ? true
+                                                    : shell.orientationChangesEnabled
+
+
     Binding {
         target: oskSettings
         property: "stayHidden"
@@ -89,7 +95,10 @@
     }
 
     readonly property int supportedOrientations: shell.supportedOrientations
-                                               & deviceConfiguration.supportedOrientations
+        & (deviceConfiguration.supportedOrientations == deviceConfiguration.useNativeOrientation
+                ? nativeOrientation
+                : deviceConfiguration.supportedOrientations)
+
     property int acceptedOrientationAngle: {
         if (orientation & supportedOrientations) {
             return Screen.angleBetween(nativeOrientation, orientation);

=== modified file 'qml/Panel/Indicators/MenuItemFactory.qml'
--- qml/Panel/Indicators/MenuItemFactory.qml	2015-09-17 18:02:22 +0000
+++ qml/Panel/Indicators/MenuItemFactory.qml	2015-10-26 12:04:03 +0000
@@ -20,7 +20,7 @@
 import QMenuModel 0.1
 import Utils 0.1 as Utils
 import Ubuntu.Components.ListItems 0.1 as ListItems
-import Ubuntu.Components 1.2
+import Ubuntu.Components 1.3
 import Unity.Session 0.1
 
 Item {
@@ -350,20 +350,23 @@
         id: alarmMenu;
 
         Menus.EventMenu {
+            id: alarmItem
             objectName: "alarmMenu"
             property QtObject menuData: null
             property var menuModel: menuFactory.menuModel
             property int menuIndex: -1
             property var extendedData: menuData && menuData.ext || undefined
-            // TODO - bug #1260728
-            property var timeFormatter: Utils.GDateTimeFormatter {
-                time: getExtendedProperty(extendedData, "xCanonicalTime", 0)
-                format: getExtendedProperty(extendedData, "xCanonicalTimeFormat", "")
+
+            property date serverTime: new Date(getExtendedProperty(extendedData, "xCanonicalTime", 0) * 1000)
+            LiveTimer {
+                frequency: LiveTimer.Relative
+                relativeTime: alarmItem.serverTime
+                onTrigger: alarmItem.serverTime = new Date(getExtendedProperty(extendedData, "xCanonicalTime", 0) * 1000)
             }
 
             text: menuData && menuData.label || ""
             iconSource: menuData && menuData.icon || "image://theme/alarm-clock"
-            time: timeFormatter.timeString
+            time: i18n.relativeDateTime(serverTime)
             enabled: menuData && menuData.sensitive || false
             highlightWhenPressed: false
 
@@ -379,8 +382,7 @@
 
             function loadAttributes() {
                 if (!menuModel || menuIndex == -1) return;
-                menuModel.loadExtendedAttributes(menuIndex, {'x-canonical-time': 'int64',
-                                                             'x-canonical-time-format': 'string'});
+                menuModel.loadExtendedAttributes(menuIndex, {'x-canonical-time': 'int64'});
             }
         }
     }
@@ -389,20 +391,23 @@
         id: appointmentMenu;
 
         Menus.EventMenu {
+            id: appointmentItem
             objectName: "appointmentMenu"
             property QtObject menuData: null
             property var menuModel: menuFactory.menuModel
             property int menuIndex: -1
             property var extendedData: menuData && menuData.ext || undefined
-            // TODO - bug #1260728
-            property var timeFormatter: Utils.GDateTimeFormatter {
-                time: getExtendedProperty(extendedData, "xCanonicalTime", 0)
-                format: getExtendedProperty(extendedData, "xCanonicalTimeFormat", "")
+
+            property date serverTime: new Date(getExtendedProperty(extendedData, "xCanonicalTime", 0) * 1000)
+            LiveTimer {
+                frequency: LiveTimer.Relative
+                relativeTime: appointmentItem.serverTime
+                onTrigger: appointmentItem.serverTime = new Date(getExtendedProperty(extendedData, "xCanonicalTime", 0) * 1000)
             }
 
             text: menuData && menuData.label || ""
             iconSource: menuData && menuData.icon || "image://theme/calendar"
-            time: timeFormatter.timeString
+            time: i18n.relativeDateTime(serverTime)
             eventColor: getExtendedProperty(extendedData, "xCanonicalColor", Qt.rgba(0.0, 0.0, 0.0, 0.0))
             enabled: menuData && menuData.sensitive || false
             highlightWhenPressed: false
@@ -420,8 +425,7 @@
             function loadAttributes() {
                 if (!menuModel || menuIndex == -1) return;
                 menuModel.loadExtendedAttributes(menuIndex, {'x-canonical-color': 'string',
-                                                             'x-canonical-time': 'int64',
-                                                             'x-canonical-time-format': 'string'});
+                                                             'x-canonical-time': 'int64'});
             }
         }
     }

=== modified file 'qml/Panel/Indicators/MessageMenuItemFactory.qml'
--- qml/Panel/Indicators/MessageMenuItemFactory.qml	2015-09-15 22:50:16 +0000
+++ qml/Panel/Indicators/MessageMenuItemFactory.qml	2015-10-26 12:04:03 +0000
@@ -19,7 +19,7 @@
  */
 
 import QtQuick 2.0
-import Ubuntu.Components 0.1
+import Ubuntu.Components 1.3
 import Ubuntu.Settings.Menus 0.1 as Menus
 import QMenuModel 0.1 as QMenuModel
 import Utils 0.1 as Utils
@@ -35,12 +35,17 @@
     signal menuSelected
     signal menuDeselected
 
-    property var extendedData: menuData && menuData.ext || undefined
-    property var actionsDescription: getExtendedProperty(extendedData, "xCanonicalMessageActions", undefined)
-
-    // TODO - bug #1260728
-    property var timeFormatter: Utils.RelativeTimeFormatter {
-        time: getExtendedProperty(extendedData, "xCanonicalTime", 0) / 1000000
+    QtObject {
+        id: priv
+        property var extendedData: menuData && menuData.ext || undefined
+        property var actionsDescription: getExtendedProperty(extendedData, "xCanonicalMessageActions", undefined)
+        property date time: new Date(getExtendedProperty(extendedData, "xCanonicalTime", 0) / 1000)
+        property string timeString: i18n.relativeDateTime(time)
+    }
+    LiveTimer {
+        frequency: LiveTimer.Relative
+        relativeTime: priv.time
+        onTrigger: priv.timeString = Qt.binding(function() { return i18n.relativeDateTime(priv.time); })
     }
 
     onMenuModelChanged: {
@@ -50,7 +55,7 @@
         loadAttributes();
     }
 
-    sourceComponent: loadMessage(actionsDescription)
+    sourceComponent: loadMessage(priv.actionsDescription)
 
     function loadMessage(actions)
     {
@@ -100,11 +105,11 @@
             objectName: "simpleTextMessage"
             // text
             title: menuData && menuData.label || ""
-            time: timeFormatter.timeString
-            body: getExtendedProperty(extendedData, "xCanonicalText", "")
+            time: priv.timeString
+            body: getExtendedProperty(priv.extendedData, "xCanonicalText", "")
             // icons
-            avatar: getExtendedProperty(extendedData, "icon", "image://theme/contact")
-            icon: getExtendedProperty(extendedData, "xCanonicalAppIcon", "image://theme/message")
+            avatar: getExtendedProperty(priv.extendedData, "icon", "image://theme/contact")
+            icon: getExtendedProperty(priv.extendedData, "xCanonicalAppIcon", "image://theme/message")
             // actions
             enabled: menuData && menuData.sensitive || false
             removable: !selected
@@ -133,7 +138,9 @@
         Menus.TextMessageMenu {
             id: message
             objectName: "textMessage"
-            property var replyActionDescription: actionsDescription && actionsDescription.length > 0 ? actionsDescription[0] : undefined
+            property var replyActionDescription: priv.actionsDescription && priv.actionsDescription.length > 0 ?
+                                                     priv.actionsDescription[0] :
+                                                     undefined
 
             property var replyAction: QMenuModel.UnityMenuAction {
                 model: menuModel
@@ -143,13 +150,13 @@
 
             // text
             title: menuData && menuData.label || ""
-            time: timeFormatter.timeString
-            body: getExtendedProperty(extendedData, "xCanonicalText", "")
-            replyButtonText: getExtendedProperty(replyActionDescription, "label", i18n.tr("Send"))
+            time: priv.timeString
+            body: getExtendedProperty(priv.extendedData, "xCanonicalText", "")
+            replyButtonText: getExtendedProperty(replyActionDescription, "label", i18n.ctr("Button: Send a reply message", "Send"))
             replyHintText: i18n.ctr("Label: Hint in message indicator line edit", "Reply")
             // icons
-            avatar: getExtendedProperty(extendedData, "icon", "image://theme/contact")
-            icon: getExtendedProperty(extendedData, "xCanonicalAppIcon", "image://theme/message")
+            avatar: getExtendedProperty(priv.extendedData, "icon", "image://theme/contact")
+            icon: getExtendedProperty(priv.extendedData, "xCanonicalAppIcon", "image://theme/message")
             // actions
             replyEnabled: replyAction.valid && replyAction.enabled
             enabled: menuData && menuData.sensitive || false
@@ -183,8 +190,10 @@
         Menus.SnapDecisionMenu {
             id: message
             objectName: "snapDecision"
-            property var activateActionDescription: actionsDescription && actionsDescription.length > 0 ? actionsDescription[0] : undefined
-            property var replyActionDescription: actionsDescription && actionsDescription.length > 1 ? actionsDescription[1] : undefined
+            property var activateActionDescription: priv.actionsDescription && priv.actionsDescription.length > 0 ?
+                                                        priv.actionsDescription[0] : undefined
+            property var replyActionDescription: priv.actionsDescription && priv.actionsDescription.length > 1 ?
+                                                     priv.actionsDescription[1] : undefined
 
             property var activateAction: QMenuModel.UnityMenuAction {
                 model: menuModel
@@ -199,13 +208,13 @@
 
             // text
             title: menuData && menuData.label || ""
-            time: timeFormatter.timeString
-            body: getExtendedProperty(extendedData, "xCanonicalText", "")
-            actionButtonText: getExtendedProperty(activateActionDescription, "label", i18n.tr("Call back"))
-            replyButtonText: getExtendedProperty(replyActionDescription, "label", i18n.tr("Send"))
+            time: priv.timeString
+            body: getExtendedProperty(priv.extendedData, "xCanonicalText", "")
+            actionButtonText: getExtendedProperty(activateActionDescription, "label", i18n.ctr("Button: Call back on phone", "Call back"))
+            replyButtonText: getExtendedProperty(replyActionDescription, "label", i18n.ctr("Button: Send a reply message", "Send"))
             // icons
-            avatar: getExtendedProperty(extendedData, "icon", "image://theme/contact")
-            icon: getExtendedProperty(extendedData, "xCanonicalAppIcon", "image://theme/missed-call")
+            avatar: getExtendedProperty(priv.extendedData, "icon", "image://theme/contact")
+            icon: getExtendedProperty(priv.extendedData, "xCanonicalAppIcon", "image://theme/missed-call")
             // actions
             actionEnabled: activateAction.valid && activateAction.enabled
             replyEnabled: replyAction.valid && replyAction.enabled

=== modified file 'qml/Panel/Panel.qml'
--- qml/Panel/Panel.qml	2015-06-29 03:58:22 +0000
+++ qml/Panel/Panel.qml	2015-10-26 12:04:03 +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/Rotation/RotationStates.qml'
--- qml/Rotation/RotationStates.qml	2015-05-11 14:36:03 +0000
+++ qml/Rotation/RotationStates.qml	2015-10-26 12:04:03 +0000
@@ -83,7 +83,7 @@
         }
 
         function tryUpdateState() {
-            if (d.transitioning || (!d.startingUp && !root.shell.orientationChangesEnabled)) {
+            if (d.transitioning || (!d.startingUp && !root.orientedShell.orientationChangesEnabled)) {
                 return;
             }
 
@@ -95,7 +95,7 @@
         }
 
         property Connections shellConnections: Connections {
-            target: root.shell
+            target: root.orientedShell
             onOrientationChangesEnabledChanged: {
                 d.tryUpdateState();
             }

=== modified file 'qml/Shell.qml'
--- qml/Shell.qml	2015-09-22 14:23:44 +0000
+++ qml/Shell.qml	2015-10-26 12:04:03 +0000
@@ -17,7 +17,6 @@
 import QtQuick 2.0
 import QtQuick.Window 2.0
 import AccountsService 0.1
-import GSettings 1.0
 import Unity.Application 0.1
 import Ubuntu.Components 0.1
 import Ubuntu.Components.Popups 1.0
@@ -41,6 +40,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 +63,7 @@
     function updateFocusedAppOrientationAnimated() {
         applicationsDisplayLoader.item.updateFocusedAppOrientationAnimated();
     }
-    property bool hasMouse
+    property bool hasMouse: false
 
     // to be read from outside
     readonly property int mainAppWindowOrientationAngle:
@@ -107,9 +107,11 @@
     enabled: greeter && !greeter.waiting
 
     property real edgeSize: units.gu(2)
-    property url defaultBackground: Qt.resolvedUrl(shell.width >= units.gu(60) ? "graphics/tablet_background.jpg" : "graphics/phone_background.jpg")
-    property url background: asImageTester.status == Image.Ready ? asImageTester.source
-                             : gsImageTester.status == Image.Ready ? gsImageTester.source : defaultBackground
+
+    WallpaperResolver {
+        id: wallpaperResolver
+        width: shell.width
+    }
 
     readonly property alias greeter: greeterLoader.item
 
@@ -130,31 +132,6 @@
         shell.activateApplication(app);
     }
 
-    // This is a dummy image to detect if the custom AS set wallpaper loads successfully.
-    Image {
-        id: asImageTester
-        source: AccountsService.backgroundFile != undefined && AccountsService.backgroundFile.length > 0 ? AccountsService.backgroundFile : ""
-        height: 0
-        width: 0
-        sourceSize.height: 0
-        sourceSize.width: 0
-    }
-
-    GSettings {
-        id: backgroundSettings
-        schema.id: "org.gnome.desktop.background"
-    }
-
-    // This is a dummy image to detect if the custom GSettings set wallpaper loads successfully.
-    Image {
-        id: gsImageTester
-        source: backgroundSettings.pictureUri && backgroundSettings.pictureUri.length > 0 ? backgroundSettings.pictureUri : ""
-        height: 0
-        width: 0
-        sourceSize.height: 0
-        sourceSize.width: 0
-    }
-
     Binding {
         target: LauncherModel
         property: "applicationManager"
@@ -190,11 +167,6 @@
         onScreenshotTriggered: screenGrabber.capture();
     }
 
-    ScreenGrabber {
-        id: screenGrabber
-        z: dialogs.z + 10
-    }
-
     GlobalShortcut {
         // dummy shortcut to force creation of GlobalShortcutRegistry before WindowKeyFilter
     }
@@ -327,7 +299,7 @@
             Binding {
                 target: applicationsDisplayLoader.item
                 property: "background"
-                value: shell.background
+                value: wallpaperResolver.background
             }
             Binding {
                 target: applicationsDisplayLoader.item
@@ -432,7 +404,7 @@
             tabletMode: shell.usageScenario != "phone"
             launcherOffset: launcher.progress
             forcedUnlock: tutorial.running
-            background: shell.background
+            background: wallpaperResolver.background
 
             // avoid overlapping with Launcher's edge drag area
             // FIXME: Fix TouchRegistry & friends and remove this workaround
@@ -607,7 +579,7 @@
             id: wizard
             objectName: "wizard"
             anchors.fill: parent
-            background: shell.background
+            background: wallpaperResolver.background
 
             function unlockWhenDoneWithWizard() {
                 if (!active) {
@@ -638,6 +610,7 @@
             model: NotificationBackend.Model
             margin: units.gu(1)
             hasMouse: shell.hasMouse
+            background: wallpaperResolver.background
 
             y: topmostIsFullscreen ? 0 : panel.panelHeight
             height: parent.height - (topmostIsFullscreen ? 0 : panel.panelHeight)
@@ -684,9 +657,21 @@
         onShowHome: showHome()
     }
 
+    ScreenGrabber {
+        id: screenGrabber
+        rotationAngle: -shell.orientationAngle
+        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"
@@ -703,5 +688,4 @@
             }
         }
     }
-
 }

=== modified file 'qml/Stages/ApplicationWindow.qml'
--- qml/Stages/ApplicationWindow.qml	2015-09-17 12:25:29 +0000
+++ qml/Stages/ApplicationWindow.qml	2015-10-26 12:04:03 +0000
@@ -27,6 +27,8 @@
     readonly property bool fullscreen: application ? application.fullscreen : false
     property alias interactive: sessionContainer.interactive
     property bool orientationChangesEnabled: d.supportsSurfaceResize ? d.surfaceOldEnoughToBeResized : true
+    readonly property string title: sessionContainer.surface && sessionContainer.surface.name !== "" ?
+                                        sessionContainer.surface.name : d.name
 
     // to be set from outside
     property QtObject application

=== modified file 'qml/Stages/DecoratedWindow.qml'
--- qml/Stages/DecoratedWindow.qml	2015-09-08 10:32:28 +0000
+++ qml/Stages/DecoratedWindow.qml	2015-10-26 12:04:03 +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,13 +62,15 @@
 
     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)
-        title: model.name
+        title: window.title !== "" ? window.title : model.name
         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-26 12:04:03 +0000
@@ -138,9 +138,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,12 +212,11 @@
                     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) }
@@ -240,6 +236,7 @@
                     onClose: ApplicationManager.stopApplication(model.appId)
                     onMaximize: appDelegate.maximize()
                     onMinimize: appDelegate.minimize()
+                    onDecorationPressed: { ApplicationManager.focusApplication(model.appId) }
                 }
             }
         }

=== modified file 'qml/Stages/SurfaceContainer.qml'
--- qml/Stages/SurfaceContainer.qml	2015-09-09 13:44:12 +0000
+++ qml/Stages/SurfaceContainer.qml	2015-10-26 12:04:03 +0000
@@ -28,6 +28,7 @@
     property bool hadSurface: false
     property bool interactive
     property int surfaceOrientationAngle: 0
+    property string name: surface ? surface.name : ""
     property bool resizeSurface: true
 
     onSurfaceChanged: {

=== modified file 'qml/Stages/WindowDecoration.qml'
--- qml/Stages/WindowDecoration.qml	2015-03-13 19:18:35 +0000
+++ qml/Stages/WindowDecoration.qml	2015-10-26 12:04:03 +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,53 @@
  *
  * 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;
+            Mir.cursorName = "grabbing";
+        } else {
+            priv.dragging = false;
+            Mir.cursorName = "";
+        }
+    }
+    onPositionChanged: {
+        if (priv.dragging) {
+            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-26 12:04:03 +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 'src/ApplicationArguments.h'
--- src/ApplicationArguments.h	2015-09-14 09:11:08 +0000
+++ src/ApplicationArguments.h	2015-10-26 12:04:03 +0000
@@ -26,17 +26,25 @@
 class ApplicationArguments : public QObject
 {
     Q_OBJECT
-    Q_PROPERTY(QString deviceName READ deviceName CONSTANT)
+    Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)
     Q_PROPERTY(QString mode READ mode CONSTANT)
 public:
     ApplicationArguments(QObject *parent = nullptr);
 
-    void setDeviceName(const QString &deviceName) { m_deviceName = deviceName; }
+    void setDeviceName(const QString &deviceName) {
+        if (deviceName != m_deviceName) {
+            m_deviceName = deviceName;
+            Q_EMIT deviceNameChanged(m_deviceName);
+        }
+    }
     QString deviceName() const { return m_deviceName; }
 
     void setMode(const QString &mode) { m_mode = mode; }
     QString mode() const { return m_mode; }
 
+Q_SIGNALS:
+    void deviceNameChanged(const QString&);
+
 private:
     QString m_deviceName;
     QString m_mode;

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-06-24 11:41:09 +0000
+++ src/CMakeLists.txt	2015-10-26 12:04:03 +0000
@@ -21,6 +21,9 @@
     main.cpp
     MouseTouchAdaptor.cpp
     CachingNetworkManagerFactory.cpp
+    SecondaryWindow.cpp
+    ShellApplication.cpp
+    ShellView.cpp
     UnityCommandLineParser.cpp
     ${QML_FILES} # This is to make qml and image files appear in the IDE's project tree
 )

=== added file 'src/SecondaryWindow.cpp'
--- src/SecondaryWindow.cpp	1970-01-01 00:00:00 +0000
+++ src/SecondaryWindow.cpp	2015-10-26 12:04:03 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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/>.
+ */
+
+#include "SecondaryWindow.h"
+
+// local
+#include <paths.h>
+
+SecondaryWindow::SecondaryWindow(QQmlEngine *engine)
+    : QQuickView(engine, nullptr)
+{
+    setResizeMode(QQuickView::SizeRootObjectToView);
+    setColor("black");
+    setTitle(QStringLiteral("Unity8 Shell - Secondary Screen"));
+
+    QUrl source(::qmlDirectory() + "/DisabledScreenNotice.qml");
+    setSource(source);
+}

=== added file 'src/SecondaryWindow.h'
--- src/SecondaryWindow.h	1970-01-01 00:00:00 +0000
+++ src/SecondaryWindow.h	2015-10-26 12:04:03 +0000
@@ -0,0 +1,30 @@
+/*
+ * 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 UNITY_SECONDARY_WINDOW_H
+#define UNITY_SECONDARY_WINDOW_H
+
+#include <QQuickView>
+
+class SecondaryWindow : public QQuickView
+{
+    Q_OBJECT
+
+public:
+    SecondaryWindow(QQmlEngine *engine);
+};
+
+#endif // UNITY_SECONDARY_WINDOW_H

=== added file 'src/ShellApplication.cpp'
--- src/ShellApplication.cpp	1970-01-01 00:00:00 +0000
+++ src/ShellApplication.cpp	2015-10-26 12:04:03 +0000
@@ -0,0 +1,197 @@
+/*
+ * 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/>.
+ */
+
+#include "ShellApplication.h"
+
+// Qt
+#include <QLibrary>
+#include <QScreen>
+
+#include <libintl.h>
+
+// libandroid-properties
+#include <hybris/properties/properties.h>
+
+// local
+#include <paths.h>
+#include "CachingNetworkManagerFactory.h"
+#include "MouseTouchAdaptor.h"
+#include "UnityCommandLineParser.h"
+
+ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)
+    : QGuiApplication(argc, argv)
+    , m_shellView(nullptr)
+    , m_secondaryWindow(nullptr)
+    , m_mouseTouchAdaptor(nullptr)
+    , m_qmlEngine(nullptr)
+{
+
+    setApplicationName(QStringLiteral("unity8"));
+
+    connect(this, &QGuiApplication::screenAdded, this, &ShellApplication::onScreenAdded);
+
+    setupQmlEngine(isMirServer);
+
+    UnityCommandLineParser parser(*this);
+
+    if (!parser.deviceName().isEmpty()) {
+        m_deviceName = parser.deviceName();
+    } else {
+        char buffer[200];
+        property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);
+        m_deviceName = QString(buffer);
+    }
+    m_qmlArgs.setDeviceName(m_deviceName);
+
+    m_qmlArgs.setMode(parser.mode());
+
+    // The testability driver is only loaded by QApplication but not by QGuiApplication.
+    // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.
+    if (parser.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {
+        QLibrary testLib(QStringLiteral("qttestability"));
+        if (testLib.load()) {
+            typedef void (*TasInitialize)(void);
+            TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");
+            if (initFunction) {
+                initFunction();
+            } else {
+                qCritical("Library qttestability resolve failed!");
+            }
+        } else {
+            qCritical("Library qttestability load failed!");
+        }
+    }
+
+    bindtextdomain("unity8", translationDirectory().toUtf8().data());
+    textdomain("unity8");
+
+    m_shellView = new ShellView(m_qmlEngine, &m_qmlArgs);
+
+    if (parser.windowGeometry().isValid()) {
+        m_shellView->setWidth(parser.windowGeometry().width());
+        m_shellView->setHeight(parser.windowGeometry().height());
+    }
+
+    if (parser.hasFrameless()) {
+        m_shellView->setFlags(Qt::FramelessWindowHint);
+    }
+
+    // You will need this if you want to interact with touch-only components using a mouse
+    // Needed only when manually testing on a desktop.
+    if (parser.hasMouseToTouch()) {
+        m_mouseTouchAdaptor = MouseTouchAdaptor::instance();
+    }
+
+
+    // Some hard-coded policy for now.
+    // NB: We don't support more than two screens at the moment
+    //
+    // TODO: Support an arbitrary number of screens and different policies
+    //       (eg cloned desktop, several desktops, etc)
+    if (isMirServer && screens().count() == 2) {
+        m_shellView->setScreen(screens().at(1));
+        m_qmlArgs.setDeviceName("desktop");
+
+        m_secondaryWindow = new SecondaryWindow(m_qmlEngine);
+        m_secondaryWindow->setScreen(screens().at(0));
+        // QWindow::showFullScreen() also calls QWindow::requestActivate() and we don't want that!
+        m_secondaryWindow->setWindowState(Qt::WindowFullScreen);
+        m_secondaryWindow->setVisible(true);
+    }
+
+    if (isMirServer || parser.hasFullscreen()) {
+        m_shellView->showFullScreen();
+    } else {
+        m_shellView->show();
+    }
+}
+
+ShellApplication::~ShellApplication()
+{
+    destroyResources();
+}
+
+void ShellApplication::destroyResources()
+{
+    // Deletion order is important. Don't use QScopedPointers and the like
+    // Otherwise the process will hang on shutdown (bug somewhere I guess).
+    delete m_shellView;
+    m_shellView = nullptr;
+
+    delete m_secondaryWindow;
+    m_secondaryWindow = nullptr;
+
+    delete m_mouseTouchAdaptor;
+    m_mouseTouchAdaptor = nullptr;
+
+    delete m_qmlEngine;
+    m_qmlEngine = nullptr;
+}
+
+void ShellApplication::setupQmlEngine(bool isMirServer)
+{
+    m_qmlEngine = new QQmlEngine(this);
+
+    m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));
+
+    prependImportPaths(m_qmlEngine, ::overrideImportPaths());
+    if (!isMirServer) {
+        prependImportPaths(m_qmlEngine, ::nonMirImportPaths());
+    }
+    appendImportPaths(m_qmlEngine, ::fallbackImportPaths());
+
+    m_qmlEngine->setNetworkAccessManagerFactory(new CachingNetworkManagerFactory);
+
+    QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);
+}
+
+void ShellApplication::onScreenAdded(QScreen * /*screen*/)
+{
+    // TODO: Support an arbitrary number of screens and different policies
+    //       (eg cloned desktop, several desktops, etc)
+    if (screens().count() == 2) {
+        m_shellView->setScreen(screens().at(1));
+        m_qmlArgs.setDeviceName("desktop");
+        // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having
+        // its backing QPlatformWindow recreated). So lets refocus it.
+        m_shellView->requestActivate();
+
+        m_secondaryWindow = new SecondaryWindow(m_qmlEngine);
+        m_secondaryWindow->setScreen(screens().at(0));
+
+        // QWindow::showFullScreen() also calls QWindow::requestActivate() and we don't want that!
+        m_secondaryWindow->setWindowState(Qt::WindowFullScreen);
+        m_secondaryWindow->setVisible(true);
+    }
+}
+
+void ShellApplication::onScreenAboutToBeRemoved(QScreen *screen)
+{
+    // TODO: Support an arbitrary number of screens and different policies
+    //       (eg cloned desktop, several desktops, etc)
+    if (screen == m_shellView->screen()) {
+        Q_ASSERT(screens().count() > 1);
+        Q_ASSERT(screens().at(0) != screen);
+        Q_ASSERT(m_secondaryWindow);
+        delete m_secondaryWindow;
+        m_secondaryWindow = nullptr;
+        m_shellView->setScreen(screens().first());
+        m_qmlArgs.setDeviceName(m_deviceName);
+        // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having
+        // its backing QPlatformWindow recreated). So lets refocus it.
+        m_shellView->requestActivate();
+    }
+}

=== added file 'src/ShellApplication.h'
--- src/ShellApplication.h	1970-01-01 00:00:00 +0000
+++ src/ShellApplication.h	2015-10-26 12:04:03 +0000
@@ -0,0 +1,55 @@
+/*
+ * 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 SHELLAPPLICATION_H
+#define SHELLAPPLICATION_H
+
+#include <QGuiApplication>
+#include <QQmlEngine>
+#include <QQuickView>
+#include <QScopedPointer>
+
+#include "ApplicationArguments.h"
+#include "MouseTouchAdaptor.h"
+#include "SecondaryWindow.h"
+#include "ShellView.h"
+
+class ShellApplication : public QGuiApplication
+{
+    Q_OBJECT
+public:
+    ShellApplication(int & argc, char ** argv, bool isMirServer);
+    virtual ~ShellApplication();
+
+    void destroyResources();
+public Q_SLOTS:
+    // called by qtmir
+    void onScreenAboutToBeRemoved(QScreen *screen);
+
+private Q_SLOTS:
+    void onScreenAdded(QScreen*);
+
+private:
+    void setupQmlEngine(bool isMirServer);
+    QString m_deviceName;
+    ApplicationArguments m_qmlArgs;
+    ShellView *m_shellView;
+    SecondaryWindow *m_secondaryWindow;
+    MouseTouchAdaptor *m_mouseTouchAdaptor;
+    QQmlEngine *m_qmlEngine;
+};
+
+#endif // SHELLAPPLICATION_H

=== added file 'src/ShellView.cpp'
--- src/ShellView.cpp	1970-01-01 00:00:00 +0000
+++ src/ShellView.cpp	2015-10-26 12:04:03 +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 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/>.
+ */
+
+#include "ShellView.h"
+
+// Qt
+#include <QQmlContext>
+#include <QQuickItem>
+
+// local
+#include <paths.h>
+
+ShellView::ShellView(QQmlEngine *engine, QObject *qmlArgs)
+    : QQuickView(engine, nullptr)
+{
+    setResizeMode(QQuickView::SizeRootObjectToView);
+    setColor("black");
+    setTitle(QStringLiteral("Unity8"));
+
+    rootContext()->setContextProperty(QStringLiteral("applicationArguments"), qmlArgs);
+
+    QUrl source(::qmlDirectory() + "/OrientedShell.qml");
+    setSource(source);
+
+    connect(this, &QWindow::widthChanged, this, &ShellView::onWidthChanged);
+    connect(this, &QWindow::heightChanged, this, &ShellView::onHeightChanged);
+}
+
+void ShellView::onWidthChanged(int w)
+{
+    // For good measure in case SizeRootObjectToView doesn't fulfill its promise.
+    //
+    // There's at least one situation that's know to leave the root object with an outdated size.
+    // (really looks like Qt bug)
+    // Happens when starting unity8 with an external monitor already connected.
+    // The QResizeEvent we get still has the size of the first screen and since the resize move is triggered
+    // from the resize event handler, the root item doesn't get resized.
+    // TODO: Confirm the Qt bug and submit a patch upstream
+    rootObject()->setWidth(w);
+}
+
+void ShellView::onHeightChanged(int h)
+{
+    // See comment in ShellView::onWidthChanged()
+    rootObject()->setHeight(h);
+}

=== added file 'src/ShellView.h'
--- src/ShellView.h	1970-01-01 00:00:00 +0000
+++ src/ShellView.h	2015-10-26 12:04:03 +0000
@@ -0,0 +1,34 @@
+/*
+ * 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 UNITY_SHELL_VIEW_H
+#define UNITY_SHELL_VIEW_H
+
+#include <QQuickView>
+
+class ShellView : public QQuickView
+{
+    Q_OBJECT
+
+public:
+    ShellView(QQmlEngine *engine, QObject *qmlArgs);
+
+private Q_SLOTS:
+    void onWidthChanged(int);
+    void onHeightChanged(int);
+};
+
+#endif // UNITY_SHELL_VIEW_H

=== modified file 'src/main.cpp'
--- src/main.cpp	2015-09-23 15:14:01 +0000
+++ src/main.cpp	2015-10-26 12:04:03 +0000
@@ -14,26 +14,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-// Qt
-#include <QCommandLineParser>
-#include <QtQuick/QQuickView>
-#include <QtGui/QGuiApplication>
-#include <QtQml/QQmlEngine>
-#include <QtQml/QQmlContext>
-#include <QLibrary>
-#include <QDebug>
-#include <csignal>
-#include <libintl.h>
-
-// libandroid-properties
-#include <hybris/properties/properties.h>
-
 // local
-#include <paths.h>
-#include "MouseTouchAdaptor.h"
-#include "ApplicationArguments.h"
-#include "CachingNetworkManagerFactory.h"
-#include "UnityCommandLineParser.h"
+#include "ShellApplication.h"
 
 int main(int argc, const char *argv[])
 {
@@ -43,91 +25,12 @@
         isMirServer = true;
     }
 
-    QGuiApplication::setApplicationName(QStringLiteral("unity8"));
-    QGuiApplication *application;
-
-    application = new QGuiApplication(argc, (char**)argv);
-
-    UnityCommandLineParser parser(*application);
-
-    ApplicationArguments qmlArgs;
-
-    if (!parser.deviceName().isEmpty()) {
-        qmlArgs.setDeviceName(parser.deviceName());
-    } else {
-        char buffer[200];
-        property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);
-        qmlArgs.setDeviceName(QString(buffer));
-    }
-
-    qmlArgs.setMode(parser.mode());
-
-    // The testability driver is only loaded by QApplication but not by QGuiApplication.
-    // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.
-    if (parser.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {
-        QLibrary testLib(QStringLiteral("qttestability"));
-        if (testLib.load()) {
-            typedef void (*TasInitialize)(void);
-            TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");
-            if (initFunction) {
-                initFunction();
-            } else {
-                qCritical("Library qttestability resolve failed!");
-            }
-        } else {
-            qCritical("Library qttestability load failed!");
-        }
-    }
-
-    bindtextdomain("unity8", translationDirectory().toUtf8().data());
-    textdomain("unity8");
-
-    QQuickView* view = new QQuickView();
-    view->setResizeMode(QQuickView::SizeRootObjectToView);
-    view->setColor("black");
-    view->setTitle(QStringLiteral("Unity8 Shell"));
-
-    if (parser.windowGeometry().isValid()) {
-        view->setWidth(parser.windowGeometry().width());
-        view->setHeight(parser.windowGeometry().height());
-    }
-
-    view->engine()->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));
-    view->rootContext()->setContextProperty(QStringLiteral("applicationArguments"), &qmlArgs);
-    if (parser.hasFrameless()) {
-        view->setFlags(Qt::FramelessWindowHint);
-    }
-
-    // You will need this if you want to interact with touch-only components using a mouse
-    // Needed only when manually testing on a desktop.
-    MouseTouchAdaptor *mouseTouchAdaptor = 0;
-    if (parser.hasMouseToTouch()) {
-        mouseTouchAdaptor = MouseTouchAdaptor::instance();
-    }
-
-    QUrl source(::qmlDirectory() + "/OrientedShell.qml");
-    prependImportPaths(view->engine(), ::overrideImportPaths());
-    if (!isMirServer) {
-        prependImportPaths(view->engine(), ::nonMirImportPaths());
-    }
-    appendImportPaths(view->engine(), ::fallbackImportPaths());
-
-    CachingNetworkManagerFactory *managerFactory = new CachingNetworkManagerFactory();
-    view->engine()->setNetworkAccessManagerFactory(managerFactory);
-
-    view->setSource(source);
-    QObject::connect(view->engine(), &QQmlEngine::quit, application, &QGuiApplication::quit);
-
-    if (isMirServer || parser.hasFullscreen()) {
-        view->showFullScreen();
-    } else {
-        view->show();
-    }
+    ShellApplication *application = new ShellApplication(argc, (char**)argv, isMirServer);
 
     int result = application->exec();
 
-    delete view;
-    delete mouseTouchAdaptor;
+    application->destroyResources();
+
     delete application;
 
     return result;

=== modified file 'tests/autopilot/unity8/fixture_setup.py'
--- tests/autopilot/unity8/fixture_setup.py	2015-09-21 12:50:10 +0000
+++ tests/autopilot/unity8/fixture_setup.py	2015-10-26 12:04:03 +0000
@@ -133,7 +133,7 @@
         args = [binary_arg] + env_args
         self.unity_proxy = process_helpers.restart_unity_with_testability(
             *args)
-        self.main_win = self.unity_proxy.select_single(shell.QQuickView)
+        self.main_win = self.unity_proxy.select_single(shell.ShellView)
 
     def _create_sensors(self):
         # Wait for unity to start running.

=== modified file 'tests/autopilot/unity8/greeter/tests/__init__.py'
--- tests/autopilot/unity8/greeter/tests/__init__.py	2015-04-29 19:21:18 +0000
+++ tests/autopilot/unity8/greeter/tests/__init__.py	2015-10-26 12:04:03 +0000
@@ -24,5 +24,5 @@
 class GreeterTestCase(UnityTestCase):
     def get_shell(self, unity_proxy):
         main_window = (
-            unity_proxy.select_single(shell.QQuickView))
+            unity_proxy.select_single(shell.ShellView))
         return main_window.select_single('Shell')

=== modified file 'tests/autopilot/unity8/launcher.py'
--- tests/autopilot/unity8/launcher.py	2015-04-29 19:21:18 +0000
+++ tests/autopilot/unity8/launcher.py	2015-10-26 12:04:03 +0000
@@ -42,7 +42,7 @@
             logger.debug('The launcher is already opened.')
 
     def _swipe_to_show_launcher(self):
-        view = self.get_root_instance().select_single('QQuickView')
+        view = self.get_root_instance().select_single('ShellView')
         start_y = stop_y = view.y + view.height // 2
 
         start_x = view.x + 1

=== modified file 'tests/autopilot/unity8/settings_wizard/__init__.py'
--- tests/autopilot/unity8/settings_wizard/__init__.py	2015-05-21 16:52:05 +0000
+++ tests/autopilot/unity8/settings_wizard/__init__.py	2015-10-26 12:04:03 +0000
@@ -375,12 +375,17 @@
         wizard = get_wizard(self)
         next_page = wizard.get_current_page()
         locationPageEnabled = True
+        reportingPageEnabled = True
         if next_page.objectName == 'locationPage':
             next_page = wizard.get_location_page()
         else:
             locationPageEnabled = False
-            next_page = wizard.get_reporting_page()
-        return locationPageEnabled, next_page
+            if next_page.objectName == 'reportingPage':
+                next_page = wizard.get_reporting_page()
+            else:
+                reportingPageEnabled = False
+                next_page = wizard.get_finished_page()
+        return locationPageEnabled, reportingPageEnabled, next_page
 
     def _get_notification(self, unity):
         logger.info('Waiting longer for notification object')

=== modified file 'tests/autopilot/unity8/settings_wizard/tests/test_settings_wizard.py'
--- tests/autopilot/unity8/settings_wizard/tests/test_settings_wizard.py	2015-05-21 16:37:36 +0000
+++ tests/autopilot/unity8/settings_wizard/tests/test_settings_wizard.py	2015-10-26 12:04:03 +0000
@@ -80,14 +80,19 @@
             password_page = next_page
         wifi_connect_page = self._test_password_page(password_page)
 
-        locationPageEnabled, next_page = self._test_wifi_connect_page(
-            wifi_connect_page)
+        reporting_page = None
+        locationPageEnabled, reportingPageEnabled, next_page = self._test_wifi_connect_page(wifi_connect_page)
         if locationPageEnabled:
             location_page = next_page
-            reporting_page = self._test_location_page(location_page)
+            if reportingPageEnabled:
+                reporting_page = self._test_location_page(location_page)
+            else:
+                finish_page = next_page
+
+        if reporting_page is not None:
+            finish_page = self._test_reporting_page(reporting_page)
         else:
-            reporting_page = next_page
-        finish_page = self._test_reporting_page(reporting_page)
+            finish_page = next_page
 
         finish_page.finish()
         self.assertFalse(

=== modified file 'tests/autopilot/unity8/shell/__init__.py'
--- tests/autopilot/unity8/shell/__init__.py	2015-06-22 15:47:34 +0000
+++ tests/autopilot/unity8/shell/__init__.py	2015-10-26 12:04:03 +0000
@@ -93,7 +93,7 @@
     return _urgency_enums.get(urgency.upper())
 
 
-class QQuickView(ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
+class ShellView(ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
     """An helper class that makes it easy to interact with the shell"""
 
     def get_greeter(self):

=== modified file 'tests/autopilot/unity8/shell/tests/__init__.py'
--- tests/autopilot/unity8/shell/tests/__init__.py	2015-09-21 12:50:10 +0000
+++ tests/autopilot/unity8/shell/tests/__init__.py	2015-10-26 12:04:03 +0000
@@ -297,7 +297,7 @@
 
     @property
     def main_window(self):
-        return self._proxy.select_single(shell.QQuickView)
+        return self._proxy.select_single(shell.ShellView)
 
 
 class DashBaseTestCase(AutopilotTestCase):

=== modified file 'tests/mocks/CMakeLists.txt'
--- tests/mocks/CMakeLists.txt	2015-08-06 22:45:56 +0000
+++ tests/mocks/CMakeLists.txt	2015-10-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +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-26 12:04:03 +0000
@@ -0,0 +1,2 @@
+module Cursor
+Cursor 1.0 Cursor.qml

=== modified file 'tests/mocks/Unity/Launcher/MockQuickListModel.cpp'
--- tests/mocks/Unity/Launcher/MockQuickListModel.cpp	2013-08-19 15:10:58 +0000
+++ tests/mocks/Unity/Launcher/MockQuickListModel.cpp	2015-10-26 12:04:03 +0000
@@ -32,7 +32,7 @@
     switch (role)
     {
     case RoleLabel:
-        return QLatin1String("test menu entry ") + QString::number(index.row());
+        return QString(QLatin1String("test menu entry ") + QString::number(index.row()));
     case RoleIcon:
         return QLatin1String("copy.png");
     case RoleClickable:

=== modified file 'tests/mocks/Unity/fake_resultsmodel.cpp'
--- tests/mocks/Unity/fake_resultsmodel.cpp	2015-09-22 10:44:21 +0000
+++ tests/mocks/Unity/fake_resultsmodel.cpp	2015-10-26 12:04:03 +0000
@@ -78,7 +78,7 @@
         case RoleTitle:
             return QString("Title.%1.%2").arg(m_categoryId).arg(index.row());
         case RoleArt:
-            return qmlDirectory() + "/graphics/applicationIcons/dash.png";
+            return QString(qmlDirectory() + "/graphics/applicationIcons/dash.png");
         case RoleSubtitle:
             return QString("Subtitle.%1.%2").arg(m_categoryId).arg(index.row());
         case RoleMascot:

=== modified file 'tests/mocks/Unity/fake_scopesoverview.cpp'
--- tests/mocks/Unity/fake_scopesoverview.cpp	2015-09-22 10:44:21 +0000
+++ tests/mocks/Unity/fake_scopesoverview.cpp	2015-10-26 12:04:03 +0000
@@ -308,7 +308,7 @@
         case RoleSubtitle:
             return scope && scope->name() == "Videos this is long ab cd ef gh ij kl" ? "tube, movies, cinema, pictures, art, moving images, magic in a box" : QString();
         case RoleArt:
-            return qmlDirectory() + "/graphics/applicationIcons/dash.png";
+            return QString(qmlDirectory() + "/graphics/applicationIcons/dash.png");
         case RoleMascot:
         case RoleEmblem:
         case RoleSummary:

=== modified file 'tests/mocks/Utils/CMakeLists.txt'
--- tests/mocks/Utils/CMakeLists.txt	2015-09-17 12:25:29 +0000
+++ tests/mocks/Utils/CMakeLists.txt	2015-10-26 12:04:03 +0000
@@ -13,8 +13,6 @@
     ${CMAKE_SOURCE_DIR}/plugins/Utils/activefocuslogger.cpp
     ${CMAKE_SOURCE_DIR}/plugins/Utils/qlimitproxymodelqml.cpp
     ${CMAKE_SOURCE_DIR}/plugins/Utils/unitysortfilterproxymodelqml.cpp
-    ${CMAKE_SOURCE_DIR}/plugins/Utils/relativetimeformatter.cpp
-    ${CMAKE_SOURCE_DIR}/plugins/Utils/timeformatter.cpp
     ${CMAKE_SOURCE_DIR}/plugins/Utils/unitymenumodelpaths.cpp
     ${CMAKE_SOURCE_DIR}/plugins/Utils/windowkeysfilter.cpp
     ${CMAKE_SOURCE_DIR}/plugins/Utils/windowscreenshotprovider.cpp

=== modified file 'tests/mocks/Utils/Utils.qmltypes'
--- tests/mocks/Utils/Utils.qmltypes	2015-03-04 13:04:58 +0000
+++ tests/mocks/Utils/Utils.qmltypes	2015-10-26 12:04:03 +0000
@@ -4,10 +4,19 @@
 // It is used for QML tooling purposes only.
 //
 // This file was auto-generated by:
-// 'qmlplugindump -notrelocatable Utils 0.1 plugins'
+// 'qmlplugindump -notrelocatable Utils 0.1 tests/mocks'
 
 Module {
     Component {
+        name: "Constants"
+        prototype: "QObject"
+        exports: ["Utils/Constants 0.1"]
+        isCreatable: false
+        isSingleton: true
+        exportMetaObjectRevisions: [0]
+        Property { name: "indicatorValueTimeout"; type: "int"; isReadonly: true }
+    }
+    Component {
         name: "EasingCurve"
         prototype: "QObject"
         exports: ["Utils/EasingCurve 0.1"]
@@ -18,6 +27,22 @@
         Property { name: "value"; type: "double"; isReadonly: true }
     }
     Component {
+        name: "InputWatcher"
+        prototype: "QObject"
+        exports: ["Utils/InputWatcher 0.1"]
+        exportMetaObjectRevisions: [0]
+        Property { name: "target"; type: "QObject"; isPointer: true }
+        Property { name: "targetPressed"; type: "bool"; isReadonly: true }
+        Signal {
+            name: "targetChanged"
+            Parameter { name: "value"; type: "QObject"; isPointer: true }
+        }
+        Signal {
+            name: "targetPressedChanged"
+            Parameter { name: "value"; type: "bool" }
+        }
+    }
+    Component {
         name: "QAbstractProxyModel"
         prototype: "QAbstractItemModel"
         Property { name: "sourceModel"; type: "QAbstractItemModel"; isPointer: true }
@@ -60,33 +85,6 @@
         Method { name: "invalidate" }
     }
     Component {
-        name: "RelativeTimeFormatter"
-        prototype: "TimeFormatter"
-        exports: ["Utils/RelativeTimeFormatter 0.1"]
-        exportMetaObjectRevisions: [0]
-    }
-    Component {
-        name: "TimeFormatter"
-        prototype: "QObject"
-        exports: ["Utils/GDateTimeFormatter 0.1", "Utils/TimeFormatter 0.1"]
-        exportMetaObjectRevisions: [0, 0]
-        Property { name: "format"; type: "string" }
-        Property { name: "timeString"; type: "string"; isReadonly: true }
-        Property { name: "time"; type: "qlonglong" }
-        Signal {
-            name: "formatChanged"
-            Parameter { name: "format"; type: "string" }
-        }
-        Signal {
-            name: "timeStringChanged"
-            Parameter { name: "timeString"; type: "string" }
-        }
-        Signal {
-            name: "timeChanged"
-            Parameter { name: "time"; type: "qlonglong" }
-        }
-    }
-    Component {
         name: "UnityMenuModelPaths"
         prototype: "QObject"
         exports: ["Utils/UnityMenuModelPaths 0.1"]
@@ -160,6 +158,11 @@
         isCreatable: false
         isSingleton: true
         exportMetaObjectRevisions: [0]
+        Property { name: "geometry"; type: "QVariantMap" }
+        Signal {
+            name: "geometryChanged"
+            Parameter { name: "geometry"; type: "QVariantMap" }
+        }
         Method {
             name: "saveGeometry"
             Parameter { name: "windowId"; type: "string" }

=== modified file 'tests/mocks/Utils/plugin.cpp'
--- tests/mocks/Utils/plugin.cpp	2015-09-17 12:25:29 +0000
+++ tests/mocks/Utils/plugin.cpp	2015-10-26 12:04:03 +0000
@@ -23,14 +23,6 @@
 
 // local
 #include "plugin.h"
-#include "inputwatcher.h"
-#include "qlimitproxymodelqml.h"
-#include "unitysortfilterproxymodelqml.h"
-#include "relativetimeformatter.h"
-#include "timeformatter.h"
-#include "unitymenumodelpaths.h"
-#include "windowkeysfilter.h"
-#include "easingcurve.h"
 #include "windowstatestorage.h"
 #include "constants.h"
 
@@ -39,8 +31,6 @@
 #include <inputwatcher.h>
 #include <qlimitproxymodelqml.h>
 #include <unitysortfilterproxymodelqml.h>
-#include <relativetimeformatter.h>
-#include <timeformatter.h>
 #include <unitymenumodelpaths.h>
 #include <windowkeysfilter.h>
 #include <windowscreenshotprovider.h>
@@ -67,11 +57,8 @@
     qmlRegisterType<QLimitProxyModelQML>(uri, 0, 1, "LimitProxyModel");
     qmlRegisterType<UnitySortFilterProxyModelQML>(uri, 0, 1, "UnitySortFilterProxyModel");
     qmlRegisterType<UnityMenuModelPaths>(uri, 0, 1, "UnityMenuModelPaths");
-    qmlRegisterType<TimeFormatter>(uri, 0, 1, "TimeFormatter");
     qmlRegisterType<WindowKeysFilter>(uri, 0, 1, "WindowKeysFilter");
-    qmlRegisterType<GDateTimeFormatter>(uri, 0, 1, "GDateTimeFormatter");
     qmlRegisterType<EasingCurve>(uri, 0, 1, "EasingCurve");
-    qmlRegisterType<RelativeTimeFormatter>(uri, 0, 1, "RelativeTimeFormatter");
     qmlRegisterSingletonType<WindowStateStorage>(uri, 0, 1, "WindowStateStorage", createWindowStateStorage);
     qmlRegisterType<InputWatcher>(uri, 0, 1, "InputWatcher");
     qmlRegisterSingletonType<Constants>(uri, 0, 1, "Constants", createConstants);

=== modified file 'tests/plugins/ScreenGrabber/ScreenGrabberTest.cpp'
--- tests/plugins/ScreenGrabber/ScreenGrabberTest.cpp	2015-07-20 15:06:46 +0000
+++ tests/plugins/ScreenGrabber/ScreenGrabberTest.cpp	2015-10-26 12:04:03 +0000
@@ -55,6 +55,17 @@
         QVERIFY(!args.first().toString().isEmpty());
     }
 
+    void testRotatedScreenshot()
+    {
+        QSignalSpy grabberSpy(m_grabber, &ScreenGrabber::screenshotSaved);
+        m_grabber->captureAndSave(90); // rotate by 90°
+        const QVariantList args = grabberSpy.takeFirst();
+        const QString filename = args.first().toString();
+        QVERIFY(!filename.isEmpty());
+        QImage img(filename);
+        QVERIFY(img.height() > img.width()); // verify that the image got rotated by 90° (height > width)
+    }
+
 private:
     QQuickView *m_view;
     ScreenGrabber *m_grabber = nullptr;

=== modified file 'tests/plugins/ScreenGrabber/grabber.qml'
--- tests/plugins/ScreenGrabber/grabber.qml	2015-07-17 19:59:31 +0000
+++ tests/plugins/ScreenGrabber/grabber.qml	2015-10-26 12:04:03 +0000
@@ -20,7 +20,7 @@
 Rectangle {
     property var grabber: screenGrabber
 
-    width: 100
+    width: 101 // width intentionally bigger than height to test rotation
     height: 100
     color: "green"
 

=== modified file 'tests/plugins/Unity/Indicators/UnityMenuModelStackTest.cpp'
--- tests/plugins/Unity/Indicators/UnityMenuModelStackTest.cpp	2015-08-19 13:56:21 +0000
+++ tests/plugins/Unity/Indicators/UnityMenuModelStackTest.cpp	2015-10-26 12:04:03 +0000
@@ -43,6 +43,8 @@
     {
         delete m_model;
         m_model = nullptr;
+        // send deleteLaters to avoid leaks.
+        QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
     }
 
     void testHeadOnSetHead()
@@ -146,19 +148,10 @@
 
         m_model->removeRow(removeIndex);
 
-        waitFor([&stack, resultCount]() { return stack.count() == resultCount; }, 1000);
         QCOMPARE(stack.count(), resultCount);
     }
 
 private:
-    bool waitFor(std::function<bool()> functor, int ms) {
-