Merge lp:~unity-team/qtmir/silo0 into lp:qtmir

[Gerry Boland]

DO NOT MERGE

[lp:~unity-team/qtmir/silo0]

346. By Andreas Pokorny on 2015-07-22

Release in step with Mir 0.14.0
Approved by: Gerry Boland

347. By CI Train Bot Account on 2015-07-22

Releasing 0.4.5+15.10.20150722-0ubuntu1

348. By Gerry Boland on 2015-07-28

Remove explicit gcc4.9 dependency Fixes: #1452338
Approved by: PS Jenkins bot, Daniel d'Andrada

349. By CI Train Bot Account on 2015-07-28

Releasing 0.4.5+15.10.20150728-0ubuntu1

350. By Daniel d'Andrada <dandrader@panzer> on 2015-08-04

Remove focus-based app lifecycle. Let shell control it.

API changes:
- ApplicationManager: removed suspended and forceDashActive
- Added Application.requestedState

Also refactored and clearly defined Application and Session states and state transitions.
- Let Application define its own state based on events provided by ApplicationManager. Previously that responsibility was split between those classes.
- Session now defines its own state based on events and requests fed by Application, SessionManager and SurfaceManager.
Approved by: Gerry Boland

351. By Gerry Boland on 2015-08-04

We depend on Qt 5.4, remove compatibility code for older versions
Approved by: PS Jenkins bot, Daniel d'Andrada

352. By Lukáš Tinkl on 2015-08-04

Extend the key table to cover full xkb range of keycodes.

Fixes many missing symbols, mainly various multimedia keys.
Also fix missing mapping to back/forward extra mouse buttons.
Approved by: Gerry Boland, Daniel d'Andrada

353. By Gerry Boland on 2015-08-04

CMake should require mir 0.14
Approved by: Daniel d'Andrada

354. By Gerry Boland on 2015-08-04

No change rebuild using GCC 5.
Approved by: Gerry Boland

355. By Alan Griffiths on 2015-08-04

Start restructuring code to use the Mir WindowManager interface for window management. (Instead of completely replacing the Shell.)
Approved by: Gerry Boland, PS Jenkins bot

356. By Daniel van Vugt on 2015-08-04

ensure the argv passed to mir is a null terminated list (not a nullptr)
Approved by: Gerry Boland, PS Jenkins bot

357. By Gerry Boland on 2015-08-04

Ubuntu Touch has no shared graphics cache implemented, QPA should not say it does
Approved by: PS Jenkins bot, Daniel d'Andrada

358. By CI Train Bot Account on 2015-08-04

Releasing 0.4.5+15.10.20150804.1-0ubuntu1

359. By Gerry Boland on 2015-08-12

Merge mirSurface branch, fixing conflicts

360. By Gerry Boland on 2015-08-12

Merge mousePointer

361. By Gerry Boland on 2015-08-12

Add changelog entry for last vivid release

362. By Gerry Boland on 2015-08-13

Merge trunk

363. By Gerry Boland on 2015-08-13

Merge multimonitor

364. By Gerry Boland on 2015-08-13

Fix all the namespace issues

365. By Gerry Boland on 2015-08-13

Oops, infinite loop due to merge error

366. By Gerry Boland on 2015-08-14

Fix up mouse pointer

367. By Gerry Boland on 2015-08-14

Add hack to resize surface to suit all displaus

368. By Gerry Boland on 2015-08-14

Workaround a crash fix

369. By Daniel d'Andrada on 2015-08-27

QtEventFeeder: log the pointer events it gets from Mir

Unmerged revisions

369. By Daniel d'Andrada on 2015-08-27

QtEventFeeder: log the pointer events it gets from Mir

368. By Gerry Boland on 2015-08-14

Workaround a crash fix

367. By Gerry Boland on 2015-08-14

Add hack to resize surface to suit all displaus

366. By Gerry Boland on 2015-08-14

Fix up mouse pointer

365. By Gerry Boland on 2015-08-13

Oops, infinite loop due to merge error

364. By Gerry Boland on 2015-08-13

Fix all the namespace issues

363. By Gerry Boland on 2015-08-13

Merge multimonitor

362. By Gerry Boland on 2015-08-13

Merge trunk

361. By Gerry Boland on 2015-08-12

Add changelog entry for last vivid release

360. By Gerry Boland on 2015-08-12

Merge mousePointer

=== added directory '3rd_party'
=== added file '3rd_party/CMakeLists.txt'
--- 3rd_party/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ 3rd_party/CMakeLists.txt	2015-08-27 14:51:37 +0000
@@ -0,0 +1,1 @@
+add_subdirectory(xcursor)

=== added directory '3rd_party/xcursor'
=== added file '3rd_party/xcursor/CMakeLists.txt'
--- 3rd_party/xcursor/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ 3rd_party/xcursor/CMakeLists.txt	2015-08-27 14:51:37 +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 '3rd_party/xcursor/README'
--- 3rd_party/xcursor/README	1970-01-01 00:00:00 +0000
+++ 3rd_party/xcursor/README	2015-08-27 14:51:37 +0000
@@ -0,0 +1,1 @@
+TODO: This should go away once we start using the cursor feature from Mir instead of drawing the cursor ourselves as an item in the QML scene

=== added file '3rd_party/xcursor/xcursor.c'
--- 3rd_party/xcursor/xcursor.c	1970-01-01 00:00:00 +0000
+++ 3rd_party/xcursor/xcursor.c	2015-08-27 14:51:37 +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 '3rd_party/xcursor/xcursor.h'
--- 3rd_party/xcursor/xcursor.h	1970-01-01 00:00:00 +0000
+++ 3rd_party/xcursor/xcursor.h	2015-08-27 14:51:37 +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

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-08-11 19:25:04 +0000
+++ CMakeLists.txt	2015-08-27 14:51:37 +0000
@@ -74,7 +74,7 @@
 pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
 pkg_check_modules(QTDBUSTEST libqtdbustest-1 REQUIRED)
 pkg_check_modules(QTDBUSMOCK libqtdbusmock-1 REQUIRED)
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=7)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=8)
 
 include_directories(${APPLICATION_API_INCLUDE_DIRS})
 
@@ -157,4 +157,5 @@
 
 
 # add subdirectories to build
+add_subdirectory(3rd_party)
 add_subdirectory(src)

=== modified file 'README'
--- README	2014-12-10 10:33:48 +0000
+++ README	2015-08-27 14:51:37 +0000
@@ -17,18 +17,27 @@
 To avoid building the tests (to speed up the build):
 $ cmake -DNO_TESTS=true
 
-To test, enter the demos directory, run:
+To test the server, enter the demos directory, and run (NB: server should be run as root):
 
+$ sudo su
 $ export QT_QPA_PLATFORM=mirserver
+$ export MIR_SERVER_FILE=/tmp/mir_socket
+$ unset QT_QPA_PLATFORMTHEME
 
 then run the Qt application of your choice (qmlscene best). As example, try
 
 $ qmlscene qml-demo-shell/qml-demo-shell.qml
 
+prepare the environment for running mir clients:
+
+$ sudo chmod a+rw /tmp/mir_socket
+$ export MIR_SOCKET=/tmp/mir_socket
+
 and then try running an application:
 
 $ mir_demo_client_egltriangle --desktop_file_hint=/usr/share/applications/gallery-app.desktop
 or
+$ unset QT_QPA_PLATFORMTHEME
 $ export QT_QPA_PLATFORM=ubuntumirclient
 $ qmlscene qml-demo-client/qml-demo-client.qml --desktop_file_hint=/usr/share/click/preinstalled/com.ubuntu.calendar/0.4.172/calendar-app.desktop
 

=== modified file 'debian/changelog'
--- debian/changelog	2015-08-24 05:10:23 +0000
+++ debian/changelog	2015-08-27 14:51:37 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 qtmir (0.4.5+15.10.20150817-0ubuntu1) wily; urgency=medium
 
   * 
@@ -5,6 +6,16 @@
  -- CI Train Bot <[e-mail]>  Mon, 17 Aug 2015 19:28:26 +0000
 
 qtmir (0.4.5+15.10.20150812.1-0ubuntu1) vivid; urgency=medium
+=======
+qtmir (0.4.6) UNRELEASED; urgency=medium
+
+  * Enable multiple MirSurfaceItems rendering the same MirSurface
+  * Add better MultiMonitor support
+
+ -- Daniel d'Andrada <[e-mail]>  Mon, 27 Jul 2015 13:16:20 -0300
+
+qtmir (0.4.5+15.04.20150812.1-0ubuntu1) vivid; urgency=medium
+>>>>>>> MERGE-SOURCE
 
   [ Daniel van Vugt ]
   * MirSurfaceItem: Remove an unnecessary and potentially infinite loop
@@ -20,7 +31,7 @@
 
 qtmir (0.4.5+15.10.20150804.1-0ubuntu1) vivid; urgency=medium
 
-  * Dual release with wily
+  * Vivid release in step with wily
 
  -- Gerry Boland <[e-mail]>  Tue, 04 Aug 2015 17:21:12 +0000
 

=== modified file 'debian/copyright'
--- debian/copyright	2015-08-11 12:10:03 +0000
+++ debian/copyright	2015-08-27 14:51:37 +0000
@@ -13,6 +13,27 @@
 Copyright: 2013-2014 Canonical Ltd.
 License: LGPL-3
 
+Files: 3rd_party/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.
+
 License: LGPL-3
  This package is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public

=== added file 'demos/qml-demo-shell/ResizeArea.qml'
--- demos/qml-demo-shell/ResizeArea.qml	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/ResizeArea.qml	2015-08-27 14:51:37 +0000
@@ -0,0 +1,119 @@
+import QtQuick 2.4
+import Unity.Application 0.1
+
+MouseArea {
+    id: root
+
+    // to be set from outside
+    property Item target
+    property bool leftBorder: false
+    property bool rightBorder: false
+    property bool topBorder: false
+    property bool bottomBorder: false
+
+    property bool dragging: false
+    property real startX
+    property real startY
+    property real startWidth
+    property real startHeight
+
+    hoverEnabled: true
+
+    property string cursorName: {
+        if (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";
+        }
+    }
+
+    function updateCursorName() {
+        if (containsMouse || pressed) {
+            Mir.cursorName = root.cursorName;
+        } else {
+            Mir.cursorName = "";
+        }
+    }
+
+    onContainsMouseChanged: {
+        updateCursorName();
+    }
+
+    onPressedChanged: {
+        updateCursorName();
+        if (pressed) {
+            var pos = mapToItem(target.parent, mouseX, mouseY);
+            startX = pos.x;
+            startY = pos.y;
+            startWidth = target.width;
+            startHeight = target.height;
+            dragging = true;
+        } else {
+            dragging = false;
+        }
+    }
+
+    onMouseXChanged: {
+        if (!pressed || !dragging) {
+            return;
+        }
+
+        var pos = mapToItem(target.parent, mouseX, mouseY);
+
+        if (leftBorder) {
+            if (startX + startWidth - pos.x > target.minWidth) {
+                target.x = pos.x;
+                target.width = startX + startWidth - target.x;
+                startX = target.x;
+                startWidth = target.width;
+            }
+
+        } else if (rightBorder) {
+            var deltaX = pos.x - startX;
+            if (startWidth + deltaX >= target.minWidth) {
+                target.width = startWidth + deltaX;
+            } else {
+                target.width = target.minWidth;
+            }
+        }
+    }
+
+    onMouseYChanged: {
+        if (!pressed || !dragging) {
+            return;
+        }
+
+        var pos = mapToItem(target.parent, mouseX, mouseY);
+
+        if (topBorder) {
+
+            if (startY + startHeight - pos.y > target.minHeight) {
+                target.y = pos.y;
+                target.height = startY + startHeight - target.y;
+                startY = target.y;
+                startHeight = target.height;
+            }
+
+        } else if (bottomBorder) {
+            var deltaY = pos.y - startY;
+            if (startHeight + deltaY >= target.minHeight) {
+                target.height = startHeight + deltaY;
+            } else {
+                target.height = target.minHeight;
+            }
+        }
+    }
+}
+

=== added file 'demos/qml-demo-shell/TitleBar.qml'
--- demos/qml-demo-shell/TitleBar.qml	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/TitleBar.qml	2015-08-27 14:51:37 +0000
@@ -0,0 +1,72 @@
+import QtQuick 2.4
+import Unity.Application 0.1
+
+Rectangle {
+    id: root
+    color: "brown"
+    height: 25
+
+    property Item target
+    property bool cloned: false
+    property bool closeRequested: false
+    signal cloneRequested()
+
+    MouseArea {
+        anchors.fill: parent
+        property real distanceX
+        property real distanceY
+        property bool dragging
+        onPressedChanged: {
+            if (pressed) {
+                var pos = mapToItem(root.target, mouseX, mouseY);
+                distanceX = pos.x;
+                distanceY = pos.y;
+                dragging = true;
+                Mir.cursorName = "grabbing";
+            } else {
+                dragging = false;
+                Mir.cursorName = "";
+            }
+        }
+        onMouseXChanged: {
+            if (dragging) {
+                var pos = mapToItem(root.target.parent, mouseX, mouseY);
+                root.target.x = pos.x - distanceX;
+                root.target.y = pos.y - distanceY;
+            }
+        }
+    }
+
+    Text {
+        visible: !root.cloned
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        text: "CLONE"
+        MouseArea {
+            anchors.fill: parent
+            onClicked: {
+                root.cloneRequested();
+            }
+        }
+    }
+
+    Text {
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.right: parent.right
+        width: contentWidth
+        text: "X"
+        fontSizeMode: Text.VerticalFit
+        minimumPixelSize: 10; font.pixelSize: 72
+        font.weight: Font.Bold
+        horizontalAlignment: Text.AlignRight
+        verticalAlignment: Text.AlignVCenter
+        MouseArea {
+            anchors.fill: parent
+            onClicked: {
+                root.closeRequested = true;
+            }
+        }
+    }
+}
+

=== modified file 'demos/qml-demo-shell/Window.qml'
--- demos/qml-demo-shell/Window.qml	2014-05-22 13:47:20 +0000
+++ demos/qml-demo-shell/Window.qml	2015-08-27 14:51:37 +0000
@@ -1,46 +1,173 @@
 import QtQuick 2.0
+import Unity.Application 0.1
 
 Rectangle {
     id: root
     color: "red"
-    readonly property int margin: 5
-
-    function setSurface(surface) {
-        surface.parent = root //windowContainer;
-        root.width = surface.width //+ 2*margin;
-        root.height = surface.height //+ margin + title.height;
-
-        surface.anchors.fill = root //windowContainer;
-//        surface.opacity = 0.99;
-
-//        title.text = surface.name;
-    }
-
-//    Text {
-//        id: title
-//        anchors {
-//            left: parent.left
-//            right: parent.right
-//            top: parent.top
-//            leftMargin: margin
-//            rightMargin: margin
-//        }
-//        font.pixelSize: 40
-//    }
-
-    Rectangle {
-        id: windowContainer
-        anchors {
-            left: parent.left
-            right: parent.right
-            top: parent.top
-//            top: title.bottom
-            bottom: parent.bottom
-            leftMargin: margin
-            rightMargin: margin
-            bottomMargin: margin
-        }
-        color: "pink"
-        opacity: 0.2
+
+    property alias surface: surfaceItem.surface
+    property bool touchMode: false
+
+    width: surfaceItem.implicitWidth + 2*borderThickness
+    height: surfaceItem.implicitHeight + 2*borderThickness + titleBar.height
+
+    signal cloneRequested()
+    property bool cloned: false
+
+    onTouchModeChanged: {
+        if (touchMode) {
+            x -= borderThicknessTouch - borderThicknessMouse;
+            width += 2*(borderThicknessTouch - borderThicknessMouse);
+            y -= borderThicknessTouch - borderThicknessMouse;
+            height += 2*(borderThicknessTouch - borderThicknessMouse);
+        } else {
+            x += borderThicknessTouch - borderThicknessMouse;
+            width -= 2*(borderThicknessTouch - borderThicknessMouse);
+            y += borderThicknessTouch - borderThicknessMouse;
+            height -= 2*(borderThicknessTouch - borderThicknessMouse);
+        }
+    }
+
+    readonly property real minWidth: 100
+    readonly property real minHeight: 100
+
+    property real borderThickness: touchMode ? borderThicknessTouch : borderThicknessMouse
+    readonly property real borderThicknessMouse: 10
+    readonly property real borderThicknessTouch: 40
+
+    states: [
+        State {
+            name: "closed"
+            when: (surface && !surface.live) || titleBar.closeRequested
+        }
+    ]
+    transitions: [
+        Transition {
+            from: ""; to: "closed"
+            SequentialAnimation {
+                PropertyAnimation {
+                    target: root
+                    property: "scale"
+                    easing.type: Easing.InBack
+                    duration: 400
+                    from: 1.0
+                    to: 0.0
+                }
+                ScriptAction { script: { root.destroy(); } }
+            }
+        }
+    ]
+
+    ResizeArea {
+        anchors.top: root.top
+        anchors.bottom: root.bottom
+        anchors.margins: root.borderThickness
+        width: root.borderThickness
+
+        leftBorder: true
+        target: root
+    }
+    ResizeArea {
+        anchors.right: root.right
+        anchors.top: root.top
+        anchors.topMargin: root.borderThickness
+        anchors.bottom: root.bottom
+        anchors.bottomMargin: root.borderThickness
+        width: root.borderThickness
+
+        rightBorder: true
+        target: root
+    }
+    ResizeArea {
+        anchors.left: root.left
+        anchors.leftMargin: root.borderThickness
+        anchors.right: root.right
+        anchors.rightMargin: root.borderThickness
+        anchors.top: root.top
+        height: root.borderThickness
+
+        topBorder: true
+        target: root
+    }
+    ResizeArea {
+        anchors.left: root.left
+        anchors.leftMargin: root.borderThickness
+        anchors.right: root.right
+        anchors.rightMargin: root.borderThickness
+        anchors.bottom: root.bottom
+        height: root.borderThickness
+
+        bottomBorder: true
+        target: root
+    }
+    ResizeArea {
+        anchors.left: root.left
+        anchors.top: root.top
+        width: root.borderThickness
+        height: root.borderThickness
+
+        topBorder: true
+        leftBorder: true
+        target: root
+    }
+    ResizeArea {
+        anchors.left: root.left
+        anchors.bottom: root.bottom
+        width: root.borderThickness
+        height: root.borderThickness
+
+        bottomBorder: true
+        leftBorder: true
+        target: root
+    }
+    ResizeArea {
+        anchors.right: root.right
+        anchors.top: root.top
+        width: root.borderThickness
+        height: root.borderThickness
+
+        topBorder: true
+        rightBorder: true
+        target: root
+    }
+    ResizeArea {
+        anchors.right: root.right
+        anchors.bottom: root.bottom
+        width: root.borderThickness
+        height: root.borderThickness
+
+        bottomBorder: true
+        rightBorder: true
+        target: root
+    }
+
+    TitleBar {
+        id: titleBar
+        anchors.left: parent.left
+        anchors.leftMargin: root.borderThickness
+        anchors.right: parent.right
+        anchors.rightMargin: root.borderThickness
+        anchors.top: parent.top
+        anchors.topMargin: root.borderThickness
+
+        target: root
+        cloned: root.cloned
+        onCloneRequested: { root.cloneRequested(); }
+    }
+
+    MirSurfaceItem {
+        id: surfaceItem
+
+        anchors.top: titleBar.bottom
+        anchors.left: parent.left
+        anchors.leftMargin: root.borderThickness
+        anchors.right: parent.right
+        anchors.rightMargin: root.borderThickness
+        anchors.bottom: parent.bottom
+        anchors.bottomMargin: root.borderThickness
+
+        consumesInput: !root.cloned
+        surfaceWidth: root.cloned ? -1 : width
+        surfaceHeight: root.cloned ? -1 : height
     }
 }

=== added file 'demos/qml-demo-shell/WindowBufferSized.qml'
--- demos/qml-demo-shell/WindowBufferSized.qml	1970-01-01 00:00:00 +0000
+++ demos/qml-demo-shell/WindowBufferSized.qml	2015-08-27 14:51:37 +0000
@@ -0,0 +1,178 @@
+import QtQuick 2.0
+import Unity.Application 0.1
+
+Rectangle {
+    id: root
+    color: "red"
+
+    property alias surface: surfaceItem.surface
+    property bool touchMode: false
+
+    width: surfaceItem.width + (borderThickness*2)
+    height: surfaceItem.height + titleBar.height + (borderThickness*2)
+
+    signal cloneRequested()
+
+    onTouchModeChanged: {
+        if (touchMode) {
+            x -= borderThicknessTouch - borderThicknessMouse;
+            width += 2*(borderThicknessTouch - borderThicknessMouse);
+            y -= borderThicknessTouch - borderThicknessMouse;
+            height += 2*(borderThicknessTouch - borderThicknessMouse);
+        } else {
+            x += borderThicknessTouch - borderThicknessMouse;
+            width -= 2*(borderThicknessTouch - borderThicknessMouse);
+            y += borderThicknessTouch - borderThicknessMouse;
+            height -= 2*(borderThicknessTouch - borderThicknessMouse);
+        }
+    }
+
+    readonly property real minWidth: 100
+    readonly property real minHeight: 100
+
+    property real borderThickness: touchMode ? borderThicknessTouch : borderThicknessMouse
+    readonly property real borderThicknessMouse: 10
+    readonly property real borderThicknessTouch: 40
+
+    states: [
+        State {
+            name: "closed"
+            when: (surface && !surface.live) || titleBar.closeRequested
+        }
+    ]
+    transitions: [
+        Transition {
+            from: ""; to: "closed"
+            SequentialAnimation {
+                PropertyAnimation {
+                    target: root
+                    property: "scale"
+                    easing.type: Easing.InBack
+                    duration: 400
+                    from: 1.0
+                    to: 0.0
+                }
+                ScriptAction { script: { root.destroy(); } }
+            }
+        }
+    ]
+
+
+    MouseArea {
+        id: resizeArea
+
+        anchors.fill: parent
+
+        property real startX
+        property real startY
+        property real startWidth
+        property real startHeight
+        property bool leftBorder
+        property bool rightBorder
+        property bool topBorder
+        property bool bottomBorder
+        property bool dragging
+        onPressedChanged: {
+            if (pressed) {
+                var pos = mapToItem(root.parent, mouseX, mouseY);
+                startX = pos.x;
+                startY = pos.y;
+                startWidth = surfaceItem.width;
+                startHeight = surfaceItem.height;
+                leftBorder = mouseX > 0 && mouseX < root.borderThickness;
+                rightBorder = mouseX > (root.width - root.borderThickness) && mouseX < root.width;
+                topBorder = mouseY > 0 && mouseY < root.borderThickness;
+                bottomBorder = mouseY > (root.height - root.borderThickness) && mouseY < root.height;
+                dragging = true;
+            } else {
+                dragging = false;
+            }
+        }
+
+        onMouseXChanged: {
+            if (!pressed || !dragging) {
+                return;
+            }
+
+            var pos = mapToItem(root.parent, mouseX, mouseY);
+
+            var deltaX = pos.x - startX;
+            if (leftBorder) {
+                if (startWidth - deltaX >= root.minWidth) {
+                    surfaceItem.surfaceWidth = startWidth - deltaX;
+                } else {
+                    surfaceItem.surfaceWidth = root.minWidth;
+                }
+            } else if (rightBorder) {
+                if (startWidth + deltaX >= root.minWidth) {
+                    surfaceItem.surfaceWidth = startWidth + deltaX;
+                } else {
+                    surfaceItem.surfaceWidth = root.minWidth;
+                }
+            }
+        }
+
+        onMouseYChanged: {
+            if (!pressed || !dragging) {
+                return;
+            }
+
+            var pos = mapToItem(root.parent, mouseX, mouseY);
+
+            var deltaY = pos.y - startY;
+            if (topBorder) {
+                if (startHeight - deltaY >= root.minHeight) {
+                    surfaceItem.surfaceHeight = startHeight - deltaY;
+                } else {
+                    surfaceItem.surfaceHeight = root.minHeight;
+                }
+            } else if (bottomBorder) {
+                if (startHeight + deltaY >= root.minHeight) {
+                    surfaceItem.surfaceHeight = startHeight + deltaY;
+                } else {
+                    surfaceItem.surfaceHeight = root.minHeight;
+                }
+            }
+        }
+    }
+
+    TitleBar {
+        id: titleBar
+        anchors.left: parent.left
+        anchors.leftMargin: root.borderThickness
+        anchors.right: parent.right
+        anchors.rightMargin: root.borderThickness
+        anchors.top: parent.top
+        anchors.topMargin: root.borderThickness
+
+        target: root
+        cloned: root.cloned
+        onCloneRequested: { root.cloneRequested(); }
+    }
+
+    MirSurfaceItem {
+        id: surfaceItem
+
+        width: surface ? surface.size.width : 50
+        height: surface ? surface.size.height : 50
+
+        onWidthChanged: {
+            if (resizeArea.dragging && resizeArea.leftBorder) {
+                root.x = resizeArea.startX + resizeArea.startWidth - surfaceItem.width;
+            }
+        }
+
+        onHeightChanged: {
+            if (resizeArea.dragging && resizeArea.topBorder) {
+                root.y = resizeArea.startY + resizeArea.startHeight - surfaceItem.height;
+            }
+        }
+
+        anchors.top: titleBar.bottom
+        anchors.left: parent.left
+        anchors.leftMargin: root.borderThickness
+
+        consumesInput: true
+    }
+}
+

=== modified file 'demos/qml-demo-shell/qml-demo-shell.qml'
--- demos/qml-demo-shell/qml-demo-shell.qml	2015-05-01 13:31:30 +0000
+++ demos/qml-demo-shell/qml-demo-shell.qml	2015-08-27 14:51:37 +0000
@@ -1,5 +1,7 @@
-import QtQuick 2.0
+import QtQuick 2.4
+import QtQuick.Window 2.2
 import Unity.Application 0.1
+import Unity.Screens 0.1
 
 Rectangle {
     id: root
@@ -12,11 +14,26 @@
         console.log("\"Volume Down\" pressed");
     }
 
+    property bool resizeModeStretch: true
+
     gradient: Gradient {
         GradientStop { position: 0.0; color: "lightsteelblue" }
         GradientStop { position: 1.0; color: "pink" }
     }
 
+    property bool thumbFriendlyBorders: false
+
+    MultiPointTouchArea {
+        anchors.fill: parent
+        mouseEnabled: false
+        onPressed: {
+            root.thumbFriendlyBorders = true;
+        }
+        onReleased: {
+            root.thumbFriendlyBorders = false;
+        }
+    }
+
     Image {
         id: unityLogo
         source: "UnityLogo.png"
@@ -35,55 +52,8 @@
             loops: Animation.Infinite
         }
 
-    }
-
-    MultiPointTouchArea {
-        anchors.fill: parent
-        minimumTouchPoints: 1
-        maximumTouchPoints: 1
-        touchPoints: [
-            TouchPoint { id: point }
-        ]
-        property Item window: null
-        property real previousX: 0
-        property real previousY: 0
-
-        onPressed: {
-            // if at least 2 touch points are within a Window, select that Window
-            window = windowContainer.childAt(point.x, point.y);
-
-            // save mouse position
-            previousX = point.x
-            previousY = point.y
-        }
-
-        onUpdated: {
-            if (!window) return;
-
-            var offset = point.x - previousX
-            if (window.width > 100) {
-                window.width += offset
-            }
-            previousX = point.x
-
-            offset = point.y - previousY
-            if (window.height > 100) {
-                window.height += offset
-            }
-            previousY = point.y
-        }
-
-        onReleased: {
-            window = null
-            print(window.width, window.height)
-        }
-
         MultiPointTouchArea {
-            id: touchArea
-            x: unityLogo.x
-            y: unityLogo.y
-            width: unityLogo.width
-            height: unityLogo.height
+            anchors.fill: parent
             minimumTouchPoints:1
             maximumTouchPoints:1
             onPressed: {
@@ -96,21 +66,15 @@
                 }
             }
         }
-
-        Item {
-            id: windowContainer
-            anchors.fill: parent
-        }
-    }
-
-    Rectangle {
-        width: 30; height: 30
-        color: "green"
-        x: point.x
-        y: point.y
-    }
-
-    Rectangle {
+    }
+
+    Item {
+        id: windowContainer
+        anchors.fill: root
+    }
+
+    Rectangle {
+        id: quitButton
         width: 60
         height: 40
         color: "red"
@@ -125,24 +89,90 @@
         }
     }
 
+    Rectangle {
+        id: resizeButton
+        width: 90
+        height: 40
+        color: "blue"
+        anchors { right: quitButton.left; bottom: parent.bottom }
+        Text {
+            anchors.centerIn: parent
+            text: root.resizeModeStretch ? "Stretch" : "Wait Resize"
+            color: "white"
+        }
+        MouseArea {
+            anchors.fill: parent
+            onClicked: { root.resizeModeStretch = !root.resizeModeStretch; }
+        }
+    }
+
+    Rectangle {
+        width: 40
+        height: 40
+        color: "green"
+        anchors { right: resizeButton.left; bottom: parent.bottom }
+        Text {
+            anchors.centerIn: parent
+            text: "⟳"
+            color: "white"
+            font.pixelSize: 35
+        }
+        MouseArea {
+            anchors.fill: parent
+            onClicked: { root.rotation += 180; }
+        }
+    }
+
+    Component {
+        id: windowStretchComponent
+        Window {
+            x: 50
+            y: 50
+            //width: 200
+            //height: 200
+            touchMode: root.thumbFriendlyBorders
+
+            onCloneRequested: {
+                var window = windowStretchComponent.createObject(windowContainer);
+                window.cloned = true;
+                window.surface = surface;
+            }
+        }
+    }
+
+    Component {
+        id: windowWaitResizeComponent
+        WindowBufferSized {
+            x: 50
+            y: 50
+            touchMode: root.thumbFriendlyBorders
+
+            onCloneRequested: {
+                var window = windowStretchComponent.createObject(windowContainer);
+                window.cloned = true;
+                window.surface = surface;
+            }
+        }
+    }
+
+    property var windowComponent: resizeModeStretch ? windowStretchComponent : windowWaitResizeComponent
+
     Connections {
         target: SurfaceManager
         onSurfaceCreated: {
             print("new surface", surface.name)
 
-            var windowComponent = Qt.createComponent("Window.qml");
             var window = windowComponent.createObject(windowContainer);
-            window.setSurface(surface);
+            if (!window) {
+                console.warn(windowComponent.errorString());
+                return;
+            }
+
+            window.surface = surface;
 
             openAnimation.target = window;
             openAnimation.start();
         }
-
-        onSurfaceDestroyed: {
-            print("surface destroying", surface.name)
-            closeAnimation.surface = surface;
-            closeAnimation.start();
-        }
     }
 
     NumberAnimation {
@@ -152,6 +182,8 @@
         duration: 1200; easing.type: Easing.InOutQuad
     }
 
+    Cursor {}
+
     SequentialAnimation {
         id: closeAnimation
         property variant surface: null
@@ -169,4 +201,72 @@
             }
         }
     }
+
+
+    Component {
+        id: window1
+        Window {
+            color: "lightgreen"
+            visible: true // if not set visible, Window is not created!!
+
+            Image {
+                id: unityLogo1
+                source: "UnityLogo.png"
+                fillMode: Image.PreserveAspectFit
+                anchors.centerIn: parent
+                width: 600
+                height: 600
+
+                RotationAnimation {
+                    id: logoAnimation1
+                    target: unityLogo1
+                    from: 359
+                    to: 0
+                    duration: 7000
+                    easing.type: Easing.Linear
+                    loops: Animation.Infinite
+                }
+                Component.onCompleted: print("new window!!")
+                Component.onDestruction: print("window destroyed!!")
+            }
+
+            Rectangle {
+                width: 50; height: 50
+                color: "blue"
+                x: point1.x
+                y: point1.y
+            }
+
+            MultiPointTouchArea {
+                anchors.fill: parent
+                minimumTouchPoints: 1
+                maximumTouchPoints: 1
+                touchPoints: [
+                    TouchPoint { id: point1 }
+                ]
+                onPressed: {
+                    if (logoAnimation1.paused) {
+                        logoAnimation1.resume();
+                    } else if (logoAnimation1.running) {
+                        logoAnimation1.pause();
+                    } else {
+                        logoAnimation1.start();
+                    }
+                }
+            }
+        }
+    }
+
+    Screens {
+        id: screens
+        property variant secondWindow: null
+        onScreenAdded: {
+            print("Screen added!!")
+            secondWindow = window1.createObject(root)
+        }
+        onScreenRemoved: {
+            print("Screen removed!!!")
+            secondWindow.destroy();
+        }
+    }
 }

=== modified file 'src/common/debughelpers.cpp'
--- src/common/debughelpers.cpp	2015-05-13 09:40:03 +0000
+++ src/common/debughelpers.cpp	2015-08-27 14:51:37 +0000
@@ -208,6 +208,17 @@
     }
 }
 
+QString mirPointerEventToString(MirPointerEvent const* event)
+{
+    QString string = QString("MirPointerEvent(x=%1,y=%2,relative_x=%3,relative_y=%4)")
+        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_x))
+        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_y))
+        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_relative_x))
+        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_relative_y));
+
+    return string;
+}
+
 QString mirTouchEventToString(MirTouchEvent const* event)
 {
     const int pointerCount = mir_touch_event_point_count(event);

=== modified file 'src/common/debughelpers.h'
--- src/common/debughelpers.h	2015-06-24 23:08:44 +0000
+++ src/common/debughelpers.h	2015-08-27 14:51:37 +0000
@@ -36,6 +36,7 @@
 
 const char *applicationStateToStr(int state);
 
+QString mirPointerEventToString(MirPointerEvent const* event);
 QString mirTouchEventToString(MirTouchEvent const* event);
 const char *mirTouchActionToString(MirTouchAction touchAction);
 

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2015-06-15 17:01:28 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2015-08-27 14:51:37 +0000
@@ -8,6 +8,7 @@
     ${UBUNTU_APP_LAUNCH_INCLUDE_DIRS}
     ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
     ${CMAKE_SOURCE_DIR}/src/common
+    ${CMAKE_SOURCE_DIR}/3rd_party/xcursor
     ${GSETTINGS_QT_INCLUDE_DIRS}
 
     ${LTTNG_INCLUDE_DIRS}
@@ -26,6 +27,7 @@
     application.cpp
     ../../../common/abstractdbusservicemonitor.cpp
     ../../../common/debughelpers.cpp
+    cursorimageprovider.cpp
     desktopfilereader.cpp
     plugin.cpp
     applicationscreenshotprovider.cpp
@@ -33,8 +35,12 @@
     taskcontroller.cpp
     mirsurfacemanager.cpp
     ubuntukeyboardinfo.cpp
+    mirsurface.cpp
+    mirsurfaceinterface.h
     mirsurfaceitem.cpp
     mirbuffersgtexture.cpp
+    mirsingleton.cpp
+    mousepointer.cpp
     proc_info.cpp
     session.cpp
     sessionmanager.cpp
@@ -45,8 +51,10 @@
 # We need to run moc on these headers
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h
+    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h
+    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceItemInterface.h
+    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
 # Feed the automoc monster
-    mirsurfaceiteminterface.h
     session_interface.h
     applicationcontroller.h
     settings_interface.h
@@ -77,6 +85,7 @@
     Qt5::Quick
 
     qpa-mirserver
+    xcursorloader-static
 )
 
 # Generate tracepoints.c and .h from tracepoints.tp
@@ -87,4 +96,3 @@
 # install
 add_qml_plugin(Unity.Application 0.1 Unity/Application TARGETS unityapplicationplugin)
 install(FILES com.canonical.qtmir.gschema.xml DESTINATION ${CMAKE_INSTALL_DATADIR}/glib-2.0/schemas)
-

=== added file 'src/modules/Unity/Application/Cursor.qml'
--- src/modules/Unity/Application/Cursor.qml	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/Cursor.qml	2015-08-27 14:51:37 +0000
@@ -0,0 +1,12 @@
+import QtQuick 2.4
+import Unity.Application 0.1
+
+MousePointer {
+    id: mousePointer
+
+    Image {
+        x: -mousePointer.hotspotX
+        y: -mousePointer.hotspotY
+        source: "image://cursor/" + mousePointer.themeName + "/" + mousePointer.cursorName
+    }
+}

=== added file 'src/modules/Unity/Application/cursorimageprovider.cpp'
--- src/modules/Unity/Application/cursorimageprovider.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/cursorimageprovider.cpp	2015-08-27 14:51:37 +0000
@@ -0,0 +1,146 @@
+/*
+ * 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 <QFile>
+
+using namespace qtmir;
+
+CursorImageProvider *CursorImageProvider::m_instance = nullptr;
+
+CursorImage::CursorImage(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;
+        }
+    }
+}
+
+CursorImage::~CursorImage()
+{
+    XcursorImagesDestroy(xcursorImages);
+}
+
+CursorImageProvider::CursorImageProvider()
+    : QQuickImageProvider(QQuickImageProvider::Image)
+{
+    if (m_instance) {
+        qFatal("QPA mirsever: 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") {
+            cursorImage = fetchCursorHelper(themeName, "xterm");
+        } else if (cursorName == "xterm") {
+            cursorImage = fetchCursorHelper(themeName, "ibeam");
+        }
+    }
+
+    // if it all fails, there must be at least a left_ptr
+    if (cursorImage->qimage.isNull()) {
+        cursorImage = fetchCursorHelper(themeName, "left_ptr");
+    }
+
+    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 CursorImage(themeName, cursorName);
+    }
+
+    return themeCursors[cursorName];
+}

=== added file 'src/modules/Unity/Application/cursorimageprovider.h'
--- src/modules/Unity/Application/cursorimageprovider.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/cursorimageprovider.h	2015-08-27 14:51:37 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QTMIR_CURSORIMAGEPROVIDER_H
+#define QTMIR_CURSORIMAGEPROVIDER_H
+
+#include <QQuickImageProvider>
+
+// xcursor static lib
+extern "C"
+{
+#include <xcursor.h>
+}
+
+namespace qtmir
+{
+
+class CursorImage {
+public:
+    CursorImage(const QString &theme, const QString &file);
+    ~CursorImage();
+
+    QImage qimage;
+    QPoint hotspot;
+    XcursorImages *xcursorImages;
+};
+
+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;
+
+    static CursorImageProvider *m_instance;
+};
+
+} // namespace qtmir
+
+
+#endif // QTMIR_CURSORIMAGEPROVIDER_H

=== modified file 'src/modules/Unity/Application/mirbuffersgtexture.cpp'
--- src/modules/Unity/Application/mirbuffersgtexture.cpp	2015-08-11 12:08:32 +0000
+++ src/modules/Unity/Application/mirbuffersgtexture.cpp	2015-08-27 14:51:37 +0000
@@ -22,9 +22,10 @@
 
 namespace mg = mir::geometry;
 
-MirBufferSGTexture::MirBufferSGTexture(std::shared_ptr<mir::graphics::Buffer> buffer)
+MirBufferSGTexture::MirBufferSGTexture()
     : QSGTexture()
-    , m_mirBuffer(buffer)
+    , m_width(0)
+    , m_height(0)
     , m_textureId(0)
 {
     glGenTextures(1, &m_textureId);
@@ -32,10 +33,6 @@
     setFiltering(QSGTexture::Linear);
     setHorizontalWrapMode(QSGTexture::ClampToEdge);
     setVerticalWrapMode(QSGTexture::ClampToEdge);
-
-    mg::Size size = m_mirBuffer->size();
-    m_height = size.height.as_int();
-    m_width = size.width.as_int();
 }
 
 MirBufferSGTexture::~MirBufferSGTexture()
@@ -48,6 +45,8 @@
 void MirBufferSGTexture::freeBuffer()
 {
     m_mirBuffer.reset();
+    m_width = 0;
+    m_height = 0;
 }
 
 void MirBufferSGTexture::setBuffer(std::shared_ptr<mir::graphics::Buffer> buffer)

=== modified file 'src/modules/Unity/Application/mirbuffersgtexture.h'
--- src/modules/Unity/Application/mirbuffersgtexture.h	2015-08-11 12:08:32 +0000
+++ src/modules/Unity/Application/mirbuffersgtexture.h	2015-08-27 14:51:37 +0000
@@ -29,7 +29,7 @@
 {
     Q_OBJECT
 public:
-    MirBufferSGTexture(std::shared_ptr<mir::graphics::Buffer>);
+    MirBufferSGTexture();
     virtual ~MirBufferSGTexture();
 
     void setBuffer(std::shared_ptr<mir::graphics::Buffer> buffer);
@@ -44,8 +44,8 @@
 
 private:
     std::shared_ptr<mir::graphics::Buffer> m_mirBuffer;
+    int m_width;
     int m_height;
-    int m_width;
     GLuint m_textureId;
 };
 

=== added file 'src/modules/Unity/Application/mirsingleton.cpp'
--- src/modules/Unity/Application/mirsingleton.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/mirsingleton.cpp	2015-08-27 14:51:37 +0000
@@ -0,0 +1,33 @@
+#include "mirsingleton.h"
+
+qtmir::Mir *qtmir::Mir::m_instance = nullptr;
+
+qtmir::Mir::Mir()
+{
+}
+
+qtmir::Mir::~Mir()
+{
+    m_instance = nullptr;
+}
+
+qtmir::Mir *qtmir::Mir::instance()
+{
+    if (!m_instance) {
+        m_instance = new qtmir::Mir;
+    }
+    return m_instance;
+}
+
+void qtmir::Mir::setCursorName(const QString &cursorName)
+{
+    if (m_cursorName != cursorName) {
+        m_cursorName = cursorName;
+        Q_EMIT cursorNameChanged(m_cursorName);
+    }
+}
+
+QString qtmir::Mir::cursorName() const
+{
+    return m_cursorName;
+}

=== added file 'src/modules/Unity/Application/mirsingleton.h'
--- src/modules/Unity/Application/mirsingleton.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/mirsingleton.h	2015-08-27 14:51:37 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QTMIR_MIRSINGLETON_H
+#define QTMIR_MIRSINGLETON_H
+
+// unity-api
+#include <unity/shell/application/Mir.h>
+
+namespace qtmir {
+
+class Mir : public ::Mir
+{
+    Q_OBJECT
+public:
+    virtual ~Mir();
+
+    static Mir *instance();
+
+    void setCursorName(const QString &cursorName) override;
+    QString cursorName() const override;
+
+private:
+    Mir();
+
+    QString m_cursorName;
+    static qtmir::Mir *m_instance;
+};
+
+} // namespace qtmir
+
+#endif // QTMIR_MIRSINGLETON_H

=== added file 'src/modules/Unity/Application/mirsurface.cpp'
--- src/modules/Unity/Application/mirsurface.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/mirsurface.cpp	2015-08-27 14:51:37 +0000
@@ -0,0 +1,631 @@
+/*
+ * 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 "mirsurface.h"
+
+// mirserver
+#include <surfaceobserver.h>
+
+// Mir
+#include <mir/geometry/rectangle.h>
+#include <mir/events/event_builders.h>
+#include <mir/shell/shell.h>
+#include <mir_toolkit/event.h>
+
+// mirserver
+#include <logging.h>
+
+using namespace qtmir;
+
+namespace {
+
+// Would be better if QMouseEvent had nativeModifiers
+MirInputEventModifiers
+getMirModifiersFromQt(Qt::KeyboardModifiers mods)
+{
+    MirInputEventModifiers m_mods = mir_input_event_modifier_none;
+    if (mods & Qt::ShiftModifier)
+        m_mods |= mir_input_event_modifier_shift;
+    if (mods & Qt::ControlModifier)
+        m_mods |= mir_input_event_modifier_ctrl;
+    if (mods & Qt::AltModifier)
+        m_mods |= mir_input_event_modifier_alt;
+    if (mods & Qt::MetaModifier)
+        m_mods |= mir_input_event_modifier_meta;
+
+    return m_mods;
+}
+
+mir::EventUPtr makeMirEvent(QMouseEvent *qtEvent, MirPointerAction action)
+{
+    auto timestamp = std::chrono::milliseconds(qtEvent->timestamp());
+    auto modifiers = getMirModifiersFromQt(qtEvent->modifiers());
+
+    MirPointerButtons buttons = 0;
+    if (qtEvent->buttons() & Qt::LeftButton)
+        buttons |= mir_pointer_button_primary;
+    if (qtEvent->buttons() & Qt::RightButton)
+        buttons |= mir_pointer_button_secondary;
+    if (qtEvent->buttons() & Qt::MidButton)
+        buttons |= mir_pointer_button_tertiary;
+
+    return mir::events::make_event(0 /*DeviceID */, timestamp, modifiers, action,
+                                   buttons, qtEvent->x(), qtEvent->y(), 0, 0);
+}
+
+mir::EventUPtr makeMirEvent(QHoverEvent *qtEvent, MirPointerAction action)
+{
+    auto timestamp = std::chrono::milliseconds(qtEvent->timestamp());
+
+    MirPointerButtons buttons = 0;
+
+    return mir::events::make_event(0 /*DeviceID */, timestamp, mir_input_event_modifier_none, action,
+                                   buttons, qtEvent->posF().x(), qtEvent->posF().y(), 0, 0);
+}
+
+mir::EventUPtr makeMirEvent(QKeyEvent *qtEvent)
+{
+    MirKeyboardAction action = mir_keyboard_action_down;
+    switch (qtEvent->type())
+    {
+    case QEvent::KeyPress:
+        action = mir_keyboard_action_down;
+        break;
+    case QEvent::KeyRelease:
+        action = mir_keyboard_action_up;
+        break;
+    default:
+        break;
+    }
+    if (qtEvent->isAutoRepeat())
+        action = mir_keyboard_action_repeat;
+
+    return mir::events::make_event(0 /* DeviceID */, std::chrono::milliseconds(qtEvent->timestamp()),
+                           action, qtEvent->nativeVirtualKey(),
+                           qtEvent->nativeScanCode(),
+                           qtEvent->nativeModifiers());
+}
+
+mir::EventUPtr makeMirEvent(Qt::KeyboardModifiers qmods,
+                            const QList<QTouchEvent::TouchPoint> &qtTouchPoints,
+                            Qt::TouchPointStates /* qtTouchPointStates */,
+                            ulong qtTimestamp)
+{
+    auto modifiers = getMirModifiersFromQt(qmods);
+    auto ev = mir::events::make_event(0, std::chrono::milliseconds(qtTimestamp),
+                                      modifiers);
+
+    for (int i = 0; i < qtTouchPoints.count(); ++i) {
+        auto touchPoint = qtTouchPoints.at(i);
+        auto id = touchPoint.id();
+
+        MirTouchAction action = mir_touch_action_change;
+        if (touchPoint.state() == Qt::TouchPointReleased)
+        {
+            action = mir_touch_action_up;
+        }
+        if (touchPoint.state() == Qt::TouchPointPressed)
+        {
+            action = mir_touch_action_down;
+        }
+
+        MirTouchTooltype tooltype = mir_touch_tooltype_finger;
+        if (touchPoint.flags() & QTouchEvent::TouchPoint::Pen)
+            tooltype = mir_touch_tooltype_stylus;
+
+        mir::events::add_touch(*ev, id, action, tooltype,
+                               touchPoint.pos().x(), touchPoint.pos().y(),
+                               touchPoint.pressure(),
+                               touchPoint.rect().width(),
+                               touchPoint.rect().height(),
+                               0 /* size */);
+    }
+
+    return ev;
+}
+
+} // namespace {
+
+MirSurface::MirSurface(std::shared_ptr<mir::scene::Surface> surface,
+        SessionInterface* session,
+        MirShell *shell,
+        std::shared_ptr<SurfaceObserver> observer)
+    : MirSurfaceInterface()
+    , m_surface(surface)
+    , m_session(session)
+    , m_shell(shell)
+    , m_firstFrameDrawn(false)
+    , m_orientationAngle(Mir::Angle0)
+    , m_textureUpdated(false)
+    , m_currentFrameNumber(0)
+    , m_live(true)
+    , m_viewCount(0)
+{
+    m_surfaceObserver = observer;
+    if (observer) {
+        connect(observer.get(), &SurfaceObserver::framesPosted, this, &MirSurface::onFramesPostedObserved);
+        connect(observer.get(), &SurfaceObserver::attributeChanged, this, &MirSurface::onAttributeChanged);
+        observer->setListener(this);
+    }
+
+    connect(session, &QObject::destroyed, this, &MirSurface::onSessionDestroyed);
+
+    connect(&m_frameDropperTimer, &QTimer::timeout,
+            this, &MirSurface::dropPendingBuffer);
+    // Rationale behind the frame dropper and its interval value:
+    //
+    // We want to give ample room for Qt scene graph to have a chance to fetch and render
+    // the next pending buffer before we take the drastic action of dropping it (so don't set
+    // it anywhere close to our target render interval).
+    //
+    // We also want to guarantee a minimal frames-per-second (fps) frequency for client applications
+    // as they get stuck on swap_buffers() if there's no free buffer to swap to yet (ie, they
+    // are all pending consumption by the compositor, us). But on the other hand, we don't want
+    // that minimal fps to be too high as that would mean this timer would be triggered way too often
+    // for nothing causing unnecessary overhead as actually dropping frames from an app should
+    // in practice rarely happen.
+    m_frameDropperTimer.setInterval(200);
+    m_frameDropperTimer.setSingleShot(false);
+}
+
+MirSurface::~MirSurface()
+{
+    qCDebug(QTMIR_SURFACES).nospace() << "MirSurface::~MirSurface this=" << this << " viewCount=" << m_viewCount;
+
+    Q_ASSERT(m_viewCount == 0);
+
+    if (m_session) {
+        m_session->setSurface(nullptr);
+    }
+
+    QMutexLocker locker(&m_mutex);
+    m_surface->remove_observer(m_surfaceObserver);
+}
+
+void MirSurface::onFramesPostedObserved()
+{
+    if (!m_firstFrameDrawn) {
+        m_firstFrameDrawn = true;
+        Q_EMIT firstFrameDrawn();
+    }
+
+    // restart the frame dropper so that items have enough time to render the next frame.
+    m_frameDropperTimer.start();
+
+    Q_EMIT framesPosted();
+}
+
+void MirSurface::onAttributeChanged(const MirSurfaceAttrib attribute, const int /*value*/)
+{
+    switch (attribute) {
+    case mir_surface_attrib_type:
+        Q_EMIT typeChanged(type());
+        break;
+    case mir_surface_attrib_state:
+        Q_EMIT stateChanged(state());
+        break;
+    default:
+        break;
+    }
+}
+
+SessionInterface* MirSurface::session() const
+{
+    return m_session.data();
+}
+
+Mir::Type MirSurface::type() const
+{
+    switch (m_surface->type()) {
+    case mir_surface_type_normal:
+        return Mir::NormalType;
+
+    case mir_surface_type_utility:
+        return Mir::UtilityType;
+
+    case mir_surface_type_dialog:
+        return Mir::DialogType;
+
+    case mir_surface_type_gloss:
+        return Mir::GlossType;
+
+    case mir_surface_type_freestyle:
+        return Mir::FreeStyleType;
+
+    case mir_surface_type_menu:
+        return Mir::MenuType;
+
+    case mir_surface_type_inputmethod:
+        return Mir::InputMethodType;
+
+    case mir_surface_type_satellite:
+        return Mir::SatelliteType;
+
+    case mir_surface_type_tip:
+        return Mir::TipType;
+
+    default:
+        return Mir::UnknownType;
+    }
+}
+
+void MirSurface::dropPendingBuffer()
+{
+    QMutexLocker locker(&m_mutex);
+
+    const void* const userId = (void*)123;
+
+    const int framesPending = m_surface->buffers_ready_for_compositor(userId);
+    if (framesPending > 0) {
+        for (auto const &renderable : m_surface->generate_renderables(userId)) {
+            // The line below looks like an innocent, effect-less, getter. But as this
+            // method returns a unique_pointer, not holding its reference causes the
+            // buffer to be destroyed/released straight away.
+            renderable->buffer();
+        }
+        qCDebug(QTMIR_SURFACES) << "MirSurface::dropPendingBuffer()"
+            << "surface =" << this
+            << "buffer dropped."
+            << framesPending-1
+            << "left.";
+    }
+}
+
+void MirSurface::stopFrameDropper()
+{
+    qCDebug(QTMIR_SURFACES) << "MirSurface::stopFrameDropper surface = " << this;
+    m_frameDropperTimer.stop();
+}
+
+void MirSurface::startFrameDropper()
+{
+    qCDebug(QTMIR_SURFACES) << "MirSurface::startFrameDropper surface = " << this;
+    if (!m_frameDropperTimer.isActive()) {
+        m_frameDropperTimer.start();
+    }
+}
+
+QSharedPointer<QSGTexture> MirSurface::texture()
+{
+    if (!m_texture) {
+        QSharedPointer<QSGTexture> texture(new MirBufferSGTexture);
+        m_texture = texture.toWeakRef();
+        return texture;
+    } else {
+        return m_texture.toStrongRef();
+    }
+}
+
+void MirSurface::updateTexture()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_textureUpdated) {
+        return;
+    }
+
+    Q_ASSERT(!m_texture.isNull());
+    MirBufferSGTexture *texture = static_cast<MirBufferSGTexture*>(m_texture.data());
+
+    const void* const userId = (void*)123;
+    auto renderables = m_surface->generate_renderables(userId);
+
+    if (m_surface->buffers_ready_for_compositor(userId) > 0 && renderables.size() > 0) {
+        // Avoid holding two buffers for the compositor at the same time. Thus free the current
+        // before acquiring the next
+        texture->freeBuffer();
+        texture->setBuffer(renderables[0]->buffer());
+        ++m_currentFrameNumber;
+
+        if (texture->textureSize() != m_size) {
+            m_size = texture->textureSize();
+            QMetaObject::invokeMethod(this, "emitSizeChanged", Qt::QueuedConnection);
+        }
+    }
+
+    if (m_surface->buffers_ready_for_compositor(userId) > 0) {
+        // restart the frame dropper to give MirSurfaceItems enough time to render the next frame.
+        // queued since the timer lives in a different thread
+        QMetaObject::invokeMethod(&m_frameDropperTimer, "start", Qt::QueuedConnection);
+    }
+
+    m_textureUpdated = true;
+}
+
+void MirSurface::onCompositorSwappedBuffers()
+{
+    m_textureUpdated = false;
+}
+
+bool MirSurface::numBuffersReadyForCompositor()
+{
+    QMutexLocker locker(&m_mutex);
+    const void* const userId = (void*)123;
+    return m_surface->buffers_ready_for_compositor(userId);
+}
+
+void MirSurface::setFocus(bool focus)
+{
+    if (focus) {
+        m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_focus, mir_surface_focused);
+    } else {
+        m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_focus, mir_surface_unfocused);
+    }
+}
+
+void MirSurface::resize(int width, int height)
+{
+    int mirWidth = m_surface->size().width.as_int();
+    int mirHeight = m_surface->size().height.as_int();
+
+    bool mirSizeIsDifferent = width != mirWidth || height != mirHeight;
+
+    if (clientIsRunning() && mirSizeIsDifferent) {
+        mir::geometry::Size newMirSize(width, height);
+        m_surface->resize(newMirSize);
+        qCDebug(QTMIR_SURFACES) << "MirSurface::resize"
+                << "surface =" << this
+                << ", old (" << mirWidth << "," << mirHeight << ")"
+                << ", new (" << width << "," << height << ")";
+    }
+}
+
+QSize MirSurface::size() const
+{
+    return m_size;
+}
+
+Mir::State MirSurface::state() const
+{
+    switch (m_surface->state()) {
+    case mir_surface_state_unknown:
+        return Mir::UnknownState;
+    case mir_surface_state_restored:
+        return Mir::RestoredState;
+    case mir_surface_state_minimized:
+        return Mir::MinimizedState;
+    case mir_surface_state_maximized:
+        return Mir::MaximizedState;
+    case mir_surface_state_vertmaximized:
+        return Mir::VertMaximizedState;
+    case mir_surface_state_fullscreen:
+        return Mir::FullscreenState;
+    case mir_surface_state_horizmaximized:
+        return Mir::HorizMaximizedState;
+    case mir_surface_state_hidden:
+        return Mir::HiddenState;
+    default:
+        return Mir::UnknownState;
+    }
+}
+
+Mir::OrientationAngle MirSurface::orientationAngle() const
+{
+    return m_orientationAngle;
+}
+
+void MirSurface::setOrientationAngle(Mir::OrientationAngle angle)
+{
+    MirOrientation mirOrientation;
+
+    if (angle == m_orientationAngle) {
+        return;
+    }
+
+    m_orientationAngle = angle;
+
+    switch (angle) {
+    case Mir::Angle0:
+        mirOrientation = mir_orientation_normal;
+        break;
+    case Mir::Angle90:
+        mirOrientation = mir_orientation_right;
+        break;
+    case Mir::Angle180:
+        mirOrientation = mir_orientation_inverted;
+        break;
+    case Mir::Angle270:
+        mirOrientation = mir_orientation_left;
+        break;
+    default:
+        qCWarning(QTMIR_SURFACES, "Unsupported orientation angle: %d", angle);
+        return;
+    }
+
+    if (m_surface) {
+        m_surface->set_orientation(mirOrientation);
+    }
+
+    Q_EMIT orientationAngleChanged(angle);
+}
+
+QString MirSurface::name() const
+{
+    //FIXME - how to listen to change in this property?
+    return QString::fromStdString(m_surface->name());
+}
+
+void MirSurface::setState(Mir::State qmlState)
+{
+    int mirState;
+
+    switch (qmlState) {
+    default:
+    case Mir::UnknownState:
+        mirState = mir_surface_state_unknown;
+        break;
+
+    case Mir::RestoredState:
+        mirState = mir_surface_state_restored;
+        break;
+
+    case Mir::MinimizedState:
+        mirState = mir_surface_state_minimized;
+        break;
+
+    case Mir::MaximizedState:
+        mirState = mir_surface_state_maximized;
+        break;
+
+    case Mir::VertMaximizedState:
+        mirState = mir_surface_state_vertmaximized;
+        break;
+
+    case Mir::FullscreenState:
+        mirState = mir_surface_state_fullscreen;
+        break;
+
+    case Mir::HorizMaximizedState:
+        mirState = mir_surface_state_horizmaximized;
+        break;
+
+    case Mir::HiddenState:
+        mirState = mir_surface_state_hidden;
+        break;
+    }
+
+    m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_state, mirState);
+}
+
+void MirSurface::setLive(bool value)
+{
+    if (value != m_live) {
+        m_live = value;
+        Q_EMIT liveChanged(value);
+    }
+}
+
+bool MirSurface::live() const
+{
+    return m_live;
+}
+
+void MirSurface::mousePressEvent(QMouseEvent *event)
+{
+    auto ev = makeMirEvent(event, mir_pointer_action_button_down);
+    m_surface->consume(*ev);
+    event->accept();
+}
+
+void MirSurface::mouseMoveEvent(QMouseEvent *event)
+{
+    auto ev = makeMirEvent(event, mir_pointer_action_motion);
+    m_surface->consume(*ev);
+    event->accept();
+}
+
+void MirSurface::mouseReleaseEvent(QMouseEvent *event)
+{
+    auto ev = makeMirEvent(event, mir_pointer_action_button_up);
+    m_surface->consume(*ev);
+    event->accept();
+}
+
+void MirSurface::hoverEnterEvent(QHoverEvent *event)
+{
+    auto ev = makeMirEvent(event, mir_pointer_action_enter);
+    m_surface->consume(*ev);
+    event->accept();
+}
+
+void MirSurface::hoverLeaveEvent(QHoverEvent *event)
+{
+    auto ev = makeMirEvent(event, mir_pointer_action_leave);
+    m_surface->consume(*ev);
+    event->accept();
+}
+
+void MirSurface::hoverMoveEvent(QHoverEvent *event)
+{
+    auto ev = makeMirEvent(event, mir_pointer_action_motion);
+    m_surface->consume(*ev);
+    event->accept();
+}
+
+void MirSurface::keyPressEvent(QKeyEvent *qtEvent)
+{
+    auto ev = makeMirEvent(qtEvent);
+    m_surface->consume(*ev);
+    qtEvent->accept();
+}
+
+void MirSurface::keyReleaseEvent(QKeyEvent *qtEvent)
+{
+    auto ev = makeMirEvent(qtEvent);
+    m_surface->consume(*ev);
+    qtEvent->accept();
+}
+
+void MirSurface::touchEvent(Qt::KeyboardModifiers mods,
+                            const QList<QTouchEvent::TouchPoint> &touchPoints,
+                            Qt::TouchPointStates touchPointStates,
+                            ulong timestamp)
+{
+    auto ev = makeMirEvent(mods, touchPoints, touchPointStates, timestamp);
+    m_surface->consume(*ev);
+}
+
+bool MirSurface::clientIsRunning() const
+{
+    return (m_session &&
+            (m_session->state() == Session::State::Running
+             || m_session->state() == Session::State::Starting))
+        || !m_session;
+}
+
+bool MirSurface::isBeingDisplayed() const
+{
+    return m_viewCount > 0;
+}
+
+void MirSurface::incrementViewCount()
+{
+    ++m_viewCount;
+    qCDebug(QTMIR_SURFACES).nospace() << "MirSurface::incrementViewCount after=" << m_viewCount;
+    if (m_viewCount == 1) {
+        Q_EMIT isBeingDisplayedChanged();
+    }
+}
+
+void MirSurface::decrementViewCount()
+{
+    Q_ASSERT(m_viewCount > 0);
+    --m_viewCount;
+    qCDebug(QTMIR_SURFACES).nospace() << "MirSurface::decrementViewCount after=" << m_viewCount;
+    if (m_viewCount == 0) {
+        Q_EMIT isBeingDisplayedChanged();
+        if (m_session.isNull() || !m_live) {
+            deleteLater();
+        }
+    }
+}
+
+unsigned int MirSurface::currentFrameNumber() const
+{
+    return m_currentFrameNumber;
+}
+
+void MirSurface::onSessionDestroyed()
+{
+    if (m_viewCount == 0) {
+        deleteLater();
+    }
+}
+
+void MirSurface::emitSizeChanged()
+{
+    Q_EMIT sizeChanged(m_size);
+}

=== added file 'src/modules/Unity/Application/mirsurface.h'
--- src/modules/Unity/Application/mirsurface.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/mirsurface.h	2015-08-27 14:51:37 +0000
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QTMIR_MIRSURFACE_H
+#define QTMIR_MIRSURFACE_H
+
+#include "mirsurfaceinterface.h"
+
+// Qt
+#include <QMutex>
+#include <QPointer>
+#include <QSharedPointer>
+#include <QSGTextureProvider>
+#include <QTimer>
+#include <QWeakPointer>
+
+#include "mirbuffersgtexture.h"
+#include "session.h"
+#include "mirserver.h"
+
+// mir
+#include <mir/scene/surface.h>
+#include <mir_toolkit/common.h>
+
+class SurfaceObserver;
+
+namespace qtmir {
+
+class MirSurface : public MirSurfaceInterface
+{
+    Q_OBJECT
+
+public:
+    MirSurface(std::shared_ptr<mir::scene::Surface> surface,
+            SessionInterface* session,
+            MirShell *shell,
+            std::shared_ptr<SurfaceObserver> observer);
+    virtual ~MirSurface();
+
+    ////
+    // unity::shell::application::MirSurfaceInterface
+
+    Mir::Type type() const override;
+
+    QString name() const override;
+
+    QSize size() const override;
+    void resize(int width, int height) override;
+
+    Mir::State state() const override;
+    void setState(Mir::State qmlState) override;
+
+    bool live() const override;
+
+    Mir::OrientationAngle orientationAngle() const override;
+    void setOrientationAngle(Mir::OrientationAngle angle) override;
+
+    ////
+    // qtmir::MirSurfaceInterface
+
+    void setLive(bool value) override;
+
+    bool isFirstFrameDrawn() const override { return m_firstFrameDrawn; }
+
+    SessionInterface *session() const override;
+
+    void stopFrameDropper() override;
+    void startFrameDropper() override;
+
+    bool isBeingDisplayed() const override;
+    void incrementViewCount() override;
+    void decrementViewCount() override;
+
+    // methods called from the rendering (scene graph) thread:
+    QSharedPointer<QSGTexture> texture() override;
+    void updateTexture() override;
+    unsigned int currentFrameNumber() const override;
+    bool numBuffersReadyForCompositor() override;
+    // end of methods called from the rendering (scene graph) thread
+
+    void setFocus(bool focus) override;
+
+    void mousePressEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent *event) override;
+    void mouseReleaseEvent(QMouseEvent *event) override;
+    void hoverEnterEvent(QHoverEvent *event) override;
+    void hoverLeaveEvent(QHoverEvent *event) override;
+    void hoverMoveEvent(QHoverEvent *event) override;
+
+    void keyPressEvent(QKeyEvent *event) override;
+    void keyReleaseEvent(QKeyEvent *event) override;
+
+    void touchEvent(Qt::KeyboardModifiers qmods,
+            const QList<QTouchEvent::TouchPoint> &qtTouchPoints,
+            Qt::TouchPointStates qtTouchPointStates,
+            ulong qtTimestamp) override;
+
+public Q_SLOTS:
+    void onCompositorSwappedBuffers() override;
+
+private Q_SLOTS:
+    void dropPendingBuffer();
+    void onAttributeChanged(const MirSurfaceAttrib, const int);
+    void onFramesPostedObserved();
+    void onSessionDestroyed();
+    void emitSizeChanged();
+
+private:
+    void syncSurfaceSizeWithItemSize();
+    bool clientIsRunning() const;
+
+    std::shared_ptr<mir::scene::Surface> m_surface;
+    QPointer<SessionInterface> m_session;
+    MirShell *const m_shell;
+    bool m_firstFrameDrawn;
+
+    //FIXME -  have to save the state as Mir has no getter for it (bug:1357429)
+    Mir::OrientationAngle m_orientationAngle;
+
+    QTimer m_frameDropperTimer;
+
+    QMutex m_mutex;
+
+    // Lives in the rendering (scene graph) thread
+    QWeakPointer<QSGTexture> m_texture;
+    bool m_textureUpdated;
+    unsigned int m_currentFrameNumber;
+
+    bool m_live;
+    int m_viewCount;
+
+    std::shared_ptr<SurfaceObserver> m_surfaceObserver;
+
+    QSize m_size;
+};
+
+} // namespace qtmir
+
+#endif // QTMIR_MIRSURFACE_H

=== added file 'src/modules/Unity/Application/mirsurfaceinterface.h'
--- src/modules/Unity/Application/mirsurfaceinterface.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/mirsurfaceinterface.h	2015-08-27 14:51:37 +0000
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QTMIR_MIRSURFACEINTERFACE_H
+#define QTMIR_MIRSURFACEINTERFACE_H
+
+// Unity API
+#include <unity/shell/application/MirSurfaceInterface.h>
+
+#include "session_interface.h"
+
+// Qt
+#include <QTouchEvent>
+
+class QHoverEvent;
+class QMouseEvent;
+class QKeyEvent;
+class QSGTexture;
+
+namespace qtmir {
+
+class MirSurfaceInterface : public unity::shell::application::MirSurfaceInterface
+{
+    Q_OBJECT
+public:
+    MirSurfaceInterface(QObject *parent = nullptr) : unity::shell::application::MirSurfaceInterface(parent) {}
+    virtual ~MirSurfaceInterface() {}
+
+    virtual void setLive(bool value) = 0;
+
+    virtual bool isFirstFrameDrawn() const = 0;
+
+    virtual SessionInterface *session() const = 0;
+
+    virtual void stopFrameDropper() = 0;
+    virtual void startFrameDropper() = 0;
+
+    virtual bool isBeingDisplayed() const = 0;
+    virtual void incrementViewCount() = 0;
+    virtual void decrementViewCount() = 0;
+
+    // methods called from the rendering (scene graph) thread:
+    virtual QSharedPointer<QSGTexture> texture() = 0;
+    virtual void updateTexture() = 0;
+    virtual unsigned int currentFrameNumber() const = 0;
+    virtual bool numBuffersReadyForCompositor() = 0;
+    // end of methods called from the rendering (scene graph) thread
+
+    virtual void setFocus(bool focus) = 0;
+
+    virtual void mousePressEvent(QMouseEvent *event) = 0;
+    virtual void mouseMoveEvent(QMouseEvent *event) = 0;
+    virtual void mouseReleaseEvent(QMouseEvent *event) = 0;
+    virtual void hoverEnterEvent(QHoverEvent *event) = 0;
+    virtual void hoverLeaveEvent(QHoverEvent *event) = 0;
+    virtual void hoverMoveEvent(QHoverEvent *event) = 0;
+
+    virtual void keyPressEvent(QKeyEvent *event) = 0;
+    virtual void keyReleaseEvent(QKeyEvent *event) = 0;
+
+    virtual void touchEvent(Qt::KeyboardModifiers qmods,
+            const QList<QTouchEvent::TouchPoint> &qtTouchPoints,
+            Qt::TouchPointStates qtTouchPointStates,
+            ulong qtTimestamp) = 0;
+
+public Q_SLOTS:
+    virtual void onCompositorSwappedBuffers() = 0;
+
+Q_SIGNALS:
+    void firstFrameDrawn();
+    void framesPosted();
+    void isBeingDisplayedChanged();
+};
+
+} // namespace qtmir
+
+#endif // QTMIR_MIRSURFACEINTERFACE_H

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2015-08-20 12:38:34 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2015-08-27 14:51:37 +0000
@@ -16,424 +16,214 @@
 
 // local
 #include "application.h"
-#include "mirbuffersgtexture.h"
 #include "session.h"
 #include "mirsurfaceitem.h"
 #include "logging.h"
 #include "ubuntukeyboardinfo.h"
 
-// mirserver
-#include "surfaceobserver.h"
-
 // common
 #include <debughelpers.h>
 
 // Qt
 #include <QDebug>
 #include <QGuiApplication>
+#include <QMutexLocker>
 #include <QQmlEngine>
 #include <QQuickWindow>
 #include <QScreen>
 #include <private/qsgdefaultimagenode_p.h>
-#include <QSGTextureProvider>
+#include <QRunnable>
 #include <QTimer>
 
-// Mir
-#include <mir/geometry/rectangle.h>
-#include <mir/events/event_builders.h>
-#include <mir_toolkit/event.h>
-#include <mir/shell/shell.h>
-
-namespace mg = mir::graphics;
-
 namespace qtmir {
 
 namespace {
 
-// Would be better if QMouseEvent had nativeModifiers
-MirInputEventModifiers
-getMirModifiersFromQt(Qt::KeyboardModifiers mods)
-{
-    MirInputEventModifiers m_mods = mir_input_event_modifier_none;
-    if (mods & Qt::ShiftModifier)
-        m_mods |= mir_input_event_modifier_shift;
-    if (mods & Qt::ControlModifier)
-        m_mods |= mir_input_event_modifier_ctrl;
-    if (mods & Qt::AltModifier)
-        m_mods |= mir_input_event_modifier_alt;
-    if (mods & Qt::MetaModifier)
-        m_mods |= mir_input_event_modifier_meta;
-
-    return m_mods;
-}
-
-mir::EventUPtr makeMirEvent(QMouseEvent *qtEvent, MirPointerAction action)
-{
-    auto timestamp = std::chrono::milliseconds(qtEvent->timestamp());
-    auto modifiers = getMirModifiersFromQt(qtEvent->modifiers());
-
-    MirPointerButtons buttons = 0;
-    if (qtEvent->buttons() & Qt::LeftButton)
-        buttons |= mir_pointer_button_primary;
-    if (qtEvent->buttons() & Qt::RightButton)
-        buttons |= mir_pointer_button_secondary;
-    if (qtEvent->buttons() & Qt::MidButton)
-        buttons |= mir_pointer_button_tertiary;
-
-    return mir::events::make_event(0 /*DeviceID */, timestamp, modifiers, action,
-                                   buttons, qtEvent->x(), qtEvent->y(), 0, 0);
-}
-
-mir::EventUPtr makeMirEvent(QHoverEvent *qtEvent, MirPointerAction action)
-{
-    auto timestamp = std::chrono::milliseconds(qtEvent->timestamp());
-
-    MirPointerButtons buttons = 0;
-
-    return mir::events::make_event(0 /*DeviceID */, timestamp, mir_input_event_modifier_none, action,
-                                   buttons, qtEvent->posF().x(), qtEvent->posF().y(), 0, 0);
-}
-
-mir::EventUPtr makeMirEvent(QKeyEvent *qtEvent)
-{
-    MirKeyboardAction action = mir_keyboard_action_down;
-    switch (qtEvent->type())
-    {
-    case QEvent::KeyPress:
-        action = mir_keyboard_action_down;
-        break;
-    case QEvent::KeyRelease:
-        action = mir_keyboard_action_up;
-        break;
-    default:
-        break;
-    }
-    if (qtEvent->isAutoRepeat())
-        action = mir_keyboard_action_repeat;
-
-    return mir::events::make_event(0 /* DeviceID */, std::chrono::milliseconds(qtEvent->timestamp()),
-                           action, qtEvent->nativeVirtualKey(),
-                           qtEvent->nativeScanCode(),
-                           qtEvent->nativeModifiers());
-}
-
-mir::EventUPtr makeMirEvent(Qt::KeyboardModifiers qmods,
-                            const QList<QTouchEvent::TouchPoint> &qtTouchPoints,
-                            Qt::TouchPointStates /* qtTouchPointStates */,
-                            ulong qtTimestamp)
-{
-    auto modifiers = getMirModifiersFromQt(qmods);
-    auto ev = mir::events::make_event(0, std::chrono::milliseconds(qtTimestamp),
-                                      modifiers);
-
-    for (int i = 0; i < qtTouchPoints.count(); ++i) {
-        auto touchPoint = qtTouchPoints.at(i);
-        auto id = touchPoint.id();
-
-        MirTouchAction action = mir_touch_action_change;
-        if (touchPoint.state() == Qt::TouchPointReleased)
-        {
-            action = mir_touch_action_up;
-        }
-        if (touchPoint.state() == Qt::TouchPointPressed)
-        {
-            action = mir_touch_action_down;
-        }
-
-        MirTouchTooltype tooltype = mir_touch_tooltype_finger;
-        if (touchPoint.flags() & QTouchEvent::TouchPoint::Pen)
-            tooltype = mir_touch_tooltype_stylus;
-
-        mir::events::add_touch(*ev, id, action, tooltype,
-                               touchPoint.pos().x(), touchPoint.pos().y(),
-                               touchPoint.pressure(),
-                               touchPoint.rect().width(),
-                               touchPoint.rect().height(),
-                               0 /* size */);
-    }
-
-    return ev;
-}
+class MirSurfaceItemReleaseResourcesJob : public QRunnable
+{
+public:
+    MirSurfaceItemReleaseResourcesJob() : textureProvider(nullptr) {}
+    void run() {
+        delete textureProvider;
+        textureProvider = nullptr;
+    }
+    QObject *textureProvider;
+};
 
 } // namespace {
 
-class QMirSurfaceTextureProvider : public QSGTextureProvider
+class MirTextureProvider : public QSGTextureProvider
 {
     Q_OBJECT
 public:
-    QMirSurfaceTextureProvider() : t(0) { }
-    ~QMirSurfaceTextureProvider() { delete t; }
-
+    MirTextureProvider(QSharedPointer<QSGTexture> texture) : t(texture) {}
     QSGTexture *texture() const {
         if (t)
             t->setFiltering(smooth ? QSGTexture::Linear : QSGTexture::Nearest);
-        return t;
+        return t.data();
     }
 
     bool smooth;
-    MirBufferSGTexture *t;
-
-public Q_SLOTS:
-    void invalidate()
-    {
-        delete t;
-        t = 0;
-    }
+
+    void releaseTexture() {
+        t.reset();
+    }
+
+    void setTexture(QSharedPointer<QSGTexture> newTexture) {
+        t = newTexture;
+    }
+
+private:
+    QSharedPointer<QSGTexture> t;
 };
 
-MirSurfaceItem::MirSurfaceItem(std::shared_ptr<mir::scene::Surface> surface,
-                               SessionInterface* session,
-                               MirShell *shell,
-                               std::shared_ptr<SurfaceObserver> observer,
-                               QQuickItem *parent)
+MirSurfaceItem::MirSurfaceItem(QQuickItem *parent)
     : MirSurfaceItemInterface(parent)
-    , m_surface(surface)
-    , m_session(session)
-    , m_shell(shell)
-    , m_firstFrameDrawn(false)
-    , m_live(true)
-    , m_orientationAngle(Angle0)
+    , m_surface(nullptr)
     , m_textureProvider(nullptr)
     , m_lastTouchEvent(nullptr)
+    , m_lastFrameNumberRendered(nullptr)
+    , m_surfaceWidth(0)
+    , m_surfaceHeight(0)
+    , m_orientationAngle(nullptr)
+    , m_consumesInput(false)
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::MirSurfaceItem";
 
-    m_surfaceObserver = observer;
-    if (observer) {
-        connect(observer.get(), &SurfaceObserver::framesPosted, this, &MirSurfaceItem::surfaceDamaged);
-        connect(observer.get(), &SurfaceObserver::attributeChanged, this, &MirSurfaceItem::onAttributeChanged);
-        observer->setListener(this);
-    }
-
     setSmooth(true);
     setFlag(QQuickItem::ItemHasContents, true); //so scene graph will render this item
-    setAcceptedMouseButtons(Qt::LeftButton | Qt::MiddleButton | Qt::RightButton |
-        Qt::ExtraButton1 | Qt::ExtraButton2 | Qt::ExtraButton3 | Qt::ExtraButton4 |
-        Qt::ExtraButton5 | Qt::ExtraButton6 | Qt::ExtraButton7 | Qt::ExtraButton8 |
-        Qt::ExtraButton9 | Qt::ExtraButton10 | Qt::ExtraButton11 |
-        Qt::ExtraButton12 | Qt::ExtraButton13);
-    setAcceptHoverEvents(true);
-
-    // fetch surface geometry
-    setImplicitSize(static_cast<qreal>(m_surface->size().width.as_float()),
-                    static_cast<qreal>(m_surface->size().height.as_float()));
 
     if (!UbuntuKeyboardInfo::instance()) {
         new UbuntuKeyboardInfo;
     }
 
-    // Ensure C++ (MirSurfaceManager) retains ownership of this object
-    // TODO: Investigate if having the Javascript engine have ownership of this object
-    // might create a less error-prone API design (concern: QML forgets to call "release()"
-    // for a surface, and thus Mir will not release the surface buffers etc.)
-    QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);
-
-    connect(&m_frameDropperTimer, &QTimer::timeout,
-            this, &MirSurfaceItem::dropPendingBuffer);
-    // Rationale behind the frame dropper and its interval value:
-    //
-    // We want to give ample room for Qt scene graph to have a chance to fetch and render
-    // the next pending buffer before we take the drastic action of dropping it (so don't set
-    // it anywhere close to our target render interval).
-    //
-    // We also want to guarantee a minimal frames-per-second (fps) frequency for client applications
-    // as they get stuck on swap_buffers() if there's no free buffer to swap to yet (ie, they
-    // are all pending consumption by the compositor, us). But on the other hand, we don't want
-    // that minimal fps to be too high as that would mean this timer would be triggered way too often
-    // for nothing causing unnecessary overhead as actually dropping frames from an app should
-    // in practice rarely happen.
-    m_frameDropperTimer.setInterval(200);
-    m_frameDropperTimer.setSingleShot(false);
-
     m_updateMirSurfaceSizeTimer.setSingleShot(true);
     m_updateMirSurfaceSizeTimer.setInterval(1);
     connect(&m_updateMirSurfaceSizeTimer, &QTimer::timeout, this, &MirSurfaceItem::updateMirSurfaceSize);
-    connect(this, &QQuickItem::widthChanged, this, &MirSurfaceItem::scheduleMirSurfaceSizeUpdate);
-    connect(this, &QQuickItem::heightChanged, this, &MirSurfaceItem::scheduleMirSurfaceSizeUpdate);
 
-    // FIXME - setting surface unfocused immediately breaks camera & video apps, but is
-    // technically the correct thing to do (surface should be unfocused until shell focuses it)
-    //m_surface->configure(mir_surface_attrib_focus, mir_surface_unfocused);
     connect(this, &QQuickItem::activeFocusChanged, this, &MirSurfaceItem::updateMirSurfaceFocus);
-
-    if (m_session) {
-        connect(m_session.data(), &Session::stateChanged, this, &MirSurfaceItem::onSessionStateChanged);
-    }
 }
 
 MirSurfaceItem::~MirSurfaceItem()
 {
-    if (m_session) {
-        m_session->setSurface(nullptr);
-    }
-
     qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::~MirSurfaceItem - this=" << this;
-    QMutexLocker locker(&m_mutex);
-    m_surface->remove_observer(m_surfaceObserver);
-    if (m_textureProvider)
-        m_textureProvider->deleteLater();
+
+    setSurface(nullptr);
 
     delete m_lastTouchEvent;
-}
-
-// For QML to destroy this surface
-void MirSurfaceItem::release()
-{
-    qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::release - this=" << this;
-
-    if (m_session) {
-        m_session->setSurface(nullptr);
-    }
-    deleteLater();
-}
-
-SessionInterface* MirSurfaceItem::session() const
-{
-    return m_session.data();
-}
-
-MirSurfaceItem::Type MirSurfaceItem::type() const
-{
-    return static_cast<MirSurfaceItem::Type>(m_surface->type());
-}
-
-MirSurfaceItem::State MirSurfaceItem::state() const
-{
-    return static_cast<MirSurfaceItem::State>(m_surface->state());
-}
-
-MirSurfaceItem::OrientationAngle MirSurfaceItem::orientationAngle() const
-{
-    return m_orientationAngle;
-}
-
-void MirSurfaceItem::setOrientationAngle(MirSurfaceItem::OrientationAngle angle)
+    delete m_lastFrameNumberRendered;
+    delete m_orientationAngle;
+    delete m_textureProvider;
+}
+
+Mir::Type MirSurfaceItem::type() const
+{
+    if (m_surface) {
+        return m_surface->type();
+    } else {
+        return Mir::UnknownType;
+    }
+}
+
+Mir::OrientationAngle MirSurfaceItem::orientationAngle() const
+{
+    if (m_orientationAngle) {
+        Q_ASSERT(!m_surface);
+        return *m_orientationAngle;
+    } else if (m_surface) {
+        return m_surface->orientationAngle();
+    } else {
+        return Mir::Angle0;
+    }
+}
+
+void MirSurfaceItem::setOrientationAngle(Mir::OrientationAngle angle)
 {
     qCDebug(QTMIR_SURFACES, "MirSurfaceItem::setOrientationAngle(%d)", angle);
 
-    if (m_orientationAngle == angle)
-        return;
-
-    MirOrientation mirOrientation;
-
-    switch (angle) {
-    case Angle0:
-        mirOrientation = mir_orientation_normal;
-        break;
-    case Angle90:
-        mirOrientation = mir_orientation_right;
-        break;
-    case Angle180:
-        mirOrientation = mir_orientation_inverted;
-        break;
-    case Angle270:
-        mirOrientation = mir_orientation_left;
-        break;
-    default:
-        qCWarning(QTMIR_SURFACES, "Unsupported orientation angle: %d", angle);
-        return;
+    if (m_surface) {
+        Q_ASSERT(!m_orientationAngle);
+        m_surface->setOrientationAngle(angle);
+    } else if (!m_orientationAngle) {
+        m_orientationAngle = new Mir::OrientationAngle;
+        *m_orientationAngle = angle;
+        Q_EMIT orientationAngleChanged(angle);
+    } else if (*m_orientationAngle != angle) {
+        *m_orientationAngle = angle;
+        Q_EMIT orientationAngleChanged(angle);
     }
-
-    m_surface->set_orientation(mirOrientation);
-
-    m_orientationAngle = angle;
-    Q_EMIT orientationAngleChanged(angle);
 }
 
 QString MirSurfaceItem::name() const
 {
-    //FIXME - how to listen to change in this property?
-    return QString::fromStdString(m_surface->name());
+    if (m_surface) {
+        return m_surface->name();
+    } else {
+        return QString();
+    }
 }
 
 bool MirSurfaceItem::live() const
 {
-    return m_live;
+    return m_surface && m_surface->live();
 }
 
 // Called from the rendering (scene graph) thread
 QSGTextureProvider *MirSurfaceItem::textureProvider() const
 {
-    const_cast<MirSurfaceItem *>(this)->ensureProvider();
+    QMutexLocker mutexLocker(const_cast<QMutex*>(&m_mutex));
+    const_cast<MirSurfaceItem *>(this)->ensureTextureProvider();
     return m_textureProvider;
 }
 
-void MirSurfaceItem::ensureProvider()
+void MirSurfaceItem::ensureTextureProvider()
 {
+    if (!m_surface) {
+        return;
+    }
+
     if (!m_textureProvider) {
-        m_textureProvider = new QMirSurfaceTextureProvider();
-        connect(window(), SIGNAL(sceneGraphInvalidated()),
-                m_textureProvider, SLOT(invalidate()), Qt::DirectConnection);
-    }
-}
-
-void MirSurfaceItem::surfaceDamaged()
-{
-    if (!m_firstFrameDrawn) {
-        m_firstFrameDrawn = true;
-        Q_EMIT firstFrameDrawn();
-    }
-
-    scheduleTextureUpdate();
-}
-
-bool MirSurfaceItem::updateTexture()    // called by rendering thread (scene graph)
-{
-    QMutexLocker locker(&m_mutex);
-    ensureProvider();
-    bool textureUpdated = false;
-
-    const void* const userId = (void*)123;
-    auto renderables = m_surface->generate_renderables(userId);
-
-    if (m_surface->buffers_ready_for_compositor(userId) > 0 && renderables.size() > 0) {
-        if (!m_textureProvider->t) {
-            m_textureProvider->t = new MirBufferSGTexture(renderables[0]->buffer());
-        } else {
-            // Avoid holding two buffers for the compositor at the same time. Thus free the current
-            // before acquiring the next
-            m_textureProvider->t->freeBuffer();
-            m_textureProvider->t->setBuffer(renderables[0]->buffer());
-        }
-        textureUpdated = true;
-    }
-
-    if (m_surface->buffers_ready_for_compositor(userId) > 0) {
+        m_textureProvider = new MirTextureProvider(m_surface->texture());
+    } else if (!m_textureProvider->texture()) {
+        m_textureProvider->setTexture(m_surface->texture());
+    }
+}
+
+QSGNode *MirSurfaceItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)    // called by render thread
+{
+    QMutexLocker mutexLocker(&m_mutex);
+
+    if (!m_surface) {
+        delete oldNode;
+        return 0;
+    }
+
+    ensureTextureProvider();
+
+    m_surface->updateTexture();
+
+    if (m_surface->numBuffersReadyForCompositor() > 0) {
         QTimer::singleShot(0, this, SLOT(update()));
-        // restart the frame dropper so that we have enough time to render the next frame.
-        // queued since the timer lives in a different thread
-        QMetaObject::invokeMethod(&m_frameDropperTimer, "start", Qt::QueuedConnection);
+    }
+
+    if (!m_textureProvider->texture()) {
+        delete oldNode;
+        return 0;
     }
 
     m_textureProvider->smooth = smooth();
 
-    return textureUpdated;
-}
-
-QSGNode *MirSurfaceItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)    // called by render thread
-{
-    if (!m_surface) {
-        delete oldNode;
-        return 0;
-    }
-
-    bool textureUpdated = updateTexture();
-    if (!m_textureProvider->t) {
-        delete oldNode;
-        return 0;
-    }
-
     QSGDefaultImageNode *node = static_cast<QSGDefaultImageNode*>(oldNode);
     if (!node) {
         node = new QSGDefaultImageNode;
-        node->setTexture(m_textureProvider->t);
+        node->setTexture(m_textureProvider->texture());
 
         node->setMipmapFiltering(QSGTexture::None);
         node->setHorizontalWrapMode(QSGTexture::ClampToEdge);
         node->setVerticalWrapMode(QSGTexture::ClampToEdge);
         node->setSubSourceRect(QRectF(0, 0, 1, 1));
     } else {
-        if (textureUpdated) {
+        if (!m_lastFrameNumberRendered  || (*m_lastFrameNumberRendered != m_surface->currentFrameNumber())) {
             node->markDirty(QSGNode::DirtyMaterial);
         }
     }
@@ -446,39 +236,48 @@
 
     node->update();
 
+    if (!m_lastFrameNumberRendered) {
+        m_lastFrameNumberRendered = new unsigned int;
+    }
+    *m_lastFrameNumberRendered = m_surface->currentFrameNumber();
+
     return node;
 }
 
 void MirSurfaceItem::mousePressEvent(QMouseEvent *event)
 {
-    if (type() == InputMethod) {
-        // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
-        if (isMouseInsideUbuntuKeyboard(event)) {
-            auto ev = makeMirEvent(event, mir_pointer_action_button_down);
-            m_surface->consume(*ev);
-            event->accept();
+    if (m_consumesInput && m_surface && m_surface->live()) {
+        if (type() == Mir::InputMethodType) {
+            // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
+            if (isMouseInsideUbuntuKeyboard(event)) {
+                m_surface->mousePressEvent(event);
+            } else {
+                event->ignore();
+            }
         } else {
-            event->ignore();
+            m_surface->mousePressEvent(event);
         }
     } else {
-        auto ev = makeMirEvent(event, mir_pointer_action_button_down);
-        m_surface->consume(*ev);
-        event->accept();
+        event->ignore();
     }
 }
 
 void MirSurfaceItem::mouseMoveEvent(QMouseEvent *event)
 {
-    auto ev = makeMirEvent(event, mir_pointer_action_motion);
-    m_surface->consume(*ev);
-    event->accept();
+    if (m_consumesInput && m_surface && m_surface->live()) {
+        m_surface->mouseMoveEvent(event);
+    } else {
+        event->ignore();
+    }
 }
 
 void MirSurfaceItem::mouseReleaseEvent(QMouseEvent *event)
 {
-    auto ev = makeMirEvent(event, mir_pointer_action_button_up);
-    m_surface->consume(*ev);
-    event->accept();
+    if (m_consumesInput && m_surface && m_surface->live()) {
+        m_surface->mouseReleaseEvent(event);
+    } else {
+        event->ignore();
+    }
 }
 
 void MirSurfaceItem::wheelEvent(QWheelEvent *event)
@@ -488,44 +287,57 @@
 
 void MirSurfaceItem::hoverEnterEvent(QHoverEvent *event)
 {
-    auto ev = makeMirEvent(event, mir_pointer_action_enter);
-    m_surface->consume(*ev);
-    event->accept();
+    if (m_consumesInput && m_surface && m_surface->live()) {
+        m_surface->hoverEnterEvent(event);
+    } else {
+        event->ignore();
+    }
 }
 
 void MirSurfaceItem::hoverLeaveEvent(QHoverEvent *event)
 {
-    auto ev = makeMirEvent(event, mir_pointer_action_leave);
-    m_surface->consume(*ev);
-    event->accept();
+    if (m_consumesInput && m_surface && m_surface->live()) {
+        m_surface->hoverLeaveEvent(event);
+    } else {
+        event->ignore();
+    }
 }
 
 void MirSurfaceItem::hoverMoveEvent(QHoverEvent *event)
 {
-    auto ev = makeMirEvent(event, mir_pointer_action_motion);
-    m_surface->consume(*ev);
-    event->accept();
-}
-
-void MirSurfaceItem::keyPressEvent(QKeyEvent *qtEvent)
-{
-    auto ev = makeMirEvent(qtEvent);
-    m_surface->consume(*ev);
-    qtEvent->accept();
-}
-
-void MirSurfaceItem::keyReleaseEvent(QKeyEvent *qtEvent)
-{
-    auto ev = makeMirEvent(qtEvent);
-    m_surface->consume(*ev);
-    qtEvent->accept();
+    if (m_consumesInput && m_surface && m_surface->live()) {
+        m_surface->hoverMoveEvent(event);
+    } else {
+        event->ignore();
+    }
+}
+
+void MirSurfaceItem::keyPressEvent(QKeyEvent *event)
+{
+    if (m_consumesInput && m_surface && m_surface->live()) {
+        m_surface->keyPressEvent(event);
+    } else {
+        event->ignore();
+    }
+}
+
+void MirSurfaceItem::keyReleaseEvent(QKeyEvent *event)
+{
+    if (m_consumesInput && m_surface && m_surface->live()) {
+        m_surface->keyReleaseEvent(event);
+    } else {
+        event->ignore();
+    }
 }
 
 QString MirSurfaceItem::appId() const
 {
     QString appId;
-    if (session() && session()->application()) {
-        appId = session()->application()->appId();
+
+    SessionInterface *session = m_surface ? m_surface->session() : nullptr;
+
+    if (session && session->application()) {
+        appId = session->application()->appId();
     } else {
         appId.append("-");
     }
@@ -557,9 +369,8 @@
 
         touchEvent.updateTouchPointStatesAndType();
 
-        auto ev = makeMirEvent(touchEvent.modifiers, touchEvent.touchPoints,
+        m_surface->touchEvent(touchEvent.modifiers, touchEvent.touchPoints,
                                touchEvent.touchPointStates, touchEvent.timestamp);
-        m_surface->consume(*ev);
 
         *m_lastTouchEvent = touchEvent;
 
@@ -580,8 +391,7 @@
         endCurrentTouchSequence(timestamp);
     }
 
-    auto ev = makeMirEvent(mods, touchPoints, touchPointStates, timestamp);
-    m_surface->consume(*ev);
+    m_surface->touchEvent(mods, touchPoints, touchPointStates, timestamp);
 
     if (!m_lastTouchEvent) {
         m_lastTouchEvent = new TouchEvent;
@@ -609,8 +419,13 @@
         const QList<QTouchEvent::TouchPoint> &touchPoints,
         Qt::TouchPointStates touchPointStates)
 {
+
+    if (!m_consumesInput || !m_surface || !m_surface->live()) {
+        return false;
+    }
+
     bool accepted = true;
-    if (type() == InputMethod && eventType == QEvent::TouchBegin) {
+    if (type() == Mir::InputMethodType && eventType == QEvent::TouchBegin) {
         // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
         if (hasTouchInsideUbuntuKeyboard(touchPoints)) {
             validateAndDeliverTouchEvent(eventType, timestamp, mods, touchPoints, touchPointStates);
@@ -654,75 +469,45 @@
         && pos.y() <= (ubuntuKeyboardInfo->y() + ubuntuKeyboardInfo->height());
 }
 
-void MirSurfaceItem::setType(const Type &type)
-{
-    if (this->type() != type) {
-        m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_type, static_cast<int>(type));
-    }
-}
-
-void MirSurfaceItem::setState(const State &state)
-{
-    if (this->state() != state) {
-        m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_state, static_cast<int>(state));
-    }
-}
-
-void MirSurfaceItem::setLive(bool live)
-{
-    if (m_live != live) {
-        m_live = live;
-        Q_EMIT liveChanged(m_live);
-    }
-}
-
-void MirSurfaceItem::onAttributeChanged(const MirSurfaceAttrib attribute, const int /*value*/)
-{
-    switch (attribute) {
-    case mir_surface_attrib_type:
-        Q_EMIT typeChanged();
-        break;
-    case mir_surface_attrib_state:
-        Q_EMIT stateChanged();
-        break;
-    default:
-        break;
+Mir::State MirSurfaceItem::surfaceState() const
+{
+    if (m_surface) {
+        return m_surface->state();
+    } else {
+        return Mir::UnknownState;
+    }
+}
+
+void MirSurfaceItem::setSurfaceState(Mir::State state)
+{
+    if (m_surface) {
+        m_surface->setState(state);
     }
 }
 
 void MirSurfaceItem::scheduleMirSurfaceSizeUpdate()
 {
-    if (clientIsRunning() && !m_updateMirSurfaceSizeTimer.isActive()) {
+    if (!m_updateMirSurfaceSizeTimer.isActive()) {
         m_updateMirSurfaceSizeTimer.start();
     }
 }
 
 void MirSurfaceItem::updateMirSurfaceSize()
 {
-    int mirWidth = m_surface->size().width.as_int();
-    int mirHeight = m_surface->size().height.as_int();
-
-    int qmlWidth = (int)width();
-    int qmlHeight = (int)height();
-
-    bool mirSizeIsDifferent = qmlWidth != mirWidth || qmlHeight != mirHeight;
-
-    const char *didResize = clientIsRunning() && mirSizeIsDifferent ? "surface resized" : "surface NOT resized";
-    qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::updateMirSurfaceSize"
-            << "surface =" << this
-            << ", old (" << mirWidth << "," << mirHeight << ")"
-            << ", new (" << qmlWidth << "," << qmlHeight << ")"
-            << didResize;
-
-    if (clientIsRunning() && mirSizeIsDifferent) {
-        mir::geometry::Size newMirSize(qmlWidth, qmlHeight);
-        m_surface->resize(newMirSize);
-        setImplicitSize(qmlWidth, qmlHeight);
+    if (!m_surface || !m_surface->live() || (m_surfaceWidth <= 0 && m_surfaceHeight <= 0)) {
+        return;
     }
+
+    // If one dimension is not set, fallback to the current value
+    int width = m_surfaceWidth > 0 ? m_surfaceWidth : m_surface->size().width();
+    int height = m_surfaceHeight > 0 ? m_surfaceHeight : m_surface->size().height();
+
+    m_surface->resize(width, height);
 }
 
 void MirSurfaceItem::updateMirSurfaceFocus(bool focused)
 {
+<<<<<<< TREE
     qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::updateMirSurfaceFocus" << focused;
 
     // Temporary hotfix for http://pad.lv/1483752
@@ -820,6 +605,17 @@
             (m_session->state() == Session::State::Running
              || m_session->state() == Session::State::Starting))
         || !m_session;
+=======
+    if (m_surface && m_consumesInput && m_surface->live()) {
+        m_surface->setFocus(focused);
+    }
+}
+
+void MirSurfaceItem::invalidateSceneGraph()
+{
+    delete m_textureProvider;
+    m_textureProvider = nullptr;
+>>>>>>> MERGE-SOURCE
 }
 
 void MirSurfaceItem::TouchEvent::updateTouchPointStatesAndType()
@@ -838,6 +634,142 @@
     }
 }
 
+bool MirSurfaceItem::consumesInput() const
+{
+    return m_consumesInput;
+}
+
+void MirSurfaceItem::setConsumesInput(bool value)
+{
+    if (m_consumesInput == value) {
+        return;
+    }
+
+    m_consumesInput = value;
+    if (m_consumesInput) {
+        setAcceptedMouseButtons(Qt::LeftButton | Qt::MiddleButton | Qt::RightButton |
+            Qt::ExtraButton1 | Qt::ExtraButton2 | Qt::ExtraButton3 | Qt::ExtraButton4 |
+            Qt::ExtraButton5 | Qt::ExtraButton6 | Qt::ExtraButton7 | Qt::ExtraButton8 |
+            Qt::ExtraButton9 | Qt::ExtraButton10 | Qt::ExtraButton11 |
+            Qt::ExtraButton12 | Qt::ExtraButton13);
+        setAcceptHoverEvents(true);
+    } else {
+        setAcceptedMouseButtons(Qt::NoButton);
+        setAcceptHoverEvents(false);
+    }
+
+    Q_EMIT consumesInputChanged(value);
+}
+
+unity::shell::application::MirSurfaceInterface* MirSurfaceItem::surface() const
+{
+    return m_surface;
+}
+
+void MirSurfaceItem::setSurface(unity::shell::application::MirSurfaceInterface *unitySurface)
+{
+    QMutexLocker mutexLocker(&m_mutex);
+
+    qtmir::MirSurface *surface = static_cast<qtmir::MirSurface*>(unitySurface);
+    qCDebug(QTMIR_SURFACES).nospace() << "MirSurfaceItem::setSurface surface=" << surface;
+
+    if (surface == m_surface) {
+        return;
+    }
+
+    if (m_surface) {
+        disconnect(m_surface, nullptr, this, nullptr);
+        m_surface->decrementViewCount();
+        if (!m_surface->isBeingDisplayed() && window()) {
+            disconnect(window(), nullptr, m_surface, nullptr);
+        }
+        if (m_textureProvider) {
+            m_textureProvider->releaseTexture();
+        }
+    }
+
+    m_surface = surface;
+
+    if (m_surface) {
+        m_surface->incrementViewCount();
+
+        // When a new mir frame gets posted we notify the QML engine that this item needs redrawing,
+        // schedules call to updatePaintNode() from the rendering thread
+        connect(m_surface, &MirSurface::framesPosted, this, &QQuickItem::update);
+
+        connect(m_surface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);
+        connect(m_surface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);
+        connect(m_surface, &MirSurface::sizeChanged, this, &MirSurfaceItem::onActualSurfaceSizeChanged);
+
+        connect(window(), &QQuickWindow::frameSwapped, m_surface, &MirSurface::onCompositorSwappedBuffers,
+            (Qt::ConnectionType) (Qt::DirectConnection | Qt::UniqueConnection));
+
+        Q_EMIT typeChanged(m_surface->type());
+        Q_EMIT liveChanged(true);
+        Q_EMIT surfaceStateChanged(m_surface->state());
+
+        updateMirSurfaceSize();
+        setImplicitSize(m_surface->size().width(), m_surface->size().height());
+
+        if (m_orientationAngle) {
+            m_surface->setOrientationAngle(*m_orientationAngle);
+            connect(m_surface, &MirSurface::orientationAngleChanged, this, &MirSurfaceItem::orientationAngleChanged);
+            delete m_orientationAngle;
+            m_orientationAngle = nullptr;
+        } else {
+            connect(m_surface, &MirSurface::orientationAngleChanged, this, &MirSurfaceItem::orientationAngleChanged);
+            Q_EMIT orientationAngleChanged(m_surface->orientationAngle());
+        }
+    }
+
+    Q_EMIT surfaceChanged(m_surface);
+}
+
+void MirSurfaceItem::releaseResources()
+{
+    if (m_textureProvider) {
+        Q_ASSERT(window());
+
+        MirSurfaceItemReleaseResourcesJob *job = new MirSurfaceItemReleaseResourcesJob;
+        job->textureProvider = m_textureProvider;
+        m_textureProvider = nullptr;
+        window()->scheduleRenderJob(job, QQuickWindow::AfterSynchronizingStage);
+    }
+}
+
+int MirSurfaceItem::surfaceWidth() const
+{
+    return m_surfaceWidth;
+}
+
+void MirSurfaceItem::setSurfaceWidth(int value)
+{
+    if (value != m_surfaceWidth) {
+        m_surfaceWidth = value;
+        scheduleMirSurfaceSizeUpdate();
+        Q_EMIT surfaceWidthChanged(value);
+    }
+}
+
+void MirSurfaceItem::onActualSurfaceSizeChanged(const QSize &size)
+{
+    setImplicitSize(size.width(), size.height());
+}
+
+int MirSurfaceItem::surfaceHeight() const
+{
+    return m_surfaceHeight;
+}
+
+void MirSurfaceItem::setSurfaceHeight(int value)
+{
+    if (value != m_surfaceHeight) {
+        m_surfaceHeight = value;
+        scheduleMirSurfaceSizeUpdate();
+        Q_EMIT surfaceHeightChanged(value);
+    }
+}
+
 } // namespace qtmir
 
 #include "mirsurfaceitem.moc"

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
--- src/modules/Unity/Application/mirsurfaceitem.h	2015-08-12 11:35:49 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.h	2015-08-27 14:51:37 +0000
@@ -21,61 +21,66 @@
 
 // Qt
 #include <QMutex>
-#include <QPointer>
 #include <QTimer>
-#include <QQmlListProperty>
-
-// mir
-#include <mir/scene/surface.h>
-#include <mir_toolkit/common.h>
-
-#include "mirsurfaceiteminterface.h"
+
+// Unity API
+#include <unity/shell/application/MirSurfaceItemInterface.h>
+
+#include "mirsurface.h"
 #include "session_interface.h"
 
-namespace mir { namespace shell { class Shell; }}
+//namespace mir { namespace shell { class Shell; }}
 
 class SurfaceObserver;
-using MirShell = mir::shell::Shell;
+//using MirShell = mir::shell::Shell;
 
 namespace qtmir {
 
 class MirSurfaceManager;
 class QSGMirSurfaceNode;
-class QMirSurfaceTextureProvider;
+class MirTextureProvider;
 
-class MirSurfaceItem : public MirSurfaceItemInterface
+class MirSurfaceItem : public unity::shell::application::MirSurfaceItemInterface
 {
     Q_OBJECT
 
 public:
-    explicit MirSurfaceItem(std::shared_ptr<mir::scene::Surface> surface,
-                            SessionInterface* session,
-                            MirShell *shell,
-                            std::shared_ptr<SurfaceObserver> observer,
-                            QQuickItem *parent = 0);
+    explicit MirSurfaceItem(QQuickItem *parent = 0);
     virtual ~MirSurfaceItem();
 
-    //getters
-    Type type() const override;
-    State state() const override;
+    ////////
+    // MirSurfaceItemInterface
+
+    Mir::Type type() const override;
     QString name() const override;
     bool live() const override;
-    SessionInterface *session() const override;
-    OrientationAngle orientationAngle() const override;
-
-    Q_INVOKABLE void release() override;
-
-    // Item surface/texture management
-    bool isTextureProvider() const { return true; }
-    QSGTextureProvider *textureProvider() const;
-
-    void stopFrameDropper() override;
-    void startFrameDropper() override;
-
-    bool isFirstFrameDrawn() const override { return m_firstFrameDrawn; }
-
-    void setOrientationAngle(OrientationAngle angle) override;
-    void setSession(SessionInterface *app) override;
+
+    Mir::State surfaceState() const override;
+    void setSurfaceState(Mir::State) override;
+
+    Mir::OrientationAngle orientationAngle() const override;
+    void setOrientationAngle(Mir::OrientationAngle angle) override;
+
+    unity::shell::application::MirSurfaceInterface* surface() const override;
+    void setSurface(unity::shell::application::MirSurfaceInterface*) override;
+
+    bool consumesInput() const override;
+    void setConsumesInput(bool value) override;
+
+    int surfaceWidth() const override;
+    void setSurfaceWidth(int value) override;
+
+    int surfaceHeight() const override;
+    void setSurfaceHeight(int value) override;
+
+    ////////
+    // QQuickItem
+
+    bool isTextureProvider() const override { return true; }
+    QSGTextureProvider *textureProvider() const override;
+
+    ////////
+    // own API
 
     // to allow easy touch event injection from tests
     bool processTouchEvent(int eventType,
@@ -84,8 +89,10 @@
             const QList<QTouchEvent::TouchPoint> &touchPoints,
             Qt::TouchPointStates touchPointStates);
 
-protected Q_SLOTS:
-    void onSessionStateChanged(SessionInterface::State state);
+
+public Q_SLOTS:
+    // Called by QQuickWindow from the rendering thread
+    void invalidateSceneGraph();
 
 protected:
     void mousePressEvent(QMouseEvent *event) override;
@@ -103,33 +110,21 @@
 
     QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *);
 
+    void releaseResources() override;
+
 private Q_SLOTS:
-    void surfaceDamaged();
-    void dropPendingBuffer();
-    void scheduleTextureUpdate();
-
     void scheduleMirSurfaceSizeUpdate();
     void updateMirSurfaceSize();
 
     void updateMirSurfaceFocus(bool focused);
-    void onAttributeChanged(const MirSurfaceAttrib, const int);
+
+    void onActualSurfaceSizeChanged(const QSize &size);
 
 private:
-    bool updateTexture();
-    void ensureProvider();
-
-    void setType(const Type&);
-    void setState(const State&);
-    void setLive(bool) override;
-
-    // called by MirSurfaceManager
-    void setSurfaceValid(const bool);
+    void ensureTextureProvider();
 
     bool hasTouchInsideUbuntuKeyboard(const QList<QTouchEvent::TouchPoint> &touchPoints);
     bool isMouseInsideUbuntuKeyboard(const QMouseEvent *event);
-    void syncSurfaceSizeWithItemSize();
-
-    bool clientIsRunning() const;
 
     QString appId() const;
     void endCurrentTouchSequence(ulong timestamp);
@@ -139,22 +134,10 @@
             const QList<QTouchEvent::TouchPoint> &touchPoints,
             Qt::TouchPointStates touchPointStates);
 
+    MirSurface* m_surface;
+
     QMutex m_mutex;
-
-    std::shared_ptr<mir::scene::Surface> m_surface;
-    QPointer<SessionInterface> m_session;
-    MirShell *const m_shell;
-    bool m_firstFrameDrawn;
-    bool m_live;
-
-    //FIXME -  have to save the state as Mir has no getter for it (bug:1357429)
-    OrientationAngle m_orientationAngle;
-
-    QMirSurfaceTextureProvider *m_textureProvider;
-
-    std::shared_ptr<SurfaceObserver> m_surfaceObserver;
-
-    QTimer m_frameDropperTimer;
+    MirTextureProvider *m_textureProvider;
 
     QTimer m_updateMirSurfaceSizeTimer;
 
@@ -177,6 +160,14 @@
         QList<QTouchEvent::TouchPoint> touchPoints;
         Qt::TouchPointStates touchPointStates;
     } *m_lastTouchEvent;
+
+    unsigned int *m_lastFrameNumberRendered;
+
+    int m_surfaceWidth;
+    int m_surfaceHeight;
+    Mir::OrientationAngle *m_orientationAngle;
+
+    bool m_consumesInput;
 };
 
 } // namespace qtmir

=== removed file 'src/modules/Unity/Application/mirsurfaceiteminterface.h'
--- src/modules/Unity/Application/mirsurfaceiteminterface.h	2015-06-15 17:01:28 +0000
+++ src/modules/Unity/Application/mirsurfaceiteminterface.h	1970-01-01 00:00:00 +0000
@@ -1,116 +0,0 @@
-/*
- * 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 MIRSURFACEITEMINTERFACE_H
-#define MIRSURFACEITEMINTERFACE_H
-
-// Qt
-#include <QQuickItem>
-
-// mir
-#include <mir_toolkit/common.h>
-
-#include "session_interface.h"
-
-namespace qtmir {
-
-class MirSurfaceItemInterface : public QQuickItem
-{
-    Q_OBJECT
-    Q_ENUMS(Type)
-    Q_ENUMS(State)
-    Q_ENUMS(OrientationAngle)
-
-    Q_PROPERTY(Type type READ type NOTIFY typeChanged)
-    Q_PROPERTY(State state READ state NOTIFY stateChanged)
-    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
-    Q_PROPERTY(bool live READ live NOTIFY liveChanged)
-
-    // How many degrees, clockwise, the UI in the surface has to rotate to match with the
-    // shell UI orientation
-    Q_PROPERTY(OrientationAngle orientationAngle READ orientationAngle WRITE setOrientationAngle
-               NOTIFY orientationAngleChanged DESIGNABLE false)
-
-public:
-    MirSurfaceItemInterface(QQuickItem *parent) : QQuickItem(parent) {}
-    virtual ~MirSurfaceItemInterface() {}
-
-    enum Type {
-        Normal = mir_surface_type_normal,
-        Utility = mir_surface_type_utility,
-        Dialog = mir_surface_type_dialog,
-        Overlay = mir_surface_type_overlay,
-        Freestyle = mir_surface_type_freestyle,
-        Popover = mir_surface_type_popover,
-        InputMethod = mir_surface_type_inputmethod,
-        };
-
-    enum State {
-        Unknown = mir_surface_state_unknown,
-        Restored = mir_surface_state_restored,
-        Minimized = mir_surface_state_minimized,
-        Maximized = mir_surface_state_maximized,
-        VertMaximized = mir_surface_state_vertmaximized,
-        /* SemiMaximized = mir_surface_state_semimaximized, // see mircommon/mir_toolbox/common.h*/
-        Fullscreen = mir_surface_state_fullscreen,
-    };
-
-    enum OrientationAngle {
-        Angle0 = 0,
-        Angle90 = 90,
-        Angle180 = 180,
-        Angle270 = 270
-    };
-
-    //getters
-    virtual Type type() const = 0;
-    virtual State state() const = 0;
-    virtual QString name() const = 0;
-    virtual bool live() const = 0;
-    virtual SessionInterface *session() const = 0;
-    virtual OrientationAngle orientationAngle() const = 0;
-
-    virtual Q_INVOKABLE void release() = 0;
-
-    virtual void stopFrameDropper() = 0;
-    virtual void startFrameDropper() = 0;
-
-    virtual bool isFirstFrameDrawn() const = 0;
-
-    virtual void setOrientationAngle(OrientationAngle angle) = 0;
-    virtual void setSession(SessionInterface *app) = 0;
-
-Q_SIGNALS:
-    void typeChanged();
-    void stateChanged();
-    void nameChanged();
-    void orientationAngleChanged(OrientationAngle angle);
-    void liveChanged(bool live);
-    void firstFrameDrawn();
-
-private:
-    virtual void setLive(bool) = 0;
-
-    friend class MirSurfaceManager;
-};
-
-} // namespace qtmir
-
-Q_DECLARE_METATYPE(qtmir::MirSurfaceItemInterface*)
-Q_DECLARE_METATYPE(qtmir::MirSurfaceItemInterface::OrientationAngle)
-
-#endif // MIRSURFACEITEMINTERFACE_H
-

=== removed file 'src/modules/Unity/Application/mirsurfaceitemmodel.h'
--- src/modules/Unity/Application/mirsurfaceitemmodel.h	2015-05-27 21:07:45 +0000
+++ src/modules/Unity/Application/mirsurfaceitemmodel.h	1970-01-01 00:00:00 +0000
@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 2014 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 MIRSURFACEITEMMODEL_H
-#define MIRSURFACEITEMMODEL_H
-
-// Local
-#include "objectlistmodel.h"
-
-namespace qtmir {
-
-class MirSurfaceItemInterface;
-typedef ObjectListModel<MirSurfaceItemInterface> MirSurfaceItemModel;
-
-} // namespace qtmir
-
-Q_DECLARE_METATYPE(qtmir::MirSurfaceItemModel*)
-
-#endif // MIRSURFACEITEMMODEL_H

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2015-08-11 12:08:32 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2015-08-27 14:51:37 +0000
@@ -14,12 +14,14 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "mirsurfacemanager.h"
+
 // Qt
 #include <QGuiApplication>
 #include <QMutexLocker>
 
 // local
-#include "mirsurfacemanager.h"
+#include "mirsurface.h"
 #include "sessionmanager.h"
 #include "application_manager.h"
 #include "tracepoints.h" // generated from tracepoints.tp
@@ -39,7 +41,7 @@
 
 namespace qtmir {
 
-MirSurfaceManager *MirSurfaceManager::the_surface_manager = nullptr;
+MirSurfaceManager *MirSurfaceManager::instance = nullptr;
 
 
 void connectToSessionListener(MirSurfaceManager *manager, SessionListener *listener)
@@ -52,7 +54,7 @@
 
 MirSurfaceManager* MirSurfaceManager::singleton()
 {
-    if (!the_surface_manager) {
+    if (!instance) {
 
         NativeInterface *nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
 
@@ -65,11 +67,11 @@
         SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
         MirShell *shell = static_cast<MirShell*>(nativeInterface->nativeResourceForIntegration("Shell"));
 
-        the_surface_manager = new MirSurfaceManager(nativeInterface->m_mirServer, shell, SessionManager::singleton());
+        instance = new MirSurfaceManager(nativeInterface->m_mirServer, shell, SessionManager::singleton());
 
-        connectToSessionListener(the_surface_manager, sessionListener);
+        connectToSessionListener(instance, sessionListener);
     }
-    return the_surface_manager;
+    return instance;
 }
 
 MirSurfaceManager::MirSurfaceManager(
@@ -77,7 +79,7 @@
         MirShell *shell,
         SessionManager* sessionManager,
         QObject *parent)
-    : MirSurfaceItemModel(parent)
+    : QObject(parent)
     , m_mirServer(mirServer)
     , m_shell(shell)
     , m_sessionManager(sessionManager)
@@ -90,7 +92,7 @@
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::~MirSurfaceManager - this=" << this;
 
-    m_mirSurfaceToItemHash.clear();
+    m_mirSurfaceToQmlSurfaceHash.clear();
 }
 
 void MirSurfaceManager::onSessionCreatedSurface(const mir::scene::Session *mirSession,
@@ -101,32 +103,29 @@
                             << "surface=" << surface.get() << "surface.name=" << surface->name().c_str();
 
     SessionInterface* session = m_sessionManager->findSession(mirSession);
-    auto qmlSurface = new MirSurfaceItem(surface, session, m_shell, observer);
+    auto qmlSurface = new MirSurface(surface, session, m_shell, observer);
     {
         QMutexLocker lock(&m_mutex);
-        m_mirSurfaceToItemHash.insert(surface.get(), qmlSurface);
+        m_mirSurfaceToQmlSurfaceHash.insert(surface.get(), qmlSurface);
     }
 
     if (session)
         session->setSurface(qmlSurface);
 
     // Only notify QML of surface creation once it has drawn its first frame.
-    connect(qmlSurface, &MirSurfaceItemInterface::firstFrameDrawn, this, [=]() {
+    connect(qmlSurface, &MirSurfaceInterface::firstFrameDrawn, this, [=]() {
         tracepoint(qtmir, firstFrameDrawn);
         Q_EMIT surfaceCreated(qmlSurface);
-
-        insert(0, qmlSurface);
     });
 
-    // clean up after MirSurfaceItem is destroyed
-    connect(qmlSurface, &MirSurfaceItem::destroyed, this, [&](QObject *item) {
-        auto mirSurfaceItem = static_cast<MirSurfaceItem*>(item);
+    // clean up after MirSurface is destroyed
+    connect(qmlSurface, &QObject::destroyed, this, [&](QObject *obj) {
+        auto qmlSurface = static_cast<MirSurfaceInterface*>(obj);
         {
             QMutexLocker lock(&m_mutex);
-            m_mirSurfaceToItemHash.remove(m_mirSurfaceToItemHash.key(mirSurfaceItem));
+            m_mirSurfaceToQmlSurfaceHash.remove(m_mirSurfaceToQmlSurfaceHash.key(qmlSurface));
         }
 
-        remove(mirSurfaceItem);
         tracepoint(qtmir, surfaceDestroyed);
     });
     tracepoint(qtmir, surfaceCreated);
@@ -138,25 +137,24 @@
     qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::onSessionDestroyingSurface - session=" << session
                             << "surface=" << surface.get() << "surface.name=" << surface->name().c_str();
 
-    MirSurfaceItemInterface* item = nullptr;
+    MirSurfaceInterface* qmlSurface = nullptr;
     {
         QMutexLocker lock(&m_mutex);
-        auto it = m_mirSurfaceToItemHash.find(surface.get());
-        if (it != m_mirSurfaceToItemHash.end()) {
-
-            item = it.value();
-
-            m_mirSurfaceToItemHash.remove(m_mirSurfaceToItemHash.key(item));
+        auto it = m_mirSurfaceToQmlSurfaceHash.find(surface.get());
+        if (it != m_mirSurfaceToQmlSurfaceHash.end()) {
+
+            qmlSurface = it.value();
+
+            m_mirSurfaceToQmlSurfaceHash.remove(m_mirSurfaceToQmlSurfaceHash.key(qmlSurface));
         } else {
-            qCritical() << "MirSurfaceManager::onSessionDestroyingSurface: unable to find MirSurfaceItem corresponding"
+            qCritical() << "MirSurfaceManager::onSessionDestroyingSurface: unable to find MirSurface corresponding"
                         << "to surface=" << surface.get() << "surface.name=" << surface->name().c_str();
             return;
         }
     }
 
-    item->setEnabled(false); //disable input events
-    item->setLive(false); //disable input events
-    Q_EMIT surfaceDestroyed(item);
+    qmlSurface->setLive(false);
+    Q_EMIT surfaceDestroyed(qmlSurface);
 }
 
 } // namespace qtmir

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.h'
--- src/modules/Unity/Application/mirsurfacemanager.h	2015-08-11 12:08:32 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.h	2015-08-27 14:51:37 +0000
@@ -21,15 +21,16 @@
 #include <memory>
 
 // Qt
+#include <QObject>
 #include <QHash>
 #include <QMutex>
+#include <QSharedPointer>
 
 // Mir
 #include <mir_toolkit/common.h>
 
 // local
-#include "mirsurfaceitem.h"
-#include "mirsurfaceitemmodel.h"
+#include <mirserver.h>
 
 namespace mir {
     namespace scene {
@@ -40,14 +41,16 @@
 }
 
 class MirServer;
+class SurfaceObserver;
 
 namespace qtmir {
 
 class Application;
 class ApplicationManager;
+class MirSurfaceInterface;
 class SessionManager;