Merge lp:~attente/gtk/gtk-mir into lp:~ubuntu-desktop/gtk/ubuntugtk3

[William Hua]

  * debian/control:
  * debian/control.in:
    - Build depend on libcontent-hub-glib-dev
  * debian/patches/series:
  * debian/patches/0001-mir-implement-window-properties.patch:
  * debian/patches/0002-mir-track-focused-window.patch:
  * debian/patches/0003-mir-connect-to-content-hub.patch:
  * debian/patches/0004-mir-copy-clipboard-data-to-content-hub.patch:
  * debian/patches/0005-mir-paste-clipboard-data-from-content-hub.patch:
  * debian/patches/0006-mir-properly-handle-empty-clipboard.patch:
  * debian/patches/0031-mir-fix-compile-time-warnings.patch:
  * debian/patches/0032-mir-use-modal-window-hint.patch:
  * debian/patches/0036-mir-use-mir_surface_spec_set_placement-for-menus.patch:
  * debian/patches/0037-mir-handle-surface-placement-events.patch:
    - Add upstream patches from gtk-3-22 branch

Apply upstream patches from gtk-3-22 branch:

  * debian/control:
  * debian/control.in:
    - Build depend on libcontent-hub-glib-dev
  * debian/patches/series:
  * debian/patches/0001-mir-implement-window-properties.patch:
  * debian/patches/0002-mir-track-focused-window.patch:
  * debian/patches/0003-mir-connect-to-content-hub.patch:
  * debian/patches/0004-mir-copy-clipboard-data-to-content-hub.patch:
  * debian/patches/0005-mir-paste-clipboard-data-from-content-hub.patch:
  * debian/patches/0006-mir-properly-handle-empty-clipboard.patch:
  * debian/patches/0031-mir-fix-compile-time-warnings.patch:
  * debian/patches/0032-mir-use-modal-window-hint.patch:
  * debian/patches/0036-mir-use-mir_surface_spec_set_placement-for-menus.patch:
  * debian/patches/0037-mir-handle-surface-placement-events.patch:
    - Add upstream patches from gtk-3-22 branch

[Jeremy Bicha (jbicha)]

Thanks!

review: Approve

[lp:~attente/gtk/gtk-mir]

544. By William Hua on 2017-02-08

* debian/control:
* debian/control.in:
  - Build depend on libcontent-hub-glib-dev
* debian/patches/series:
* debian/patches/0001-mir-implement-window-properties.patch:
* debian/patches/0002-mir-track-focused-window.patch:
* debian/patches/0003-mir-connect-to-content-hub.patch:
* debian/patches/0004-mir-copy-clipboard-data-to-content-hub.patch:
* debian/patches/0005-mir-paste-clipboard-data-from-content-hub.patch:
* debian/patches/0006-mir-properly-handle-empty-clipboard.patch:
* debian/patches/0031-mir-fix-compile-time-warnings.patch:
* debian/patches/0032-mir-use-modal-window-hint.patch:
* debian/patches/0036-mir-use-mir_surface_spec_set_placement-for-menus.patch:
* debian/patches/0037-mir-handle-surface-placement-events.patch:
  - Add upstream patches from gtk-3-22 branch

=== modified file 'debian/changelog'
--- debian/changelog	2017-01-23 14:44:32 +0000
+++ debian/changelog	2017-02-08 17:37:49 +0000
@@ -1,3 +1,23 @@
+gtk+3.0 (3.22.7-1ubuntu3) zesty; urgency=medium
+
+  * debian/control:
+  * debian/control.in:
+    - Build depend on libcontent-hub-glib-dev
+  * debian/patches/series:
+  * debian/patches/0001-mir-implement-window-properties.patch:
+  * debian/patches/0002-mir-track-focused-window.patch:
+  * debian/patches/0003-mir-connect-to-content-hub.patch:
+  * debian/patches/0004-mir-copy-clipboard-data-to-content-hub.patch:
+  * debian/patches/0005-mir-paste-clipboard-data-from-content-hub.patch:
+  * debian/patches/0006-mir-properly-handle-empty-clipboard.patch:
+  * debian/patches/0031-mir-fix-compile-time-warnings.patch:
+  * debian/patches/0032-mir-use-modal-window-hint.patch:
+  * debian/patches/0036-mir-use-mir_surface_spec_set_placement-for-menus.patch:
+  * debian/patches/0037-mir-handle-surface-placement-events.patch:
+    - Add upstream patches from gtk-3-22 branch
+
+ -- William Hua <[e-mail]>  Wed, 08 Feb 2017 10:27:45 -0500
+
 gtk+3.0 (3.22.7-1ubuntu2) zesty; urgency=medium
 
   * Restore gtksocket-unscale-before-sending-configurenotify.patch:

=== modified file 'debian/control'
--- debian/control	2016-10-24 16:41:31 +0000
+++ debian/control	2017-02-08 17:37:49 +0000
@@ -52,7 +52,8 @@
                xsltproc,
                xvfb <!nocheck>,
                libmirclient-dev (>= 0.13.3),
-               libmircookie-dev (>= 0.17.0)
+               libmircookie-dev (>= 0.17.0),
+               libcontent-hub-glib-dev,
 Build-Depends-Indep: libglib2.0-doc,
                      libatk1.0-doc,
                      libpango1.0-doc,

=== modified file 'debian/control.in'
--- debian/control.in	2016-10-24 16:41:31 +0000
+++ debian/control.in	2017-02-08 17:37:49 +0000
@@ -52,7 +52,8 @@
                xsltproc,
                xvfb <!nocheck>,
                libmirclient-dev (>= 0.13.3),
-               libmircookie-dev (>= 0.17.0)
+               libmircookie-dev (>= 0.17.0),
+               libcontent-hub-glib-dev,
 Build-Depends-Indep: libglib2.0-doc,
                      libatk1.0-doc,
                      libpango1.0-doc,

=== added file 'debian/patches/0001-mir-implement-window-properties.patch'
--- debian/patches/0001-mir-implement-window-properties.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0001-mir-implement-window-properties.patch	2017-02-08 17:37:49 +0000
@@ -0,0 +1,244 @@
+From b6baa088dccecb25130d056f33d8078d198dd2d7 Mon Sep 17 00:00:00 2001
+From: William Hua <[e-mail]>
+Date: Tue, 11 Oct 2016 19:06:12 -0400
+Subject: [PATCH 01/38] mir: implement window properties
+
+https://bugzilla.gnome.org/show_bug.cgi?id=775732
+---
+ gdk/mir/gdkmirwindowimpl.c | 179 +++++++++++++++++++++++++++++++++++++++++----
+ 1 file changed, 163 insertions(+), 16 deletions(-)
+
+diff --git a/gdk/mir/gdkmirwindowimpl.c b/gdk/mir/gdkmirwindowimpl.c
+index a7be39c..48e66ca 100644
+--- a/gdk/mir/gdkmirwindowimpl.c
++++ b/gdk/mir/gdkmirwindowimpl.c
+@@ -36,12 +36,45 @@
+ 
+ #define MAX_EGL_ATTRS 30
+ 
++typedef struct
++{
++  GdkAtom type;
++  GArray *array;
++} GdkMirProperty;
++
++static GdkMirProperty *
++gdk_mir_property_new (GdkAtom type,
++                      guint   format,
++                      guint   capacity)
++{
++  GdkMirProperty *property = g_slice_new (GdkMirProperty);
++
++  property->type = type;
++  property->array = g_array_sized_new (TRUE, FALSE, format, capacity);
++
++  return property;
++}
++
++static void
++gdk_mir_property_free (gpointer data)
++{
++  GdkMirProperty *property = data;
++
++  if (!property)
++    return;
++
++  g_array_unref (property->array);
++  g_slice_free (GdkMirProperty, property);
++}
++
+ typedef struct _GdkMirWindowImplClass GdkMirWindowImplClass;
+ 
+ struct _GdkMirWindowImpl
+ {
+   GdkWindowImpl parent_instance;
+ 
++  GHashTable *properties;
++
+   /* Window we are temporary for */
+   GdkWindow *transient_for;
+   gint transient_x;
+@@ -233,6 +266,7 @@ _gdk_mir_window_impl_get_cursor_state (GdkMirWindowImpl *impl,
+ static void
+ gdk_mir_window_impl_init (GdkMirWindowImpl *impl)
+ {
++  impl->properties = g_hash_table_new_full (NULL, NULL, NULL, gdk_mir_property_free);
+   impl->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
+   impl->surface_state = mir_surface_state_unknown;
+   impl->output_scale = 1;
+@@ -687,6 +721,8 @@ gdk_mir_window_impl_finalize (GObject *object)
+   if (impl->cairo_surface)
+     cairo_surface_destroy (impl->cairo_surface);
+ 
++  g_clear_pointer (&impl->properties, g_hash_table_unref);
++
+   G_OBJECT_CLASS (gdk_mir_window_impl_parent_class)->finalize (object);
+ }
+ 
+@@ -1482,19 +1518,79 @@ gdk_mir_window_impl_simulate_button (GdkWindow       *window,
+ }
+ 
+ static gboolean
+-gdk_mir_window_impl_get_property (GdkWindow   *window,
+-                                  GdkAtom      property,
+-                                  GdkAtom      type,
+-                                  gulong       offset,
+-                                  gulong       length,
+-                                  gint         pdelete,
+-                                  GdkAtom     *actual_property_type,
+-                                  gint        *actual_format_type,
+-                                  gint        *actual_length,
+-                                  guchar     **data)
+-{
+-  //g_printerr ("gdk_mir_window_impl_get_property window=%p\n", window);
+-  return FALSE;
++gdk_mir_window_impl_get_property (GdkWindow  *window,
++                                  GdkAtom     property,
++                                  GdkAtom     type,
++                                  gulong      offset,
++                                  gulong      length,
++                                  gint        pdelete,
++                                  GdkAtom    *actual_type,
++                                  gint       *actual_format,
++                                  gint       *actual_length,
++                                  guchar    **data)
++{
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++  GdkMirProperty *mir_property;
++  GdkAtom dummy_actual_type;
++  gint dummy_actual_format;
++  gint dummy_actual_length;
++  guint width;
++
++  if (!actual_type)
++    actual_type = &dummy_actual_type;
++  if (!actual_format)
++    actual_format = &dummy_actual_format;
++  if (!actual_length)
++    actual_length = &dummy_actual_length;
++
++  *actual_type = GDK_NONE;
++  *actual_format = 0;
++  *actual_length = 0;
++
++  if (data)
++    *data = NULL;
++
++  mir_property = g_hash_table_lookup (impl->properties, property);
++
++  if (!mir_property)
++    return FALSE;
++
++  width = g_array_get_element_size (mir_property->array);
++  *actual_type = mir_property->type;
++  *actual_format = 8 * width;
++
++  /* ICCCM 2.7: GdkAtoms can be 64-bit, but ATOMs and ATOM_PAIRs have format 32  */
++  if (*actual_type == GDK_SELECTION_TYPE_ATOM || *actual_type == gdk_atom_intern_static_string ("ATOM_PAIR"))
++    *actual_format = 32;
++
++  if (type != GDK_NONE && type != mir_property->type)
++    return FALSE;
++
++  offset *= 4;
++
++  /* round up to next nearest multiple of width */
++  if (length < G_MAXULONG - width + 1)
++    length = (length - 1 + width) / width * width;
++  else
++    length = G_MAXULONG / width * width;
++
++  /* we're skipping the first offset bytes */
++  if (length > mir_property->array->len * width - offset)
++    length = mir_property->array->len * width - offset;
++
++  /* leave room for null terminator */
++  if (length > G_MAXULONG - width)
++    length -= width;
++
++  *actual_length = length;
++
++  if (data)
++    {
++      *data = g_memdup (mir_property->array->data + offset, length + width);
++      memset (*data + length, 0, width);
++    }
++
++  return TRUE;
+ }
+ 
+ static void
+@@ -1504,16 +1600,67 @@ gdk_mir_window_impl_change_property (GdkWindow    *window,
+                                      gint          format,
+                                      GdkPropMode   mode,
+                                      const guchar *data,
+-                                     gint          nelements)
++                                     gint          n_elements)
+ {
+-  //g_printerr ("gdk_mir_window_impl_change_property window=%p\n", window);
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++  GdkMirProperty *mir_property;
++  GdkEvent *event;
++
++  /* ICCCM 2.7: ATOMs and ATOM_PAIRs have format 32, but GdkAtoms can be 64-bit */
++  if (type == GDK_SELECTION_TYPE_ATOM || type == gdk_atom_intern_static_string ("ATOM_PAIR"))
++    format = 8 * sizeof (GdkAtom);
++
++  if (mode != GDK_PROP_MODE_REPLACE)
++    mir_property = g_hash_table_lookup (impl->properties, property);
++  else
++    mir_property = NULL;
++
++  if (!mir_property)
++    {
++      /* format is measured in bits, but we need to know this in bytes */
++      mir_property = gdk_mir_property_new (type, format / 8, n_elements);
++      g_hash_table_insert (impl->properties, property, mir_property);
++    }
++
++  /* format is measured in bits, but we need to know this in bytes */
++  if (type != mir_property->type || format / 8 != g_array_get_element_size (mir_property->array))
++    return;
++
++  if (mode == GDK_PROP_MODE_PREPEND)
++    g_array_prepend_vals (mir_property->array, data, n_elements);
++  else
++    g_array_append_vals (mir_property->array, data, n_elements);
++
++  event = gdk_event_new (GDK_PROPERTY_NOTIFY);
++  event->property.window = g_object_ref (window);
++  event->property.send_event = FALSE;
++  event->property.atom = property;
++  event->property.time = GDK_CURRENT_TIME;
++  event->property.state = GDK_PROPERTY_NEW_VALUE;
++
++  gdk_event_put (event);
++  gdk_event_free (event);
+ }
+ 
+ static void
+ gdk_mir_window_impl_delete_property (GdkWindow *window,
+                                      GdkAtom    property)
+ {
+-  //g_printerr ("gdk_mir_window_impl_delete_property window=%p\n", window);
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++  GdkEvent *event;
++
++  if (g_hash_table_remove (impl->properties, property))
++    {
++      event = gdk_event_new (GDK_PROPERTY_NOTIFY);
++      event->property.window = g_object_ref (window);
++      event->property.send_event = FALSE;
++      event->property.atom = property;
++      event->property.time = GDK_CURRENT_TIME;
++      event->property.state = GDK_PROPERTY_DELETE;
++
++      gdk_event_put (event);
++      gdk_event_free (event);
++    }
+ }
+ 
+ static gint
+-- 
+2.10.2
+

=== added file 'debian/patches/0002-mir-track-focused-window.patch'
--- debian/patches/0002-mir-track-focused-window.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0002-mir-track-focused-window.patch	2017-02-08 17:37:49 +0000
@@ -0,0 +1,91 @@
+From 0acb58b40fbc158f94486195e35088f610071583 Mon Sep 17 00:00:00 2001
+From: William Hua <[e-mail]>
+Date: Fri, 14 Oct 2016 17:00:34 -0400
+Subject: [PATCH 02/38] mir: track focused window
+
+https://bugzilla.gnome.org/show_bug.cgi?id=775732
+---
+ gdk/mir/gdkmir-private.h    |  4 ++++
+ gdk/mir/gdkmirdisplay.c     | 21 +++++++++++++++++++++
+ gdk/mir/gdkmireventsource.c | 10 ++++++++--
+ 3 files changed, 33 insertions(+), 2 deletions(-)
+
+diff --git a/gdk/mir/gdkmir-private.h b/gdk/mir/gdkmir-private.h
+index 38f1d7a..7e3893c 100644
+--- a/gdk/mir/gdkmir-private.h
++++ b/gdk/mir/gdkmir-private.h
+@@ -107,6 +107,10 @@ void _gdk_mir_event_source_queue (GdkMirWindowReference *window_ref, const MirEv
+ 
+ MirPixelFormat _gdk_mir_display_get_pixel_format (GdkDisplay *display, MirBufferUsage usage);
+ 
++void _gdk_mir_display_focus_window (GdkDisplay *display, GdkWindow *window);
++
++void _gdk_mir_display_unfocus_window (GdkDisplay *display, GdkWindow *window);
++
+ gboolean _gdk_mir_display_init_egl_display (GdkDisplay *display);
+ 
+ EGLDisplay _gdk_mir_display_get_egl_display (GdkDisplay *display);
+diff --git a/gdk/mir/gdkmirdisplay.c b/gdk/mir/gdkmirdisplay.c
+index eea892c..89cfad2 100644
+--- a/gdk/mir/gdkmirdisplay.c
++++ b/gdk/mir/gdkmirdisplay.c
+@@ -47,6 +47,8 @@ typedef struct GdkMirDisplay
+ 
+   GdkKeymap *keymap;
+ 
++  GdkWindow *focused_window;
++
+   MirPixelFormat sw_pixel_format;
+   MirPixelFormat hw_pixel_format;
+ 
+@@ -582,6 +584,25 @@ _gdk_mir_display_get_pixel_format (GdkDisplay *display,
+   return mir_dpy->sw_pixel_format;
+ }
+ 
++void
++_gdk_mir_display_focus_window (GdkDisplay *display,
++                               GdkWindow  *window)
++{
++  GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
++
++  g_set_object (&mir_display->focused_window, window);
++}
++
++void
++_gdk_mir_display_unfocus_window (GdkDisplay *display,
++                                 GdkWindow  *window)
++{
++  GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
++
++  if (window == mir_display->focused_window)
++    g_clear_object (&mir_display->focused_window);
++}
++
+ gboolean
+ _gdk_mir_display_init_egl_display (GdkDisplay *display)
+ {
+diff --git a/gdk/mir/gdkmireventsource.c b/gdk/mir/gdkmireventsource.c
+index 8c7e106..a2a1a12 100644
+--- a/gdk/mir/gdkmireventsource.c
++++ b/gdk/mir/gdkmireventsource.c
+@@ -240,9 +240,15 @@ generate_focus_event (GdkWindow *window, gboolean focused)
+   GdkEvent *event;
+ 
+   if (focused)
+-    gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_FOCUSED);
++    {
++      gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_FOCUSED);
++      _gdk_mir_display_focus_window (gdk_window_get_display (window), window);
++    }
+   else
+-    gdk_synthesize_window_state (window, GDK_WINDOW_STATE_FOCUSED, 0);
++    {
++      gdk_synthesize_window_state (window, GDK_WINDOW_STATE_FOCUSED, 0);
++      _gdk_mir_display_unfocus_window (gdk_window_get_display (window), window);
++    }
+ 
+   event = gdk_event_new (GDK_FOCUS_CHANGE);
+   event->focus_change.send_event = FALSE;
+-- 
+2.10.2
+

=== added file 'debian/patches/0003-mir-connect-to-content-hub.patch'
--- debian/patches/0003-mir-connect-to-content-hub.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0003-mir-connect-to-content-hub.patch	2017-02-08 17:37:49 +0000
@@ -0,0 +1,108 @@
+From 210d1279e5811ae18b0bad13f16a97c7ec98598e Mon Sep 17 00:00:00 2001
+From: William Hua <[e-mail]>
+Date: Tue, 11 Oct 2016 16:53:48 -0400
+Subject: [PATCH 03/38] mir: connect to content-hub
+
+https://bugzilla.gnome.org/show_bug.cgi?id=775732
+---
+ configure.ac            |  2 +-
+ gdk/mir/gdkmirdisplay.c | 42 ++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 43 insertions(+), 1 deletion(-)
+
+diff --git a/configure.ac b/configure.ac
+index ea609b3..000e37a 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -464,7 +464,7 @@ else
+   AM_CONDITIONAL(USE_WAYLAND, false)
+ fi
+ 
+-MIR_DEPENDENCIES="mirclient >= mirclient_required_version mircookie >= mircookie_required_version"
++MIR_DEPENDENCIES="mirclient >= mirclient_required_version mircookie >= mircookie_required_version libcontent-hub-glib"
+ if test "$enable_mir_backend" = "maybe" ; then
+   PKG_CHECK_EXISTS($MIR_DEPENDENCIES, [have_mir_deps=yes], [have_mir_deps=no])
+   AC_MSG_CHECKING([for MIR_DEPENDENCIES])
+diff --git a/gdk/mir/gdkmirdisplay.c b/gdk/mir/gdkmirdisplay.c
+index 89cfad2..718ab60 100644
+--- a/gdk/mir/gdkmirdisplay.c
++++ b/gdk/mir/gdkmirdisplay.c
+@@ -23,6 +23,8 @@
+ #include "gdkmir.h"
+ #include "gdkmir-private.h"
+ 
++#include <com/ubuntu/content/glib/content-hub-glib.h>
++
+ #define GDK_TYPE_DISPLAY_MIR              (gdk_mir_display_get_type ())
+ #define GDK_MIR_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_MIR, GdkMirDisplay))
+ #define GDK_MIR_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DISPLAY_MIR, GdkMirDisplayClass))
+@@ -57,6 +59,9 @@ typedef struct GdkMirDisplay
+   guint have_egl_buffer_age : 1;
+   guint have_egl_swap_buffers_with_damage : 1;
+   guint have_egl_surfaceless_context : 1;
++
++  ContentHubService *content_service;
++  ContentHubHandler *content_handler;
+ } GdkMirDisplay;
+ 
+ typedef struct GdkMirDisplayClass
+@@ -108,6 +113,7 @@ _gdk_mir_display_open (const gchar *display_name)
+   MirConnection *connection;
+   MirPixelFormat sw_pixel_format, hw_pixel_format;
+   GdkMirDisplay *display;
++  GDBusConnection *session;
+ 
+   //g_printerr ("gdk_mir_display_open\n");
+ 
+@@ -140,6 +146,39 @@ _gdk_mir_display_open (const gchar *display_name)
+   display->sw_pixel_format = sw_pixel_format;
+   display->hw_pixel_format = hw_pixel_format;
+ 
++  session = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
++
++  display->content_service = content_hub_service_proxy_new_sync (
++    session,
++    G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
++    "com.ubuntu.content.dbus.Service",
++    "/",
++    NULL,
++    NULL);
++
++  display->content_handler = content_hub_handler_skeleton_new ();
++
++  g_dbus_interface_skeleton_export (
++    G_DBUS_INTERFACE_SKELETON (display->content_handler),
++    session,
++    "/org/gnome/gtk/content/handler",
++    NULL);
++
++  g_object_unref (session);
++
++  content_hub_service_call_register_import_export_handler_sync (
++    display->content_service,
++    g_application_get_application_id (g_application_get_default ()),
++    "/org/gnome/gtk/content/handler",
++    NULL,
++    NULL);
++
++  content_hub_service_call_handler_active_sync (
++    display->content_service,
++    g_application_get_application_id (g_application_get_default ()),
++    NULL,
++    NULL);
++
+   g_signal_emit_by_name (display, "opened");
+ 
+   return GDK_DISPLAY (display);
+@@ -175,6 +214,9 @@ gdk_mir_display_dispose (GObject *object)
+ {
+   GdkMirDisplay *display = GDK_MIR_DISPLAY (object);
+ 
++  g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (display->content_handler));
++  g_clear_object (&display->content_handler);
++  g_clear_object (&display->content_service);
+   g_clear_object (&display->screen);
+   g_clear_object (&display->keymap);
+   g_clear_pointer (&display->event_source, g_source_unref);
+-- 
+2.10.2
+

=== added file 'debian/patches/0004-mir-copy-clipboard-data-to-content-hub.patch'
--- debian/patches/0004-mir-copy-clipboard-data-to-content-hub.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0004-mir-copy-clipboard-data-to-content-hub.patch	2017-02-08 17:37:49 +0000
@@ -0,0 +1,292 @@
+From 5c4c3f1afd9a56644c1d204df3a9f5f1526ffa38 Mon Sep 17 00:00:00 2001
+From: William Hua <[e-mail]>
+Date: Wed, 12 Oct 2016 16:56:01 -0400
+Subject: [PATCH 04/38] mir: copy clipboard data to content-hub
+
+https://bugzilla.gnome.org/show_bug.cgi?id=775732
+---
+ gdk/mir/gdkmir-private.h   |   5 ++
+ gdk/mir/gdkmirdisplay.c    |  60 +++++++++++++++++-
+ gdk/mir/gdkmirwindowimpl.c | 150 ++++++++++++++++++++++++++++++++++++++++++++-
+ 3 files changed, 212 insertions(+), 3 deletions(-)
+
+diff --git a/gdk/mir/gdkmir-private.h b/gdk/mir/gdkmir-private.h
+index 7e3893c..a677dec 100644
+--- a/gdk/mir/gdkmir-private.h
++++ b/gdk/mir/gdkmir-private.h
+@@ -111,6 +111,11 @@ void _gdk_mir_display_focus_window (GdkDisplay *display, GdkWindow *window);
+ 
+ void _gdk_mir_display_unfocus_window (GdkDisplay *display, GdkWindow *window);
+ 
++void _gdk_mir_display_create_paste (GdkDisplay          *display,
++                                    const gchar * const *paste_formats,
++                                    gconstpointer        paste_data,
++                                    gsize                paste_size);
++
+ gboolean _gdk_mir_display_init_egl_display (GdkDisplay *display);
+ 
+ EGLDisplay _gdk_mir_display_get_egl_display (GdkDisplay *display);
+diff --git a/gdk/mir/gdkmirdisplay.c b/gdk/mir/gdkmirdisplay.c
+index 718ab60..3dd3798 100644
+--- a/gdk/mir/gdkmirdisplay.c
++++ b/gdk/mir/gdkmirdisplay.c
+@@ -504,7 +504,28 @@ gdk_mir_display_set_selection_owner (GdkDisplay *display,
+                                      guint32     time,
+                                      gboolean    send_event)
+ {
+-  //g_printerr ("gdk_mir_display_set_selection_owner\n");
++  GdkEvent *event;
++
++  if (selection == GDK_SELECTION_CLIPBOARD)
++    {
++      if (owner)
++        {
++          event = gdk_event_new (GDK_SELECTION_REQUEST);
++          event->selection.window = g_object_ref (owner);
++          event->selection.send_event = FALSE;
++          event->selection.selection = selection;
++          event->selection.target = gdk_atom_intern_static_string ("TARGETS");
++          event->selection.property = gdk_atom_intern_static_string ("AVAILABLE_TARGETS");
++          event->selection.time = GDK_CURRENT_TIME;
++          event->selection.requestor = g_object_ref (owner);
++
++          gdk_event_put (event);
++          gdk_event_free (event);
++
++          return TRUE;
++        }
++    }
++
+   return FALSE;
+ }
+ 
+@@ -645,6 +666,43 @@ _gdk_mir_display_unfocus_window (GdkDisplay *display,
+     g_clear_object (&mir_display->focused_window);
+ }
+ 
++void
++_gdk_mir_display_create_paste (GdkDisplay          *display,
++                               const gchar * const *paste_formats,
++                               gconstpointer        paste_data,
++                               gsize                paste_size)
++{
++  GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
++  MirSurface *surface;
++  MirPersistentId *persistent_id;
++
++  if (!mir_display->focused_window)
++    return;
++
++  surface = gdk_mir_window_get_mir_surface (mir_display->focused_window);
++
++  if (!surface)
++    return;
++
++  persistent_id = mir_surface_request_persistent_id_sync (surface);
++
++  if (!persistent_id)
++    return;
++
++  if (mir_persistent_id_is_valid (persistent_id))
++    content_hub_service_call_create_paste_sync (
++      mir_display->content_service,
++      g_application_get_application_id (g_application_get_default ()),
++      mir_persistent_id_as_string (persistent_id),
++      g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, paste_data, paste_size, sizeof (guchar)),
++      paste_formats,
++      NULL,
++      NULL,
++      NULL);
++
++  mir_persistent_id_release (persistent_id);
++}
++
+ gboolean
+ _gdk_mir_display_init_egl_display (GdkDisplay *display)
+ {
+diff --git a/gdk/mir/gdkmirwindowimpl.c b/gdk/mir/gdkmirwindowimpl.c
+index 48e66ca..8a15816 100644
+--- a/gdk/mir/gdkmirwindowimpl.c
++++ b/gdk/mir/gdkmirwindowimpl.c
+@@ -1594,6 +1594,140 @@ gdk_mir_window_impl_get_property (GdkWindow  *window,
+ }
+ 
+ static void
++request_targets (GdkWindow     *window,
++                 const GdkAtom *available_targets,
++                 gint           n_available_targets)
++{
++  GArray *requested_targets;
++  GdkAtom target_pair[2];
++  gchar *target_location;
++  GdkEvent *event;
++  gint i;
++
++  requested_targets = g_array_sized_new (TRUE, FALSE, sizeof (GdkAtom), 2 * n_available_targets);
++
++  for (i = 0; i < n_available_targets; i++)
++    {
++      target_pair[0] = available_targets[i];
++
++      if (target_pair[0] == gdk_atom_intern_static_string ("TIMESTAMP") ||
++          target_pair[0] == gdk_atom_intern_static_string ("TARGETS") ||
++          target_pair[0] == gdk_atom_intern_static_string ("MULTIPLE") ||
++          target_pair[0] == gdk_atom_intern_static_string ("SAVE_TARGETS"))
++        continue;
++
++      target_location = g_strdup_printf ("REQUESTED_TARGET_U%u", requested_targets->len / 2);
++      target_pair[1] = gdk_atom_intern (target_location, FALSE);
++      g_free (target_location);
++
++      g_array_append_vals (requested_targets, target_pair, 2);
++    }
++
++  gdk_property_delete (window, gdk_atom_intern_static_string ("AVAILABLE_TARGETS"));
++  gdk_property_delete (window, gdk_atom_intern_static_string ("REQUESTED_TARGETS"));
++
++  gdk_property_change (window,
++                       gdk_atom_intern_static_string ("REQUESTED_TARGETS"),
++                       GDK_SELECTION_TYPE_ATOM,
++                       8 * sizeof (GdkAtom),
++                       GDK_PROP_MODE_REPLACE,
++                       (const guchar *) requested_targets->data,
++                       requested_targets->len);
++
++  g_array_unref (requested_targets);
++
++  event = gdk_event_new (GDK_SELECTION_REQUEST);
++  event->selection.window = g_object_ref (window);
++  event->selection.send_event = FALSE;
++  event->selection.selection = GDK_SELECTION_CLIPBOARD;
++  event->selection.target = gdk_atom_intern_static_string ("MULTIPLE");
++  event->selection.property = gdk_atom_intern_static_string ("REQUESTED_TARGETS");
++  event->selection.time = GDK_CURRENT_TIME;
++  event->selection.requestor = g_object_ref (window);
++
++  gdk_event_put (event);
++  gdk_event_free (event);
++}
++
++static void
++create_paste (GdkWindow     *window,
++              const GdkAtom *requested_targets,
++              gint           n_requested_targets)
++{
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++  GPtrArray *paste_formats;
++  GArray *paste_header;
++  GByteArray *paste_data;
++  gint sizes[4];
++  GdkMirProperty *mir_property;
++  const gchar *paste_format;
++  gint i;
++
++  paste_formats = g_ptr_array_new_full (n_requested_targets, g_free);
++  paste_header = g_array_sized_new (FALSE, FALSE, sizeof (gint), 1 + 4 * n_requested_targets);
++  paste_data = g_byte_array_new ();
++
++  g_array_append_val (paste_header, sizes[0]);
++
++  for (i = 0; i < n_requested_targets; i++)
++    {
++      if (requested_targets[i] == GDK_NONE)
++        continue;
++
++      mir_property = g_hash_table_lookup (impl->properties, requested_targets[i]);
++
++      if (!mir_property)
++        continue;
++
++      paste_format = _gdk_atom_name_const (mir_property->type);
++
++      /* skip non-MIME targets */
++      if (!strchr (paste_format, '/'))
++        {
++          g_hash_table_remove (impl->properties, requested_targets[i]);
++          continue;
++        }
++
++      sizes[0] = paste_data->len;
++      sizes[1] = strlen (paste_format);
++      sizes[2] = sizes[0] + sizes[1];
++      sizes[3] = mir_property->array->len * g_array_get_element_size (mir_property->array);
++
++      g_ptr_array_add (paste_formats, g_strdup (paste_format));
++      g_array_append_vals (paste_header, sizes, 4);
++      g_byte_array_append (paste_data, (const guint8 *) paste_format, sizes[1]);
++      g_byte_array_append (paste_data, (const guint8 *) mir_property->array->data, sizes[3]);
++
++      g_hash_table_remove (impl->properties, requested_targets[i]);
++    }
++
++  gdk_property_delete (window, gdk_atom_intern_static_string ("REQUESTED_TARGETS"));
++
++  g_array_index (paste_header, gint, 0) = paste_formats->len;
++
++  for (i = 0; i < paste_formats->len; i++)
++    {
++      g_array_index (paste_header, gint, 1 + 4 * i) += paste_header->len * sizeof (gint);
++      g_array_index (paste_header, gint, 3 + 4 * i) += paste_header->len * sizeof (gint);
++    }
++
++  g_byte_array_prepend (paste_data,
++                        (const guint8 *) paste_header->data,
++                        paste_header->len * g_array_get_element_size (paste_header));
++
++  g_ptr_array_add (paste_formats, NULL);
++
++  _gdk_mir_display_create_paste (gdk_window_get_display (window),
++                                 (const gchar * const *) paste_formats->pdata,
++                                 paste_data->data,
++                                 paste_data->len);
++
++  g_byte_array_unref (paste_data);
++  g_array_unref (paste_header);
++  g_ptr_array_unref (paste_formats);
++}
++
++static void
+ gdk_mir_window_impl_change_property (GdkWindow    *window,
+                                      GdkAtom       property,
+                                      GdkAtom       type,
+@@ -1604,6 +1738,7 @@ gdk_mir_window_impl_change_property (GdkWindow    *window,
+ {
+   GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
+   GdkMirProperty *mir_property;
++  gboolean existed;
+   GdkEvent *event;
+ 
+   /* ICCCM 2.7: ATOMs and ATOM_PAIRs have format 32, but GdkAtoms can be 64-bit */
+@@ -1611,9 +1746,15 @@ gdk_mir_window_impl_change_property (GdkWindow    *window,
+     format = 8 * sizeof (GdkAtom);
+ 
+   if (mode != GDK_PROP_MODE_REPLACE)
+-    mir_property = g_hash_table_lookup (impl->properties, property);
++    {
++      mir_property = g_hash_table_lookup (impl->properties, property);
++      existed = mir_property != NULL;
++    }
+   else
+-    mir_property = NULL;
++    {
++      mir_property = NULL;
++      existed = g_hash_table_contains (impl->properties, property);
++    }
+ 
+   if (!mir_property)
+     {
+@@ -1640,6 +1781,11 @@ gdk_mir_window_impl_change_property (GdkWindow    *window,
+ 
+   gdk_event_put (event);
+   gdk_event_free (event);
++
++  if (property == gdk_atom_intern_static_string ("AVAILABLE_TARGETS"))
++    request_targets (window, (const GdkAtom *) data, n_elements);
++  else if (property == gdk_atom_intern_static_string ("REQUESTED_TARGETS") && existed)
++    create_paste (window, (const GdkAtom *) data, n_elements);
+ }
+ 
+ static void
+-- 
+2.10.2
+

=== added file 'debian/patches/0005-mir-paste-clipboard-data-from-content-hub.patch'
--- debian/patches/0005-mir-paste-clipboard-data-from-content-hub.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0005-mir-paste-clipboard-data-from-content-hub.patch	2017-02-08 17:37:49 +0000
@@ -0,0 +1,415 @@
+From 41732391d8b93478d4b63d63f9c3cc5bbf124a2a Mon Sep 17 00:00:00 2001
+From: William Hua <[e-mail]>
+Date: Sat, 15 Oct 2016 22:19:59 +0200
+Subject: [PATCH 05/38] mir: paste clipboard data from content-hub
+
+https://bugzilla.gnome.org/show_bug.cgi?id=775732
+---
+ gdk/mir/gdkmirdisplay.c | 339 +++++++++++++++++++++++++++++++++++++++++++++++-
+ 1 file changed, 335 insertions(+), 4 deletions(-)
+
+diff --git a/gdk/mir/gdkmirdisplay.c b/gdk/mir/gdkmirdisplay.c
+index 3dd3798..21967ac 100644
+--- a/gdk/mir/gdkmirdisplay.c
++++ b/gdk/mir/gdkmirdisplay.c
+@@ -23,6 +23,8 @@
+ #include "gdkmir.h"
+ #include "gdkmir-private.h"
+ 
++#include <string.h>
++
+ #include <com/ubuntu/content/glib/content-hub-glib.h>
+ 
+ #define GDK_TYPE_DISPLAY_MIR              (gdk_mir_display_get_type ())
+@@ -62,6 +64,7 @@ typedef struct GdkMirDisplay
+ 
+   ContentHubService *content_service;
+   ContentHubHandler *content_handler;
++  GVariant *paste_data;
+ } GdkMirDisplay;
+ 
+ typedef struct GdkMirDisplayClass
+@@ -107,6 +110,13 @@ static void get_pixel_formats (MirConnection *, MirPixelFormat *sw, MirPixelForm
+ 
+ G_DEFINE_TYPE (GdkMirDisplay, gdk_mir_display, GDK_TYPE_DISPLAY)
+ 
++static void
++pasteboard_changed_cb (GdkMirDisplay *display,
++                       gpointer       user_data)
++{
++  g_clear_pointer (&display->paste_data, g_variant_unref);
++}
++
+ GdkDisplay *
+ _gdk_mir_display_open (const gchar *display_name)
+ {
+@@ -156,6 +166,12 @@ _gdk_mir_display_open (const gchar *display_name)
+     NULL,
+     NULL);
+ 
++  g_signal_connect_swapped (
++    display->content_service,
++    "pasteboard-changed",
++    G_CALLBACK (pasteboard_changed_cb),
++    display);
++
+   display->content_handler = content_hub_handler_skeleton_new ();
+ 
+   g_dbus_interface_skeleton_export (
+@@ -214,6 +230,7 @@ gdk_mir_display_dispose (GObject *object)
+ {
+   GdkMirDisplay *display = GDK_MIR_DISPLAY (object);
+ 
++  g_clear_pointer (&display->paste_data, g_variant_unref);
+   g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (display->content_handler));
+   g_clear_object (&display->content_handler);
+   g_clear_object (&display->content_service);
+@@ -547,10 +564,255 @@ gdk_mir_display_get_selection_property (GdkDisplay  *display,
+                                         GdkAtom     *ret_type,
+                                         gint        *ret_format)
+ {
+-  //g_printerr ("gdk_mir_display_get_selection_property\n");
++  gint length;
++
++  gdk_property_get (requestor,
++                    gdk_atom_intern_static_string ("GDK_SELECTION"),
++                    GDK_NONE,
++                    0,
++                    G_MAXULONG,
++                    FALSE,
++                    ret_type,
++                    ret_format,
++                    &length,
++                    data);
++
++  return length;
++}
++
++static gint
++get_format_score (const gchar *format,
++                  GdkAtom      target,
++                  GdkAtom     *out_type,
++                  gint        *out_size)
++{
++  const gchar *target_string;
++  GdkAtom dummy_type;
++  gint dummy_size;
++
++  target_string = _gdk_atom_name_const (target);
++
++  if (!out_type)
++    out_type = &dummy_type;
++
++  if (!out_size)
++    out_size = &dummy_size;
++
++  if (!g_ascii_strcasecmp (format, target_string))
++    {
++      *out_type = GDK_SELECTION_TYPE_STRING;
++      *out_size = sizeof (guchar);
++
++      return G_MAXINT;
++    }
++
++  if (target == gdk_atom_intern_static_string ("UTF8_STRING"))
++    return get_format_score (format, gdk_atom_intern_static_string ("text/plain;charset=utf-8"), out_type, out_size);
++
++  /* TODO: use best media type for COMPOUND_TEXT target */
++  if (target == gdk_atom_intern_static_string ("COMPOUND_TEXT"))
++    return get_format_score (format, gdk_atom_intern_static_string ("text/plain;charset=utf-8"), out_type, out_size);
++
++  if (target == GDK_TARGET_STRING)
++    return get_format_score (format, gdk_atom_intern_static_string ("text/plain;charset=iso-8859-1"), out_type, out_size);
++
++  if (target == gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"))
++    return get_format_score (format, gdk_atom_intern_static_string ("text/plain;charset=utf-8"), out_type, out_size);
++
++  if (g_content_type_is_a (format, target_string))
++    {
++      *out_type = GDK_SELECTION_TYPE_STRING;
++      *out_size = sizeof (guchar);
++
++      return 2;
++    }
++
++  if (g_content_type_is_a (target_string, format))
++    {
++      *out_type = GDK_SELECTION_TYPE_STRING;
++      *out_size = sizeof (guchar);
++
++      return 1;
++    }
++
+   return 0;
+ }
+ 
++static gint
++get_best_format_index (const gchar * const *formats,
++                       guint                n_formats,
++                       GdkAtom              target,
++                       GdkAtom             *out_type,
++                       gint                *out_size)
++{
++  gint best_i = -1;
++  gint best_score = 0;
++  GdkAtom best_type;
++  gint best_size;
++  gint score;
++  GdkAtom type;
++  gint size;
++  gint i;
++
++  if (!out_type)
++    out_type = &best_type;
++
++  if (!out_size)
++    out_size = &best_size;
++
++  *out_type = GDK_NONE;
++  *out_size = 0;
++
++  for (i = 0; i < n_formats; i++)
++    {
++      score = get_format_score (formats[i], target, &type, &size);
++
++      if (score > best_score)
++        {
++          best_i = i;
++          best_score = score;
++          *out_type = type;
++          *out_size = size;
++        }
++    }
++
++  return best_i;
++}
++
++static void
++gdk_mir_display_real_convert_selection (GdkDisplay *display,
++                                        GdkWindow  *requestor,
++                                        GdkAtom     selection,
++                                        GdkAtom     target,
++                                        guint32     time)
++{
++  GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
++  const gchar *paste_data;
++  gsize paste_size;
++  const gint *paste_header;
++  GPtrArray *paste_formats;
++  GArray *paste_targets;
++  GdkAtom paste_target;
++  GdkEvent *event;
++  gint best_i;
++  GdkAtom best_type;
++  gint best_size;
++  gint i;
++
++  g_return_if_fail (mir_display->paste_data);
++
++  paste_data = g_variant_get_fixed_array (mir_display->paste_data, &paste_size, sizeof (guchar));
++  paste_header = (const gint *) paste_data;
++  paste_formats = g_ptr_array_new_full (paste_header[0], g_free);
++
++  for (i = 0; i < paste_header[0]; i++)
++    g_ptr_array_add (paste_formats, g_strndup (paste_data + paste_header[1 + 4 * i], paste_header[2 + 4 * i]));
++
++  if (target == gdk_atom_intern_static_string ("TARGETS"))
++    {
++      paste_targets = g_array_sized_new (TRUE, FALSE, sizeof (GdkAtom), paste_formats->len);
++
++      for (i = 0; i < paste_formats->len; i++)
++        {
++          paste_target = gdk_atom_intern (g_ptr_array_index (paste_formats, i), FALSE);
++          g_array_append_val (paste_targets, paste_target);
++        }
++
++      gdk_property_change (requestor,
++                           gdk_atom_intern_static_string ("GDK_SELECTION"),
++                           GDK_SELECTION_TYPE_ATOM,
++                           8 * sizeof (GdkAtom),
++                           GDK_PROP_MODE_REPLACE,
++                           (const guchar *) paste_targets->data,
++                           paste_targets->len);
++
++      g_array_unref (paste_targets);
++
++      event = gdk_event_new (GDK_SELECTION_NOTIFY);
++      event->selection.window = g_object_ref (requestor);
++      event->selection.send_event = FALSE;
++      event->selection.selection = selection;
++      event->selection.target = target;
++      event->selection.property = gdk_atom_intern_static_string ("GDK_SELECTION");
++      event->selection.time = time;
++      event->selection.requestor = g_object_ref (requestor);
++
++      gdk_event_put (event);
++      gdk_event_free (event);
++    }
++  else
++    {
++      best_i = get_best_format_index ((const gchar * const *) paste_formats->pdata,
++                                      paste_formats->len,
++                                      target,
++                                      &best_type,
++                                      &best_size);
++
++      if (best_i >= 0)
++        {
++          gdk_property_change (requestor,
++                               gdk_atom_intern_static_string ("GDK_SELECTION"),
++                               best_type,
++                               8 * best_size,
++                               GDK_PROP_MODE_REPLACE,
++                               (const guchar *) paste_data + paste_header[3 + 4 * best_i],
++                               paste_header[4 + 4 * best_i] / best_size);
++
++          event = gdk_event_new (GDK_SELECTION_NOTIFY);
++          event->selection.window = g_object_ref (requestor);
++          event->selection.send_event = FALSE;
++          event->selection.selection = selection;
++          event->selection.target = target;
++          event->selection.property = gdk_atom_intern_static_string ("GDK_SELECTION");
++          event->selection.time = time;
++          event->selection.requestor = g_object_ref (requestor);
++
++          gdk_event_put (event);
++          gdk_event_free (event);
++        }
++    }
++
++  g_ptr_array_unref (paste_formats);
++}
++
++typedef struct
++{
++  GdkDisplay *display;
++  GdkWindow  *requestor;
++  GdkAtom     selection;
++  GdkAtom     target;
++  guint32     time;
++} ConvertInfo;
++
++static void
++paste_data_ready_cb (GObject      *source_object,
++                     GAsyncResult *res,
++                     gpointer      user_data)
++{
++  ContentHubService *content_service = CONTENT_HUB_SERVICE (source_object);
++  ConvertInfo *info = user_data;
++  GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (info->display);
++  gboolean result;
++
++  g_clear_pointer (&mir_display->paste_data, g_variant_unref);
++
++  result = content_hub_service_call_get_latest_paste_data_finish (content_service,
++                                                                  &mir_display->paste_data,
++                                                                  res,
++                                                                  NULL);
++
++  if (result)
++    gdk_mir_display_real_convert_selection (info->display,
++                                            info->requestor,
++                                            info->selection,
++                                            info->target,
++                                            info->time);
++
++  g_object_unref (info->requestor);
++  g_object_unref (info->display);
++  g_free (info);
++}
++
+ static void
+ gdk_mir_display_convert_selection (GdkDisplay *display,
+                                    GdkWindow  *requestor,
+@@ -558,7 +820,46 @@ gdk_mir_display_convert_selection (GdkDisplay *display,
+                                    GdkAtom     target,
+                                    guint32     time)
+ {
+-  //g_printerr ("gdk_mir_display_convert_selection\n");
++  GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
++  MirSurface *surface;
++  MirPersistentId *persistent_id;
++  ConvertInfo *info;
++
++  if (selection != GDK_SELECTION_CLIPBOARD)
++    return;
++  else if (mir_display->paste_data)
++    gdk_mir_display_real_convert_selection (display, requestor, selection, target, time);
++  else if (mir_display->focused_window)
++    {
++      surface = gdk_mir_window_get_mir_surface (mir_display->focused_window);
++
++      if (!surface)
++        return;
++
++      persistent_id = mir_surface_request_persistent_id_sync (surface);
++
++      if (!persistent_id)
++        return;
++
++      if (mir_persistent_id_is_valid (persistent_id))
++        {
++          info = g_new (ConvertInfo, 1);
++          info->display = g_object_ref (display);
++          info->requestor = g_object_ref (requestor);
++          info->selection = selection;
++          info->target = target;
++          info->time = time;
++
++          content_hub_service_call_get_latest_paste_data (
++            mir_display->content_service,
++            mir_persistent_id_as_string (persistent_id),
++            NULL,
++            paste_data_ready_cb,
++            info);
++        }
++
++      mir_persistent_id_release (persistent_id);
++    }
+ }
+ 
+ static gint
+@@ -569,8 +870,38 @@ gdk_mir_display_text_property_to_utf8_list (GdkDisplay    *display,
+                                             gint           length,
+                                             gchar       ***list)
+ {
+-  //g_printerr ("gdk_mir_display_text_property_to_utf8_list\n");
+-  return 0;
++  GPtrArray *array;
++  const gchar *ptr;
++  gsize chunk_len;
++  gchar *copy;
++  guint nitems;
++
++  ptr = (const gchar *) text;
++  array = g_ptr_array_new ();
++
++  /* split text into utf-8 strings */
++  while (ptr < (const gchar *) &text[length])
++    {
++      chunk_len = strlen (ptr);
++
++      if (g_utf8_validate (ptr, chunk_len, NULL))
++        {
++          copy = g_strndup (ptr, chunk_len);
++          g_ptr_array_add (array, copy);
++        }
++
++      ptr = &ptr[chunk_len + 1];
++    }
++
++  nitems = array->len;
++  g_ptr_array_add (array, NULL);
++
++  if (list)
++    *list = (gchar **) g_ptr_array_free (array, FALSE);
++  else
++    g_ptr_array_free (array, TRUE);
++
++  return nitems;
+ }
+ 
+ static gchar *
+-- 
+2.10.2
+

=== added file 'debian/patches/0006-mir-properly-handle-empty-clipboard.patch'
--- debian/patches/0006-mir-properly-handle-empty-clipboard.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0006-mir-properly-handle-empty-clipboard.patch	2017-02-08 17:37:49 +0000
@@ -0,0 +1,37 @@
+From 248ef2d6a0f97cbb71d10c0bb37a3183f13ea19f Mon Sep 17 00:00:00 2001
+From: William Hua <[e-mail]>
+Date: Mon, 9 Jan 2017 12:04:48 -0500
+Subject: [PATCH 06/38] mir: properly handle empty clipboard
+
+https://bugzilla.gnome.org/show_bug.cgi?id=775732
+---
+ gdk/mir/gdkmirdisplay.c | 12 +++++++++---
+ 1 file changed, 9 insertions(+), 3 deletions(-)
+
+diff --git a/gdk/mir/gdkmirdisplay.c b/gdk/mir/gdkmirdisplay.c
+index 21967ac..62f36ee 100644
+--- a/gdk/mir/gdkmirdisplay.c
++++ b/gdk/mir/gdkmirdisplay.c
+@@ -703,10 +703,16 @@ gdk_mir_display_real_convert_selection (GdkDisplay *display,
+ 
+   paste_data = g_variant_get_fixed_array (mir_display->paste_data, &paste_size, sizeof (guchar));
+   paste_header = (const gint *) paste_data;
+-  paste_formats = g_ptr_array_new_full (paste_header[0], g_free);
+ 
+-  for (i = 0; i < paste_header[0]; i++)
+-    g_ptr_array_add (paste_formats, g_strndup (paste_data + paste_header[1 + 4 * i], paste_header[2 + 4 * i]));
++  if (paste_data)
++    {
++      paste_formats = g_ptr_array_new_full (paste_header[0], g_free);
++
++      for (i = 0; i < paste_header[0]; i++)
++        g_ptr_array_add (paste_formats, g_strndup (paste_data + paste_header[1 + 4 * i], paste_header[2 + 4 * i]));
++    }
++  else
++    paste_formats = g_ptr_array_new_with_free_func (g_free);
+ 
+   if (target == gdk_atom_intern_static_string ("TARGETS"))
+     {
+-- 
+2.10.2
+

=== added file 'debian/patches/0031-mir-fix-compile-time-warnings.patch'
--- debian/patches/0031-mir-fix-compile-time-warnings.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0031-mir-fix-compile-time-warnings.patch	2017-02-08 17:37:49 +0000
@@ -0,0 +1,77 @@
+From a95feb498409b42d7b7dd08b2c89c98b70b0a9fe Mon Sep 17 00:00:00 2001
+From: William Hua <[e-mail]>
+Date: Mon, 9 Jan 2017 17:54:37 -0500
+Subject: [PATCH 31/38] mir: fix compile-time warnings
+
+---
+ gdk/mir/gdkmir-debug.c      | 10 ++++++++++
+ gdk/mir/gdkmireventsource.c |  2 ++
+ gdk/mir/gdkmirscreen.c      |  4 ++++
+ 3 files changed, 16 insertions(+)
+
+diff --git a/gdk/mir/gdkmir-debug.c b/gdk/mir/gdkmir-debug.c
+index 7dd54d5..b0ff929 100644
+--- a/gdk/mir/gdkmir-debug.c
++++ b/gdk/mir/gdkmir-debug.c
+@@ -127,6 +127,7 @@ _gdk_mir_print_touch_event (const MirInputEvent *event)
+         }
+       switch (mir_touch_event_tooltype (touch_event, i))
+         {
++        default:
+         case mir_touch_tooltype_unknown:
+           g_printerr (" ? ");
+           break;
+@@ -200,6 +201,12 @@ _gdk_mir_print_motion_event (const MirInputEvent *event)
+ }
+ 
+ static void
++_gdk_mir_print_input_event (const MirInputEvent *event)
++{
++  g_printerr ("INPUT\n");
++}
++
++static void
+ _gdk_mir_print_surface_event (const MirSurfaceEvent *event)
+ {
+   g_printerr ("SURFACE\n");
+@@ -260,6 +267,9 @@ _gdk_mir_print_event (const MirEvent *event)
+           case mir_input_event_type_pointer:
+             _gdk_mir_print_motion_event (mir_event_get_input_event (event));
+             break;
++          default:
++            _gdk_mir_print_input_event (mir_event_get_input_event (event));
++            break;
+         }
+       break;
+     case mir_event_type_key:
+diff --git a/gdk/mir/gdkmireventsource.c b/gdk/mir/gdkmireventsource.c
+index a2a1a12..d3c85b9 100644
+--- a/gdk/mir/gdkmireventsource.c
++++ b/gdk/mir/gdkmireventsource.c
+@@ -571,6 +571,8 @@ gdk_mir_event_source_queue_event (GdkDisplay     *display,
+         case mir_input_event_type_pointer:
+           handle_motion_event (window, input_event);
+           break;
++        default:
++          break;
+         }
+ 
+       break;
+diff --git a/gdk/mir/gdkmirscreen.c b/gdk/mir/gdkmirscreen.c
+index b369b03..979f2ba 100644
+--- a/gdk/mir/gdkmirscreen.c
++++ b/gdk/mir/gdkmirscreen.c
+@@ -354,6 +354,10 @@ gdk_mir_screen_get_monitor_plug_name (GdkScreen *screen,
+             return g_strdup_printf ("eDP-%u", output->output_id);
+           case mir_display_output_type_virtual:
+             return g_strdup_printf ("Virtual-%u", output->output_id);
++          case mir_display_output_type_dsi:
++            return g_strdup_printf ("DSI-%u", output->output_id);
++          case mir_display_output_type_dpi:
++            return g_strdup_printf ("DPI-%u", output->output_id);
+         }
+     }
+ 
+-- 
+2.10.2
+

=== added file 'debian/patches/0032-mir-use-modal-window-hint.patch'
--- debian/patches/0032-mir-use-modal-window-hint.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0032-mir-use-modal-window-hint.patch	2017-02-08 17:37:49 +0000
@@ -0,0 +1,76 @@
+From 5d7db3246e503016462fa28d34b1b3eafe4754d0 Mon Sep 17 00:00:00 2001
+From: William Hua <[e-mail]>
+Date: Thu, 12 Jan 2017 17:16:27 -0500
+Subject: [PATCH 32/38] mir: use modal window hint
+
+---
+ gdk/mir/gdkmirwindowimpl.c | 25 +++++++++++++++++++++++--
+ 1 file changed, 23 insertions(+), 2 deletions(-)
+
+diff --git a/gdk/mir/gdkmirwindowimpl.c b/gdk/mir/gdkmirwindowimpl.c
+index 8a15816..1f48dfb 100644
+--- a/gdk/mir/gdkmirwindowimpl.c
++++ b/gdk/mir/gdkmirwindowimpl.c
+@@ -88,6 +88,7 @@ struct _GdkMirWindowImpl
+   /* Desired surface attributes */
+   GdkWindowTypeHint type_hint;
+   MirSurfaceState surface_state;
++  gboolean modal;
+ 
+   /* Pattern for background */
+   cairo_pattern_t *background;
+@@ -305,6 +306,7 @@ create_window_type_spec (GdkDisplay *display,
+                          gint y,
+                          gint width,
+                          gint height,
++                         gboolean modal,
+                          GdkWindowTypeHint type,
+                          const MirRectangle *rect,
+                          MirEdgeAttachment edge,
+@@ -358,6 +360,17 @@ create_window_type_spec (GdkDisplay *display,
+   switch (type)
+     {
+       case GDK_WINDOW_TYPE_HINT_DIALOG:
++        if (modal)
++          return mir_connection_create_spec_for_modal_dialog (connection,
++                                                              width,
++                                                              height,
++                                                              format,
++                                                              parent_surface);
++        else
++          return mir_connection_create_spec_for_dialog (connection,
++                                                        width,
++                                                        height,
++                                                        format);
+       case GDK_WINDOW_TYPE_HINT_DOCK:
+         return mir_connection_create_spec_for_dialog (connection,
+                                                       width,
+@@ -430,6 +443,7 @@ create_spec (GdkWindow *window, GdkMirWindowImpl *impl)
+                                   impl->transient_for,
+                                   impl->transient_x, impl->transient_y,
+                                   window->width, window->height,
++                                  impl->modal,
+                                   impl->type_hint,
+                                   impl->has_rect ? &impl->rect : NULL,
+                                   impl->has_rect ? impl->edge : mir_edge_attachment_any,
+@@ -1133,8 +1147,15 @@ void
+ gdk_mir_window_impl_set_modal_hint (GdkWindow *window,
+                                     gboolean   modal)
+ {
+-  //g_printerr ("gdk_mir_window_impl_set_modal_hint window=%p\n", window);
+-  /* Mir doesn't support modal windows */
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++
++  if (modal != impl->modal)
++    {
++      impl->modal = modal;
++
++      if (impl->surface && !impl->pending_spec_update)
++        update_surface_spec (window);
++    }
+ }
+ 
+ static void
+-- 
+2.10.2
+

=== added file 'debian/patches/0036-mir-use-mir_surface_spec_set_placement-for-menus.patch'
--- debian/patches/0036-mir-use-mir_surface_spec_set_placement-for-menus.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0036-mir-use-mir_surface_spec_set_placement-for-menus.patch	2017-02-08 17:37:49 +0000
@@ -0,0 +1,334 @@
+From 14c8e25cb2063ff3a91b59328b7f45bcbc4cd875 Mon Sep 17 00:00:00 2001
+From: William Hua <[e-mail]>
+Date: Fri, 27 Jan 2017 14:46:10 -0500
+Subject: [PATCH 36/38] mir: use mir_surface_spec_set_placement for menus
+
+This API was added to Mir for GTK menus, combo boxes, etc.
+---
+ gdk/mir/gdkmirwindowimpl.c | 240 ++++++++++++++++++++++++++++++---------------
+ 1 file changed, 159 insertions(+), 81 deletions(-)
+
+diff --git a/gdk/mir/gdkmirwindowimpl.c b/gdk/mir/gdkmirwindowimpl.c
+index 1f48dfb..6fe0b3c 100644
+--- a/gdk/mir/gdkmirwindowimpl.c
++++ b/gdk/mir/gdkmirwindowimpl.c
+@@ -80,10 +80,15 @@ struct _GdkMirWindowImpl
+   gint transient_x;
+   gint transient_y;
+ 
+-  /* Anchor rectangle */
+-  gboolean has_rect;
+-  MirRectangle rect;
+-  MirEdgeAttachment edge;
++  /* gdk_window_move_to_rect */
++  gboolean            has_rect;
++  GdkRectangle        rect;
++  MirRectangle        mir_rect;
++  MirPlacementGravity rect_anchor;
++  MirPlacementGravity window_anchor;
++  MirPlacementHints   anchor_hints;
++  gint                rect_anchor_dx;
++  gint                rect_anchor_dy;
+ 
+   /* Desired surface attributes */
+   GdkWindowTypeHint type_hint;
+@@ -308,16 +313,12 @@ create_window_type_spec (GdkDisplay *display,
+                          gint height,
+                          gboolean modal,
+                          GdkWindowTypeHint type,
+-                         const MirRectangle *rect,
+-                         MirEdgeAttachment edge,
+                          MirBufferUsage buffer_usage)
+ {
+-  MirPixelFormat format;
+-  MirSurface *parent_surface = NULL;
+   MirConnection *connection = gdk_mir_display_get_mir_connection (display);
+-  MirRectangle real_rect;
+-
+-  format = _gdk_mir_display_get_pixel_format (display, buffer_usage);
++  MirSurface *parent_surface = NULL;
++  MirPixelFormat format;
++  MirRectangle rect;
+ 
+   if (parent && parent->impl)
+     {
+@@ -338,24 +339,12 @@ create_window_type_spec (GdkDisplay *display,
+         }
+     }
+ 
+-  if (rect)
+-    {
+-      real_rect = *rect;
++  format = _gdk_mir_display_get_pixel_format (display, buffer_usage);
+ 
+-      while (parent && !gdk_window_has_native (parent) && gdk_window_get_effective_parent (parent))
+-        {
+-          real_rect.left += parent->x;
+-          real_rect.top += parent->y;
+-          parent = gdk_window_get_effective_parent (parent);
+-        }
+-    }
+-  else
+-    {
+-      real_rect.left = x;
+-      real_rect.top = y;
+-      real_rect.width = 1;
+-      real_rect.height = 1;
+-    }
++  rect.left = x;
++  rect.top = y;
++  rect.width = 1;
++  rect.height = 1;
+ 
+   switch (type)
+     {
+@@ -389,9 +378,8 @@ create_window_type_spec (GdkDisplay *display,
+                                                     height,
+                                                     format,
+                                                     parent_surface,
+-                                                    &real_rect,
+-                                                    edge);
+-        break;
++                                                    &rect,
++                                                    0);
+       case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
+       case GDK_WINDOW_TYPE_HINT_UTILITY:
+         return mir_connection_create_spec_for_modal_dialog (connection,
+@@ -438,15 +426,16 @@ static MirSurfaceSpec*
+ create_spec (GdkWindow *window, GdkMirWindowImpl *impl)
+ {
+   MirSurfaceSpec *spec = NULL;
++  GdkWindow *parent;
+ 
+   spec = create_window_type_spec (impl->display,
+                                   impl->transient_for,
+-                                  impl->transient_x, impl->transient_y,
+-                                  window->width, window->height,
++                                  impl->transient_x,
++                                  impl->transient_y,
++                                  window->width,
++                                  window->height,
+                                   impl->modal,
+                                   impl->type_hint,
+-                                  impl->has_rect ? &impl->rect : NULL,
+-                                  impl->has_rect ? impl->edge : mir_edge_attachment_any,
+                                   impl->buffer_usage);
+ 
+   mir_surface_spec_set_name (spec, impl->title);
+@@ -454,6 +443,32 @@ create_spec (GdkWindow *window, GdkMirWindowImpl *impl)
+ 
+   apply_geometry_hints (spec, impl);
+ 
++  if (impl->has_rect)
++    {
++      impl->mir_rect.left = impl->rect.x;
++      impl->mir_rect.top = impl->rect.y;
++      impl->mir_rect.width = impl->rect.width;
++      impl->mir_rect.height = impl->rect.height;
++
++      parent = impl->transient_for;
++
++      while (parent && !gdk_window_has_native (parent))
++        {
++          impl->mir_rect.left += parent->x;
++          impl->mir_rect.top += parent->y;
++
++          parent = gdk_window_get_parent (parent);
++        }
++
++      mir_surface_spec_set_placement (spec,
++                                      &impl->mir_rect,
++                                      impl->rect_anchor,
++                                      impl->window_anchor,
++                                      impl->anchor_hints,
++                                      impl->rect_anchor_dx,
++                                      impl->rect_anchor_dy);
++    }
++
+   return spec;
+ }
+ 
+@@ -861,52 +876,117 @@ gdk_mir_window_impl_move_resize (GdkWindow *window,
+     }
+ }
+ 
+-static MirEdgeAttachment
+-get_edge_for_anchors (GdkGravity     rect_anchor,
+-                      GdkGravity     window_anchor,
+-                      GdkAnchorHints anchor_hints)
++static MirPlacementGravity
++get_mir_placement_gravity (GdkGravity gravity)
+ {
+-  MirEdgeAttachment edge = 0;
++  switch (gravity)
++    {
++    case GDK_GRAVITY_STATIC:
++    case GDK_GRAVITY_NORTH_WEST:
++      return mir_placement_gravity_northwest;
++    case GDK_GRAVITY_NORTH:
++      return mir_placement_gravity_north;
++    case GDK_GRAVITY_NORTH_EAST:
++      return mir_placement_gravity_northeast;
++    case GDK_GRAVITY_WEST:
++      return mir_placement_gravity_west;
++    case GDK_GRAVITY_CENTER:
++      return mir_placement_gravity_center;
++    case GDK_GRAVITY_EAST:
++      return mir_placement_gravity_east;
++    case GDK_GRAVITY_SOUTH_WEST:
++      return mir_placement_gravity_southwest;
++    case GDK_GRAVITY_SOUTH:
++      return mir_placement_gravity_south;
++    case GDK_GRAVITY_SOUTH_EAST:
++      return mir_placement_gravity_southeast;
++    }
+ 
+-  if (anchor_hints & GDK_ANCHOR_FLIP_X)
+-    edge |= mir_edge_attachment_vertical;
++  g_warn_if_reached ();
+ 
+-  if (anchor_hints & GDK_ANCHOR_FLIP_Y)
+-    edge |= mir_edge_attachment_horizontal;
++  return mir_placement_gravity_center;
++}
++
++static MirPlacementHints
++get_mir_placement_hints (GdkAnchorHints hints)
++{
++  MirPlacementHints mir_hints = 0;
++
++  if (hints & GDK_ANCHOR_FLIP_X)
++    mir_hints |= mir_placement_hints_flip_x;
++
++  if (hints & GDK_ANCHOR_FLIP_Y)
++    mir_hints |= mir_placement_hints_flip_y;
++
++  if (hints & GDK_ANCHOR_SLIDE_X)
++    mir_hints |= mir_placement_hints_slide_x;
++
++  if (hints & GDK_ANCHOR_SLIDE_Y)
++    mir_hints |= mir_placement_hints_slide_y;
+ 
+-  return edge;
++  if (hints & GDK_ANCHOR_RESIZE_X)
++    mir_hints |= mir_placement_hints_resize_x;
++
++  if (hints & GDK_ANCHOR_RESIZE_Y)
++    mir_hints |= mir_placement_hints_resize_y;
++
++  return mir_hints;
+ }
+ 
+-static void
+-get_rect_for_edge (MirRectangle       *out_rect,
+-                   const GdkRectangle *in_rect,
+-                   MirEdgeAttachment   edge,
+-                   GdkWindow          *window)
++static gint
++get_window_shadow_dx (GdkWindow  *window,
++                      GdkGravity  window_anchor)
+ {
+-  out_rect->left = in_rect->x;
+-  out_rect->top = in_rect->y;
+-  out_rect->width = in_rect->width;
+-  out_rect->height = in_rect->height;
++  switch (window_anchor)
++    {
++    case GDK_GRAVITY_STATIC:
++    case GDK_GRAVITY_NORTH_WEST:
++    case GDK_GRAVITY_WEST:
++    case GDK_GRAVITY_SOUTH_WEST:
++      return -window->shadow_left;
++
++    case GDK_GRAVITY_NORTH:
++    case GDK_GRAVITY_CENTER:
++    case GDK_GRAVITY_SOUTH:
++      return (window->shadow_right - window->shadow_left) / 2;
++
++    case GDK_GRAVITY_NORTH_EAST:
++    case GDK_GRAVITY_EAST:
++    case GDK_GRAVITY_SOUTH_EAST:
++      return window->shadow_right;
++    }
+ 
+-  switch (edge)
++  g_warn_if_reached ();
++
++  return 0;
++}
++
++static gint
++get_window_shadow_dy (GdkWindow  *window,
++                      GdkGravity  window_anchor)
++{
++  switch (window_anchor)
+     {
+-    case mir_edge_attachment_vertical:
+-      out_rect->left += window->shadow_right;
+-      out_rect->top -= window->shadow_top;
+-      out_rect->width -= window->shadow_left + window->shadow_right;
+-      out_rect->height += window->shadow_top + window->shadow_bottom;
+-      break;
+-
+-    case mir_edge_attachment_horizontal:
+-      out_rect->left -= window->shadow_left;
+-      out_rect->top += window->shadow_bottom;
+-      out_rect->width += window->shadow_left + window->shadow_right;
+-      out_rect->height -= window->shadow_top + window->shadow_bottom;
+-      break;
+-
+-    default:
+-      break;
++    case GDK_GRAVITY_STATIC:
++    case GDK_GRAVITY_NORTH_WEST:
++    case GDK_GRAVITY_NORTH:
++    case GDK_GRAVITY_NORTH_EAST:
++      return -window->shadow_top;
++
++    case GDK_GRAVITY_WEST:
++    case GDK_GRAVITY_CENTER:
++    case GDK_GRAVITY_EAST:
++      return (window->shadow_bottom - window->shadow_top) / 2;
++
++    case GDK_GRAVITY_SOUTH_WEST:
++    case GDK_GRAVITY_SOUTH:
++    case GDK_GRAVITY_SOUTH_EAST:
++      return window->shadow_bottom;
+     }
++
++  g_warn_if_reached ();
++
++  return 0;
+ }
+ 
+ static void
+@@ -920,18 +1000,16 @@ gdk_mir_window_impl_move_to_rect (GdkWindow          *window,
+ {
+   GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
+ 
+-  impl->edge = get_edge_for_anchors (rect_anchor, window_anchor, anchor_hints);
+-  get_rect_for_edge (&impl->rect, rect, impl->edge, window);
+   impl->has_rect = TRUE;
++  impl->rect = *rect;
++  impl->rect_anchor = get_mir_placement_gravity (rect_anchor);
++  impl->window_anchor = get_mir_placement_gravity (window_anchor);
++  impl->anchor_hints = get_mir_placement_hints (anchor_hints);
++  impl->rect_anchor_dx = rect_anchor_dx + get_window_shadow_dx (window, window_anchor);
++  impl->rect_anchor_dy = rect_anchor_dy + get_window_shadow_dy (window, window_anchor);
+ 
+-  ensure_no_surface (window);
+-
+-  g_signal_emit_by_name (window,
+-                         "moved-to-rect",
+-                         NULL,
+-                         NULL,
+-                         FALSE,
+-                         FALSE);
++  if (impl->surface && !impl->pending_spec_update)
++    update_surface_spec (window);
+ }
+ 
+ static void
+-- 
+2.10.2
+

=== added file 'debian/patches/0037-mir-handle-surface-placement-events.patch'
--- debian/patches/0037-mir-handle-surface-placement-events.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0037-mir-handle-surface-placement-events.patch	2017-02-08 17:37:49 +0000
@@ -0,0 +1,287 @@
+From d9947b671a2c605ef64cb720d2a9c6c80b39e7af Mon Sep 17 00:00:00 2001
+From: William Hua <[e-mail]>
+Date: Sun, 29 Jan 2017 11:24:43 -0500
+Subject: [PATCH 37/38] mir: handle surface placement events
+
+This allows the Mir backend to properly emit "moved-to-rect."
+---
+ gdk/mir/gdkmir-private.h    |   2 +
+ gdk/mir/gdkmir.h            |   1 +
+ gdk/mir/gdkmireventsource.c |  10 +++
+ gdk/mir/gdkmirwindowimpl.c  | 207 ++++++++++++++++++++++++++++++++++++++++++++
+ 4 files changed, 220 insertions(+)
+
+diff --git a/gdk/mir/gdkmir-private.h b/gdk/mir/gdkmir-private.h
+index a677dec..4595dc5 100644
+--- a/gdk/mir/gdkmir-private.h
++++ b/gdk/mir/gdkmir-private.h
+@@ -91,6 +91,8 @@ void _gdk_mir_window_impl_set_surface_type (GdkMirWindowImpl *impl, MirSurfaceTy
+ 
+ void _gdk_mir_window_set_surface_output (GdkWindow *window, gdouble scale);
+ 
++void _gdk_mir_window_set_final_rect (GdkWindow *window, MirRectangle rect);
++
+ void _gdk_mir_window_impl_set_cursor_state (GdkMirWindowImpl *impl, gdouble x, gdouble y, gboolean cursor_inside, guint button_state);
+ 
+ void _gdk_mir_window_impl_get_cursor_state (GdkMirWindowImpl *impl, gdouble *x, gdouble *y, gboolean *cursor_inside, guint *button_state);
+diff --git a/gdk/mir/gdkmir.h b/gdk/mir/gdkmir.h
+index 38cc80c..6e92fcf 100644
+--- a/gdk/mir/gdkmir.h
++++ b/gdk/mir/gdkmir.h
+@@ -20,6 +20,7 @@
+ 
+ #include <gdk/gdk.h>
+ #include <mir_toolkit/mir_client_library.h>
++#include <mir_toolkit/events/surface_placement.h>
+ 
+ G_BEGIN_DECLS
+ 
+diff --git a/gdk/mir/gdkmireventsource.c b/gdk/mir/gdkmireventsource.c
+index d3c85b9..3ebf156 100644
+--- a/gdk/mir/gdkmireventsource.c
++++ b/gdk/mir/gdkmireventsource.c
+@@ -541,6 +541,13 @@ handle_surface_output_event (GdkWindow                  *window,
+   _gdk_mir_window_set_surface_output (window, mir_surface_output_event_get_scale (event));
+ }
+ 
++static void
++handle_surface_placement_event (GdkWindow                      *window,
++                                const MirSurfacePlacementEvent *event)
++{
++  _gdk_mir_window_set_final_rect (window, mir_surface_placement_get_relative_position (event));
++}
++
+ typedef struct
+ {
+   GdkWindow *window;
+@@ -600,6 +607,9 @@ gdk_mir_event_source_queue_event (GdkDisplay     *display,
+     case mir_event_type_surface_output:
+       handle_surface_output_event (window, mir_event_get_surface_output_event (event));
+       break;
++    case mir_event_type_surface_placement:
++      handle_surface_placement_event (window, mir_event_get_surface_placement_event (event));
++      break;
+     default:
+       g_warning ("Ignoring unknown Mir event %d", mir_event_get_type (event));
+       // FIXME?
+diff --git a/gdk/mir/gdkmirwindowimpl.c b/gdk/mir/gdkmirwindowimpl.c
+index 6fe0b3c..1b016ec 100644
+--- a/gdk/mir/gdkmirwindowimpl.c
++++ b/gdk/mir/gdkmirwindowimpl.c
+@@ -1012,6 +1012,213 @@ gdk_mir_window_impl_move_to_rect (GdkWindow          *window,
+     update_surface_spec (window);
+ }
+ 
++static gint
++get_mir_placement_gravity_x (MirPlacementGravity gravity)
++{
++  switch (gravity)
++    {
++    case mir_placement_gravity_west:
++    case mir_placement_gravity_northwest:
++    case mir_placement_gravity_southwest:
++      return 0;
++
++    case mir_placement_gravity_center:
++    case mir_placement_gravity_north:
++    case mir_placement_gravity_south:
++      return 1;
++
++    case mir_placement_gravity_east:
++    case mir_placement_gravity_northeast:
++    case mir_placement_gravity_southeast:
++      return 2;
++    }
++
++  g_warn_if_reached ();
++
++  return 1;
++}
++
++static gint
++get_mir_placement_gravity_y (MirPlacementGravity gravity)
++{
++  switch (gravity)
++    {
++    case mir_placement_gravity_north:
++    case mir_placement_gravity_northwest:
++    case mir_placement_gravity_northeast:
++      return 0;
++
++    case mir_placement_gravity_center:
++    case mir_placement_gravity_west:
++    case mir_placement_gravity_east:
++      return 1;
++
++    case mir_placement_gravity_south:
++    case mir_placement_gravity_southwest:
++    case mir_placement_gravity_southeast:
++      return 2;
++    }
++
++  g_warn_if_reached ();
++
++  return 1;
++}
++
++static GdkRectangle
++get_unflipped_rect (const GdkRectangle  *rect,
++                    gint                 width,
++                    gint                 height,
++                    MirPlacementGravity  rect_anchor,
++                    MirPlacementGravity  window_anchor,
++                    gint                 rect_anchor_dx,
++                    gint                 rect_anchor_dy)
++{
++  GdkRectangle unflipped_rect;
++
++  unflipped_rect.x = rect->x;
++  unflipped_rect.x += rect->width * get_mir_placement_gravity_x (rect_anchor) / 2;
++  unflipped_rect.x -= width * get_mir_placement_gravity_x (window_anchor) / 2;
++  unflipped_rect.x += rect_anchor_dx;
++  unflipped_rect.y = rect->y;
++  unflipped_rect.y += rect->height * get_mir_placement_gravity_y (rect_anchor) / 2;
++  unflipped_rect.y -= height * get_mir_placement_gravity_y (window_anchor) / 2;
++  unflipped_rect.y += rect_anchor_dy;
++  unflipped_rect.width = width;
++  unflipped_rect.height = height;
++
++  return unflipped_rect;
++}
++
++static MirPlacementGravity
++get_opposite_mir_placement_gravity (MirPlacementGravity gravity)
++{
++  switch (gravity)
++    {
++    case mir_placement_gravity_center:
++      return mir_placement_gravity_center;
++    case mir_placement_gravity_west:
++      return mir_placement_gravity_east;
++    case mir_placement_gravity_east:
++      return mir_placement_gravity_west;
++    case mir_placement_gravity_north:
++      return mir_placement_gravity_south;
++    case mir_placement_gravity_south:
++      return mir_placement_gravity_north;
++    case mir_placement_gravity_northwest:
++      return mir_placement_gravity_southeast;
++    case mir_placement_gravity_northeast:
++      return mir_placement_gravity_southwest;
++    case mir_placement_gravity_southwest:
++      return mir_placement_gravity_northeast;
++    case mir_placement_gravity_southeast:
++      return mir_placement_gravity_northwest;
++    }
++
++  g_warn_if_reached ();
++
++  return gravity;
++}
++
++static gint
++get_anchor_x (const GdkRectangle  *rect,
++              MirPlacementGravity  anchor)
++{
++  return rect->x + rect->width * get_mir_placement_gravity_x (anchor) / 2;
++}
++
++static gint
++get_anchor_y (const GdkRectangle  *rect,
++              MirPlacementGravity  anchor)
++{
++  return rect->y + rect->height * get_mir_placement_gravity_y (anchor) / 2;
++}
++
++void
++_gdk_mir_window_set_final_rect (GdkWindow    *window,
++                                MirRectangle  rect)
++{
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++  GdkRectangle best_rect;
++  GdkRectangle worst_rect;
++  GdkRectangle flipped_rect;
++  GdkRectangle final_rect;
++  gboolean flipped_x = FALSE;
++  gboolean flipped_y = FALSE;
++  gint test_position;
++  gint final_position;
++  gint unflipped_offset;
++  gint flipped_offset;
++
++  g_return_if_fail (impl->has_rect);
++
++  best_rect = get_unflipped_rect (&impl->rect,
++                                  window->width,
++                                  window->height,
++                                  impl->rect_anchor,
++                                  impl->window_anchor,
++                                  impl->rect_anchor_dx,
++                                  impl->rect_anchor_dy);
++
++  worst_rect = get_unflipped_rect (&impl->rect,
++                                   window->width,
++                                   window->height,
++                                   get_opposite_mir_placement_gravity (impl->rect_anchor),
++                                   get_opposite_mir_placement_gravity (impl->window_anchor),
++                                   -impl->rect_anchor_dx,
++                                   -impl->rect_anchor_dy);
++
++  flipped_rect.x = best_rect.x;
++  flipped_rect.y = best_rect.y;
++  flipped_rect.width = window->width;
++  flipped_rect.height = window->height;
++
++  final_rect.x = rect.left - (impl->mir_rect.left - impl->rect.x);
++  final_rect.y = rect.top - (impl->mir_rect.top - impl->rect.y);
++  final_rect.width = rect.width;
++  final_rect.height = rect.height;
++
++  if (impl->anchor_hints & mir_placement_hints_flip_x)
++    {
++      test_position = get_anchor_x (&best_rect, impl->window_anchor);
++      final_position = get_anchor_x (&final_rect, impl->window_anchor);
++      unflipped_offset = final_position - test_position;
++
++      test_position = get_anchor_x (&worst_rect, get_opposite_mir_placement_gravity (impl->window_anchor));
++      final_position = get_anchor_x (&final_rect, get_opposite_mir_placement_gravity (impl->window_anchor));
++      flipped_offset = final_position - test_position;
++
++      if (ABS (flipped_offset) < ABS (unflipped_offset))
++        {
++          flipped_rect.x = worst_rect.x;
++          flipped_x = TRUE;
++        }
++    }
++
++  if (impl->anchor_hints & mir_placement_hints_flip_y)
++    {
++      test_position = get_anchor_y (&best_rect, impl->window_anchor);
++      final_position = get_anchor_y (&final_rect, impl->window_anchor);
++      unflipped_offset = final_position - test_position;
++
++      test_position = get_anchor_y (&worst_rect, get_opposite_mir_placement_gravity (impl->window_anchor));
++      final_position = get_anchor_y (&final_rect, get_opposite_mir_placement_gravity (impl->window_anchor));
++      flipped_offset = final_position - test_position;
++
++      if (ABS (flipped_offset) < ABS (unflipped_offset))
++        {
++          flipped_rect.y = worst_rect.y;
++          flipped_y = TRUE;
++        }
++    }
++
++  g_signal_emit_by_name (window,
++                         "moved-to-rect",
++                         &flipped_rect,
++                         &final_rect,
++                         flipped_x,
++                         flipped_y);
++}
++
+ static void
+ gdk_mir_window_impl_set_background (GdkWindow       *window,
+                                     cairo_pattern_t *pattern)
+-- 
+2.10.2
+

=== modified file 'debian/patches/series'
--- debian/patches/series	2017-01-23 14:44:24 +0000
+++ debian/patches/series	2017-02-08 17:37:49 +0000
@@ -24,3 +24,14 @@
 unity-border-radius.patch
 unity-headerbar-maximized-mode.patch
 gtksocket-unscale-before-sending-configurenotify.patch
+
+0001-mir-implement-window-properties.patch
+0002-mir-track-focused-window.patch
+0003-mir-connect-to-content-hub.patch
+0004-mir-copy-clipboard-data-to-content-hub.patch
+0005-mir-paste-clipboard-data-from-content-hub.patch
+0006-mir-properly-handle-empty-clipboard.patch
+0031-mir-fix-compile-time-warnings.patch
+0032-mir-use-modal-window-hint.patch
+0036-mir-use-mir_surface_spec_set_placement-for-menus.patch
+0037-mir-handle-surface-placement-events.patch