Merge ~3v1n0/ubuntu/+source/mutter:ubuntu/master into ~ubuntu-desktop/ubuntu/+source/mutter:ubuntu/master

[Marco Trevisan (Treviño)]

diff --git a/NEWS b/NEWS
index fcdc3cf..d5640ae 100644
--- a/NEWS
+++ b/NEWS
@@ -1,13 +1,126 @@
-3.32.2
+3.33.90
+=======
+* Fix visibility of clones with hidden source [Florian; #683]
+* Reduce freezes when opening some popup windows [Carlos; #556]
+* Be more thorough when excluding obscured areas from painting [Carlos; !698]
+* Make it possible to start Xwayland on demand [Carlos; !709]
+* clutter: Expose layout_manager to transitions [Florian; !716]
+* Misc. bug fixes and cleanups [Mark, Florian, Iain, Niels, Carlos, Ray; !671,
+  !691, !694, !696, !703, !707, !697, !710, !708, !714, #719, !721]
+
+Contributors:
+  Mark Blakeney, Carlos Garnacho, Niels De Graef, Iain Lane, Florian Müllner,
+  Ray Strode
+
+Translators:
+  Asier Sarasua Garmendia [eu], Rafael Fontenelle [pt_BR], Fabio Tomat [fur],
+  Florentina Mușat [ro]
+
+3.33.4
+======
+* Discard page flip retries on hotplug [Jonas; !630]
+* Add xdg-output v2 support [Olivier; #645]
+* Restore DRM format fallbacks [Jonas; !662]
+* Don't emit ::size-changed when only position changed [Daniel; !568]
+* Expose workspace layout properties [Florian; !618]
+* Don't use grab modifiers when shortcuts are inhibited [Olivier; #642]
+* Fix stuttering due to unchanged power save mode notifications [Georges; !674]
+* Add API to reorder workspaces [Adam; !670]
+* Make picking a new focus window more reliable [Marco; !669]
+* Defer actor allocation till shown [Carlos; !677]
+* Try to use primary GPU for copy instead of glReadPixels [Pekka; !615]
+* Unset pointer focus when the cursor is hidden [Jonas D.; !448]
+* Fix modifier-drag on wayland subsurfaces [Robert; !604]
+* Fix background corruption on Nvidia after resuming from suspend [Daniel; !600]
+* Only grab the locate-pointer key when necessary [Olivier; !685, #647]
+* Misc. bug fixes and cleanups [Florian, Jonas, Daniel, Robert, Olivier,
+  Georges, Marco, Carlos, Emmanuele; !648, !650, !647, !656, !658, !637,
+  !663, !660, !659, !665, !666, !668, !667, #667, !676, !678, #672, !680,
+  !683, !688, !689, !687]
+
+Contributors:
+  Jonas Ådahl, Emmanuele Bassi, Adam Bieńkowski, Piotr Drąg, Jonas Dreßler,
+  Olivier Fourdan, Carlos Garnacho, Robert Mader, Florian Müllner,
+  Georges Basile Stavracas Neto, Pekka Paalanen, Marco Trevisan (Treviño),
+  Daniel van Vugt
+
+Translators:
+  Fabio Tomat [fur], Kukuh Syafaat [id]
+
+3.33.3
+======
+* Prepare for running Xwayland on demand [Carlos; !420]
+* Fix text selection color rendering [Florian; #494]
+* Fix black shadows when using fractional scaling [Robert; #609]
+* Honor startup sequence workspace on wayland [Carlos; gnome-shell#674]
+* Only emit 'grab-op-end` signal after dropping grabs [Marco; !596]
+* Add a Sysprof-based profiler [Jonas, Georges; !197, !603]
+* Relax "xwayland-allow-grabs" setting [Olivier; #597]
+* Implement locate-pointer accessibility feature [Olivier; !453]
+* Implement mouse accessibility [Olivier; !512]
+* Consolidate frame throttling [Daniel, Georges; !363]
+* Fix setting blank cursor under wayland [Jonas; #630]
+* Pixel-align OpenGL cursors [Jonas; !610]
+* Handle returning from fullscreen/maximization better [Jonas; !621]
+* Improve screencast support on multi-monitor systems [Georges; !623]
+* Fix running X11 applications with sudo under wayland [Hans; #643]
+* Implement toggle-keys notification [Olivier; #637]
+* Add initial KMS transactional support [Jonas; !525]
+* Improve finding new focus window when the old one is closed [Marco; #308]
+* Misc. bug fixes and cleanups [Jonas, Carlos, Marco, Florian, Pekka, Robert,
+  Douglas, Georges, Daniel, Emil, Niels, Hans, Olivier, Ting-Wei, Corentin;
+  !591, #398, !592, !581, !597, !598, !593, !497, #591, !545, gtk#1675, !601,
+  #568, !564, !605, !609, !115, !214, !611, !617, !616, !619, !624, !622, !627,
+  !628, !629, !632, !633, !631, !636, !639, !638, !634, !640, !529, !644, !590]
+
+Contributors:
+  Jonas Ådahl, Piotr Drąg, Olivier Fourdan, Carlos Garnacho, Hans de Goede,
+  Niels De Graef, Ting-Wei Lan, Robert Mader, Florian Müllner,
+  Georges Basile Stavracas Neto, Corentin Noël, Pekka Paalanen, Douglas R. Reno,
+  Marco Trevisan (Treviño), Emil Velikov, Daniel van Vugt
+
+Translators:
+  Balázs Úr [hu], Daniel Mustieles [es], Nathan Follens [nl], Goran Vidović [hr]
+
+3.33.2
+======
+* Fix rendering lag on Xorg [Daniel; !520, !281]
+* Misc. bug fixes and cleanups [Carlos, Marco, Jonas D., Florian, Niels,
+  Daniel, Benjamin, Jonas Å., Ignacio, Vasilis; #598, !576, !547, !578,
+  !583, !582, !469, !524, !119, !571, !584, !585, !586, #425]
+
+Contributors:
+  Jonas Ådahl, Benjamin Berg, Jonas Dreßler, Carlos Garnacho, Niels De Graef,
+  Vasilis Liaskovitis, Florian Müllner, Ignacio Casal Quinteiro,
+  Marco Trevisan (Treviño), Daniel van Vugt
+
+Translators:
+  Daniel Mustieles [es]
+
+3.33.1
 ======
+* Remove unused APIs and outdated driver support
+  [Adam; !481, !468, !489, !487, !546]
+* Enable EGL_IMG_context_priority [Adam; !454]
 * Disable mouse keys with Numlock on [Olivier; #530]
 * Fix crash when restarting on X11 [Marco; #576]
+* Implement clipboard manager [Carlos; !320]
+* Fix spurious idle signals that prevent session unblank [Jonas Å.; !543]
 * Fix mapping of touchscreens that don't report dimensions [Carlos; #581]
-* Fix spurious idle signals that prevent session unblank [Jonas; !543]
-* Misc. bug fixes and cleanups [Olivier, Marco, Carlos; !552, !557, #586]
+* Fix propagating fractional scaling factor [Robert; !537]
+* Add experimental RT scheduling support [Carlos; !460]
+* Misc. bug fixes and cleanups [Robert, Carlos, Olivier, Ray, Marco, Jonas D.,
+  Georges, Daniel V., Daniel M; !467, !504, !551, !552, #575, #556, !557, !442,
+  !562, !535, !548, #586, !567, !396, !422, !507]
 
 Contributors:
-  Jonas Ådahl, Olivier Fourdan, Carlos Garnacho, Marco Trevisan (Treviño)
+  Jonas Ådahl, Piotr Drąg, Jonas Dreßler, Olivier Fourdan, Carlos Garnacho,
+  Adam Jackson, Robert Mader, Daniel García Moreno, Florian Müllner,
+  Georges Basile Stavracas Neto, Ray Strode, Marco Trevisan (Treviño),
+  Daniel van Vugt
+
+Translators:
+  Daniel Mustieles [es], Fabio Tomat [fur], Kukuh Syafaat [id]
 
 3.32.1
 ======
diff --git a/clutter/clutter/cally/cally-actor.c b/clutter/clutter/cally/cally-actor.c
index 548615f..1c21378 100644
--- a/clutter/clutter/cally/cally-actor.c
+++ b/clutter/clutter/cally/cally-actor.c
@@ -1044,10 +1044,8 @@ _cally_actor_clean_action_list (CallyActor *cally_actor)
 
   if (priv->action_list)
     {
-      g_list_foreach (priv->action_list,
-                      (GFunc) _cally_actor_destroy_action_info,
-                      NULL);
-      g_list_free (priv->action_list);
+      g_list_free_full (priv->action_list,
+                        (GDestroyNotify) _cally_actor_destroy_action_info);
       priv->action_list = NULL;
     }
 }
diff --git a/clutter/clutter/clutter-actor-meta.c b/clutter/clutter/clutter-actor-meta.c
index 4650d90..d7f4fd7 100644
--- a/clutter/clutter/clutter-actor-meta.c
+++ b/clutter/clutter/clutter-actor-meta.c
@@ -577,8 +577,7 @@ _clutter_meta_group_clear_metas (ClutterMetaGroup *group)
 {
   g_list_foreach (group->meta, (GFunc) _clutter_actor_meta_set_actor, NULL);
 
-  g_list_foreach (group->meta, (GFunc) g_object_unref, NULL);
-  g_list_free (group->meta);
+  g_list_free_full (group->meta, g_object_unref);
   group->meta = NULL;
 }
 
diff --git a/clutter/clutter/clutter-actor.c b/clutter/clutter/clutter-actor.c
index 803f76a..4314969 100644
--- a/clutter/clutter/clutter-actor.c
+++ b/clutter/clutter/clutter-actor.c
@@ -433,7 +433,7 @@
  *
  * #ClutterActor allows accessing properties of #ClutterAction,
  * #ClutterEffect, and #ClutterConstraint instances associated to an actor
- * instance for animation purposes.
+ * instance for animation purposes, as well as its #ClutterLayoutManager.
  *
  * In order to access a specific #ClutterAction or a #ClutterConstraint
  * property it is necessary to set the #ClutterActorMeta:name property on the
@@ -457,6 +457,13 @@
  * on the `origin` actor, and in its initial state is overlapping the actor
  * to which is bound to.
  *
+ * As the actor has only one #ClutterLayoutManager, the syntax for accessing its
+ * properties is simpler:
+ *
+ * |[
+ *   @layout.<property-name>
+ * ]|
+ *
  * |[<!-- language="C" -->
  * constraint = clutter_bind_constraint_new (origin, CLUTTER_BIND_X, 0.0);
  * clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), "bind-x");
@@ -807,6 +814,9 @@ struct _ClutterActorPrivate
   gpointer create_child_data;
   GDestroyNotify create_child_notify;
 
+  guint resolution_changed_id;
+  guint font_changed_id;
+
   /* bitfields: KEEP AT THE END */
 
   /* fixed position and sizes */
@@ -5983,6 +5993,7 @@ clutter_actor_dispose (GObject *object)
 {
   ClutterActor *self = CLUTTER_ACTOR (object);
   ClutterActorPrivate *priv = self->priv;
+  ClutterBackend *backend = clutter_get_default_backend ();
 
   CLUTTER_NOTE (MISC, "Dispose actor (name='%s', ref_count:%d) of type '%s'",
 		_clutter_actor_get_debug_name (self),
@@ -6019,6 +6030,18 @@ clutter_actor_dispose (GObject *object)
       g_assert (!CLUTTER_ACTOR_IS_REALIZED (self));
     }
 
+  if (priv->resolution_changed_id)
+    {
+      g_signal_handler_disconnect (backend, priv->resolution_changed_id);
+      priv->resolution_changed_id = 0;
+    }
+
+  if (priv->font_changed_id)
+    {
+      g_signal_handler_disconnect (backend, priv->font_changed_id);
+      priv->font_changed_id = 0;
+    }
+
   g_clear_object (&priv->pango_context);
   g_clear_object (&priv->actions);
   g_clear_object (&priv->constraints);
@@ -8833,9 +8856,9 @@ _clutter_actor_queue_redraw_full (ClutterActor             *self,
    *
    * later during _clutter_stage_do_update(), once relayouting is done
    * and the scenegraph has been updated we will call:
-   * _clutter_stage_finish_queue_redraws().
+   * clutter_stage_maybe_finish_queue_redraws().
    *
-   * _clutter_stage_finish_queue_redraws() will call
+   * clutter_stage_maybe_finish_queue_redraws() will call
    * _clutter_actor_finish_queue_redraw() for each listed actor.
    *
    * Note: actors *are* allowed to queue further redraws during this
@@ -10091,6 +10114,9 @@ clutter_actor_allocate (ClutterActor           *self,
       return;
     }
 
+  if (!clutter_actor_is_visible (self))
+    return;
+
   priv = self->priv;
 
   old_allocation = priv->allocation;
@@ -14900,6 +14926,30 @@ clutter_scriptable_iface_init (ClutterScriptableIface *iface)
   iface->set_custom_property = clutter_actor_set_custom_property;
 }
 
+static gboolean
+get_layout_from_animation_property (ClutterActor  *actor,
+                                    const gchar   *name,
+                                    gchar        **name_p)
+{
+  g_auto (GStrv) tokens = NULL;
+
+  if (!g_str_has_prefix (name, "@layout"))
+    return FALSE;
+
+  tokens = g_strsplit (name, ".", -1);
+  if (tokens == NULL || g_strv_length (tokens) != 2)
+    {
+      CLUTTER_NOTE (ANIMATION, "Invalid property name '%s'",
+                    name + 1);
+      return FALSE;
+    }
+
+  if (name_p != NULL)
+    *name_p = g_strdup (tokens[1]);
+
+  return TRUE;
+}
+
 static ClutterActorMeta *
 get_meta_from_animation_property (ClutterActor  *actor,
                                   const gchar   *name,
@@ -14962,14 +15012,21 @@ static GParamSpec *
 clutter_actor_find_property (ClutterAnimatable *animatable,
                              const gchar       *property_name)
 {
+  ClutterActor *actor = CLUTTER_ACTOR (animatable);
   ClutterActorMeta *meta = NULL;
   GObjectClass *klass = NULL;
   GParamSpec *pspec = NULL;
   gchar *p_name = NULL;
+  gboolean use_layout;
+
+  use_layout = get_layout_from_animation_property (actor,
+                                                   property_name,
+                                                   &p_name);
 
-  meta = get_meta_from_animation_property (CLUTTER_ACTOR (animatable),
-                                           property_name,
-                                           &p_name);
+  if (!use_layout)
+    meta = get_meta_from_animation_property (actor,
+                                             property_name,
+                                             &p_name);
 
   if (meta != NULL)
     {
@@ -14977,6 +15034,12 @@ clutter_actor_find_property (ClutterAnimatable *animatable,
 
       pspec = g_object_class_find_property (klass, p_name);
     }
+  else if (use_layout)
+    {
+      klass = G_OBJECT_GET_CLASS (actor->priv->layout_manager);
+
+      pspec = g_object_class_find_property (klass, p_name);
+    }
   else
     {
       klass = G_OBJECT_GET_CLASS (animatable);
@@ -14994,15 +15057,24 @@ clutter_actor_get_initial_state (ClutterAnimatable *animatable,
                                  const gchar       *property_name,
                                  GValue            *initial)
 {
+  ClutterActor *actor = CLUTTER_ACTOR (animatable);
   ClutterActorMeta *meta = NULL;
   gchar *p_name = NULL;
+  gboolean use_layout;
+
+  use_layout = get_layout_from_animation_property (actor,
+                                                   property_name,
+                                                   &p_name);
 
-  meta = get_meta_from_animation_property (CLUTTER_ACTOR (animatable),
-                                           property_name,
-                                           &p_name);
+  if (!use_layout)
+    meta = get_meta_from_animation_property (actor,
+                                             property_name,
+                                             &p_name);
 
   if (meta != NULL)
     g_object_get_property (G_OBJECT (meta), p_name, initial);
+  else if (use_layout)
+    g_object_get_property (G_OBJECT (actor->priv->layout_manager), p_name, initial);
   else
     g_object_get_property (G_OBJECT (animatable), property_name, initial);
 
@@ -15155,12 +15227,21 @@ clutter_actor_set_final_state (ClutterAnimatable *animatable,
   ClutterActor *actor = CLUTTER_ACTOR (animatable);
   ClutterActorMeta *meta = NULL;
   gchar *p_name = NULL;
+  gboolean use_layout;
+
+  use_layout = get_layout_from_animation_property (actor,
+                                                   property_name,
+                                                   &p_name);
+
+  if (!use_layout)
+    meta = get_meta_from_animation_property (actor,
+                                             property_name,
+                                             &p_name);
 
-  meta = get_meta_from_animation_property (actor,
-                                           property_name,
-                                           &p_name);
   if (meta != NULL)
     g_object_set_property (G_OBJECT (meta), p_name, final);
+  else if (use_layout)
+    g_object_set_property (G_OBJECT (actor->priv->layout_manager), p_name, final);
   else
     {
       GObjectClass *obj_class = G_OBJECT_GET_CLASS (animatable);
@@ -15884,10 +15965,12 @@ clutter_actor_get_pango_context (ClutterActor *self)
     {
       priv->pango_context = clutter_actor_create_pango_context (self);
 
-      g_signal_connect_object (backend, "resolution-changed",
-                               G_CALLBACK (update_pango_context), priv->pango_context, 0);
-      g_signal_connect_object (backend, "font-changed",
-                               G_CALLBACK (update_pango_context), priv->pango_context, 0);
+      priv->resolution_changed_id =
+        g_signal_connect_object (backend, "resolution-changed",
+                                 G_CALLBACK (update_pango_context), priv->pango_context, 0);
+      priv->font_changed_id =
+        g_signal_connect_object (backend, "font-changed",
+                                 G_CALLBACK (update_pango_context), priv->pango_context, 0);
     }
   else
     update_pango_context (backend, priv->pango_context);
@@ -17533,7 +17616,7 @@ _clutter_actor_get_paint_volume_real (ClutterActor *self,
                l != NULL && l->data != priv->current_effect;
                l = l->next)
             {
-              if (!_clutter_effect_get_paint_volume (l->data, pv))
+              if (!_clutter_effect_modify_paint_volume (l->data, pv))
                 {
                   clutter_paint_volume_free (pv);
                   CLUTTER_NOTE (CLIPPING, "Bail from get_paint_volume (%s): "
@@ -17551,7 +17634,7 @@ _clutter_actor_get_paint_volume_real (ClutterActor *self,
           /* otherwise, get the cumulative volume */
           effects = _clutter_meta_group_peek_metas (priv->effects);
           for (l = effects; l != NULL; l = l->next)
-            if (!_clutter_effect_get_paint_volume (l->data, pv))
+            if (!_clutter_effect_modify_paint_volume (l->data, pv))
               {
                 clutter_paint_volume_free (pv);
                 CLUTTER_NOTE (CLIPPING, "Bail from get_paint_volume (%s): "
diff --git a/clutter/clutter/clutter-backend.c b/clutter/clutter/clutter-backend.c
index d4b6a2d..8223913 100644
--- a/clutter/clutter/clutter-backend.c
+++ b/clutter/clutter/clutter-backend.c
@@ -1111,7 +1111,7 @@ _clutter_backend_reset_cogl_framebuffer (ClutterBackend *backend)
 {
   if (backend->dummy_onscreen == COGL_INVALID_HANDLE)
     {
-      CoglError *internal_error = NULL;
+      GError *internal_error = NULL;
 
       backend->dummy_onscreen = cogl_onscreen_new (backend->cogl_context, 1, 1);
 
@@ -1119,7 +1119,7 @@ _clutter_backend_reset_cogl_framebuffer (ClutterBackend *backend)
                                       &internal_error))
         {
           g_critical ("Unable to create dummy onscreen: %s", internal_error->message);
-          cogl_error_free (internal_error);
+          g_error_free (internal_error);
           return;
         }
     }
diff --git a/clutter/clutter/clutter-binding-pool.c b/clutter/clutter/clutter-binding-pool.c
index f0ec29a..60144ba 100644
--- a/clutter/clutter/clutter-binding-pool.c
+++ b/clutter/clutter/clutter-binding-pool.c
@@ -235,8 +235,7 @@ clutter_binding_pool_finalize (GObject *gobject)
 
   g_hash_table_destroy (pool->entries_hash);
 
-  g_slist_foreach (pool->entries, (GFunc) binding_entry_free, NULL);
-  g_slist_free (pool->entries);
+  g_slist_free_full (pool->entries, (GDestroyNotify) binding_entry_free);
 
   G_OBJECT_CLASS (clutter_binding_pool_parent_class)->finalize (gobject);
 }
diff --git a/clutter/clutter/clutter-blur-effect.c b/clutter/clutter/clutter-blur-effect.c
index 564f796..1ffb99c 100644
--- a/clutter/clutter/clutter-blur-effect.c
+++ b/clutter/clutter/clutter-blur-effect.c
@@ -178,8 +178,8 @@ clutter_blur_effect_paint_target (ClutterOffscreenEffect *effect)
 }
 
 static gboolean
-clutter_blur_effect_get_paint_volume (ClutterEffect      *effect,
-                                      ClutterPaintVolume *volume)
+clutter_blur_effect_modify_paint_volume (ClutterEffect      *effect,
+                                         ClutterPaintVolume *volume)
 {
   gfloat cur_width, cur_height;
   ClutterVertex origin;
@@ -223,7 +223,7 @@ clutter_blur_effect_class_init (ClutterBlurEffectClass *klass)
   gobject_class->dispose = clutter_blur_effect_dispose;
 
   effect_class->pre_paint = clutter_blur_effect_pre_paint;
-  effect_class->get_paint_volume = clutter_blur_effect_get_paint_volume;
+  effect_class->modify_paint_volume = clutter_blur_effect_modify_paint_volume;
 
   offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
   offscreen_class->paint_target = clutter_blur_effect_paint_target;
@@ -249,9 +249,7 @@ clutter_blur_effect_init (ClutterBlurEffect *self)
       cogl_pipeline_add_layer_snippet (klass->base_pipeline, 0, snippet);
       cogl_object_unref (snippet);
 
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
-                                            0, /* layer number */
-                                            COGL_TEXTURE_TYPE_2D);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);
diff --git a/clutter/clutter/clutter-brightness-contrast-effect.c b/clutter/clutter/clutter-brightness-contrast-effect.c
index 741a818..9bb3d97 100644
--- a/clutter/clutter/clutter-brightness-contrast-effect.c
+++ b/clutter/clutter/clutter-brightness-contrast-effect.c
@@ -438,9 +438,7 @@ clutter_brightness_contrast_effect_init (ClutterBrightnessContrastEffect *self)
       cogl_pipeline_add_snippet (klass->base_pipeline, snippet);
       cogl_object_unref (snippet);
 
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
-                                            0, /* layer number */
-                                            COGL_TEXTURE_TYPE_2D);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);
diff --git a/clutter/clutter/clutter-click-action.c b/clutter/clutter/clutter-click-action.c
index f7b73cc..5b4c99f 100644
--- a/clutter/clutter/clutter-click-action.c
+++ b/clutter/clutter/clutter-click-action.c
@@ -355,6 +355,10 @@ on_captured_event (ClutterActor       *stage,
 
   switch (clutter_event_type (event))
     {
+    case CLUTTER_TOUCH_CANCEL:
+      clutter_click_action_release (action);
+      break;
+
     case CLUTTER_TOUCH_END:
       has_button = FALSE;
     case CLUTTER_BUTTON_RELEASE:
diff --git a/clutter/clutter/clutter-clone.c b/clutter/clutter/clutter-clone.c
index 53dcb6c..40a3d53 100644
--- a/clutter/clutter/clutter-clone.c
+++ b/clutter/clutter/clutter-clone.c
@@ -252,6 +252,13 @@ clutter_clone_allocate (ClutterActor           *self,
   if (priv->clone_source == NULL)
     return;
 
+  /* ClutterActor delays allocating until the actor is shown; however
+   * we cannot paint it correctly in that case, so force an allocation.
+   */
+  if (clutter_actor_get_parent (priv->clone_source) != NULL &&
+      !clutter_actor_has_allocation (priv->clone_source))
+    clutter_actor_allocate_preferred_size (priv->clone_source, flags);
+
 #if 0
   /* XXX - this is wrong: ClutterClone cannot clone unparented
    * actors, as it will break all invariants
diff --git a/clutter/clutter/clutter-colorize-effect.c b/clutter/clutter/clutter-colorize-effect.c
index 1662f7d..73bd319 100644
--- a/clutter/clutter/clutter-colorize-effect.c
+++ b/clutter/clutter/clutter-colorize-effect.c
@@ -293,9 +293,7 @@ clutter_colorize_effect_init (ClutterColorizeEffect *self)
       cogl_pipeline_add_snippet (klass->base_pipeline, snippet);
       cogl_object_unref (snippet);
 
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
-                                            0, /* layer number */
-                                            COGL_TEXTURE_TYPE_2D);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);
diff --git a/clutter/clutter/clutter-deform-effect.c b/clutter/clutter/clutter-deform-effect.c
index a52e8b9..05ee15f 100644
--- a/clutter/clutter/clutter-deform-effect.c
+++ b/clutter/clutter/clutter-deform-effect.c
@@ -282,6 +282,7 @@ clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect)
   /* enable depth testing */
   cogl_depth_state_init (&depth_state);
   cogl_depth_state_set_test_enabled (&depth_state, TRUE);
+  cogl_depth_state_set_test_function (&depth_state, COGL_DEPTH_TEST_FUNCTION_LEQUAL);
   cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL);
 
   /* enable backface culling if we have a back material */
diff --git a/clutter/clutter/clutter-deprecated.h b/clutter/clutter/clutter-deprecated.h
index c26c681..1673be8 100644
--- a/clutter/clutter/clutter-deprecated.h
+++ b/clutter/clutter/clutter-deprecated.h
@@ -17,7 +17,6 @@
 #include "deprecated/clutter-container.h"
 #include "deprecated/clutter-group.h"
 #include "deprecated/clutter-keysyms.h"
-#include "deprecated/clutter-main.h"
 #include "deprecated/clutter-rectangle.h"
 #include "deprecated/clutter-stage-manager.h"
 #include "deprecated/clutter-stage.h"
diff --git a/clutter/clutter/clutter-desaturate-effect.c b/clutter/clutter/clutter-desaturate-effect.c
index 061358a..bc691d5 100644
--- a/clutter/clutter/clutter-desaturate-effect.c
+++ b/clutter/clutter/clutter-desaturate-effect.c
@@ -297,9 +297,7 @@ clutter_desaturate_effect_init (ClutterDesaturateEffect *self)
       cogl_pipeline_add_snippet (klass->base_pipeline, snippet);
       cogl_object_unref (snippet);
 
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
-                                            0, /* layer number */
-                                            COGL_TEXTURE_TYPE_2D);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);
diff --git a/clutter/clutter/clutter-device-manager-private.h b/clutter/clutter/clutter-device-manager-private.h
index 2364fd2..712dd40 100644
--- a/clutter/clutter/clutter-device-manager-private.h
+++ b/clutter/clutter/clutter-device-manager-private.h
@@ -69,6 +69,22 @@ typedef struct _ClutterTouchInfo
   gfloat current_y;
 } ClutterTouchInfo;
 
+typedef struct _ClutterPtrA11yData
+{
+  int n_btn_pressed;
+  float current_x;
+  float current_y;
+
+  float dwell_x;
+  float dwell_y;
+  gboolean dwell_drag_started;
+  gboolean dwell_gesture_started;
+  guint dwell_timer;
+
+  guint secondary_click_timer;
+  gboolean secondary_click_triggered;
+} ClutterPtrA11yData;
+
 struct _ClutterInputDevice
 {
   GObject parent_instance;
@@ -143,6 +159,10 @@ struct _ClutterInputDevice
 
   guint has_cursor : 1;
   guint is_enabled : 1;
+
+  /* Accessiblity */
+  ClutterVirtualInputDevice *accessibility_virtual_device;
+  ClutterPtrA11yData *ptr_a11y_data;
 };
 
 typedef void (*ClutterEmitInputDeviceEvent) (ClutterEvent       *event,
diff --git a/clutter/clutter/clutter-device-manager.c b/clutter/clutter/clutter-device-manager.c
index c676384..fd485a0 100644
--- a/clutter/clutter/clutter-device-manager.c
+++ b/clutter/clutter/clutter-device-manager.c
@@ -47,6 +47,7 @@
 #include "clutter-stage-private.h"
 #include "clutter-virtual-input-device.h"
 #include "clutter-input-device-tool.h"
+#include "clutter-input-pointer-a11y-private.h"
 
 struct _ClutterDeviceManagerPrivate
 {
@@ -55,6 +56,8 @@ struct _ClutterDeviceManagerPrivate
 
   /* Keyboard a11y */
   ClutterKbdA11ySettings kbd_a11y_settings;
+  /* Pointer a11y */
+  ClutterPointerA11ySettings pointer_a11y_settings;
 };
 
 enum
@@ -75,6 +78,9 @@ enum
   TOOL_CHANGED,
   KBD_A11Y_MASK_CHANGED,
   KBD_A11Y_FLAGS_CHANGED,
+  PTR_A11Y_DWELL_CLICK_TYPE_CHANGED,
+  PTR_A11Y_TIMEOUT_STARTED,
+  PTR_A11Y_TIMEOUT_STOPPED,
 
   LAST_SIGNAL
 };
@@ -239,6 +245,67 @@ clutter_device_manager_class_init (ClutterDeviceManagerClass *klass)
                   G_TYPE_NONE, 2,
                   G_TYPE_UINT,
                   G_TYPE_UINT);
+
+  /**
+   * ClutterDeviceManager::ptr-a11y-dwell-click-type-changed:
+   * @manager: the #ClutterDeviceManager that emitted the signal
+   * @click_type: the new #ClutterPointerA11yDwellClickType mode
+   *
+   * The ::ptr-a11y-dwell-click-type-changed signal is emitted each time
+   * the ClutterPointerA11yDwellClickType mode is changed as the result
+   * of pointer accessibility operations.
+   */
+  manager_signals[PTR_A11Y_DWELL_CLICK_TYPE_CHANGED] =
+    g_signal_new (I_("ptr-a11y-dwell-click-type-changed"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL,
+                  g_cclosure_marshal_VOID__FLAGS,
+                  G_TYPE_NONE, 1,
+                  CLUTTER_TYPE_POINTER_A11Y_DWELL_CLICK_TYPE);
+
+  /**
+   * ClutterDeviceManager::ptr-a11y-timeout-started:
+   * @manager: the #ClutterDeviceManager that emitted the signal
+   * @device: the core pointer #ClutterInputDevice
+   * @timeout_type: the type of timeout #ClutterPointerA11yTimeoutType
+   * @delay: the delay in ms before secondary-click is triggered.
+   *
+   * The ::ptr-a11y-timeout-started signal is emitted when a
+   * pointer accessibility timeout delay is started, so that upper
+   * layers can notify the user with some visual feedback.
+   */
+  manager_signals[PTR_A11Y_TIMEOUT_STARTED] =
+    g_signal_new (I_("ptr-a11y-timeout-started"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL,
+                  _clutter_marshal_VOID__OBJECT_FLAGS_UINT,
+                  G_TYPE_NONE, 3,
+                  CLUTTER_TYPE_INPUT_DEVICE,
+                  CLUTTER_TYPE_POINTER_A11Y_TIMEOUT_TYPE,
+                  G_TYPE_UINT);
+
+  /**
+   * ClutterDeviceManager::ptr-a11y-timeout-stopped:
+   * @manager: the #ClutterDeviceManager that emitted the signal
+   * @device: the core pointer #ClutterInputDevice
+   * @timeout_type: the type of timeout #ClutterPointerA11yTimeoutType
+   *
+   * The ::ptr-a11y-timeout-stopped signal is emitted when a running
+   * pointer accessibility timeout delay is stopped, either because
+   * it's triggered at the end of the delay or cancelled, so that
+   * upper layers can notify the user with some visual feedback.
+   */
+  manager_signals[PTR_A11Y_TIMEOUT_STOPPED] =
+    g_signal_new (I_("ptr-a11y-timeout-stopped"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL,
+                  _clutter_marshal_VOID__OBJECT_FLAGS,
+                  G_TYPE_NONE, 2,
+                  CLUTTER_TYPE_INPUT_DEVICE,
+                  CLUTTER_TYPE_POINTER_A11Y_TIMEOUT_TYPE);
 }
 
 static void
@@ -579,3 +646,88 @@ clutter_device_manager_get_kbd_a11y_settings (ClutterDeviceManager   *device_man
 
   *settings = device_manager->priv->kbd_a11y_settings;
 }
+
+static gboolean
+are_pointer_a11y_settings_equal (ClutterPointerA11ySettings *a,
+                                 ClutterPointerA11ySettings *b)
+{
+  return (memcmp (a, b, sizeof (ClutterPointerA11ySettings)) == 0);
+}
+
+static void
+clutter_device_manager_enable_pointer_a11y (ClutterDeviceManager *device_manager)
+{
+  ClutterInputDevice *core_pointer;
+
+  core_pointer = clutter_device_manager_get_core_device (device_manager,
+                                                         CLUTTER_POINTER_DEVICE);
+
+  _clutter_input_pointer_a11y_add_device (core_pointer);
+}
+
+static void
+clutter_device_manager_disable_pointer_a11y (ClutterDeviceManager *device_manager)
+{
+  ClutterInputDevice *core_pointer;
+
+  core_pointer = clutter_device_manager_get_core_device (device_manager,
+                                                         CLUTTER_POINTER_DEVICE);
+
+  _clutter_input_pointer_a11y_remove_device (core_pointer);
+}
+
+/**
+ * clutter_device_manager_set_pointer_a11y_settings:
+ * @device_manager: a #ClutterDeviceManager
+ * @settings: a pointer to a #ClutterPointerA11ySettings
+ *
+ * Sets the pointer accessibility settings
+ **/
+void
+clutter_device_manager_set_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
+                                                  ClutterPointerA11ySettings *settings)
+{
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  if (are_pointer_a11y_settings_equal (&device_manager->priv->pointer_a11y_settings, settings))
+    return;
+
+  if (device_manager->priv->pointer_a11y_settings.controls == 0 && settings->controls != 0)
+    clutter_device_manager_enable_pointer_a11y (device_manager);
+  else if (device_manager->priv->pointer_a11y_settings.controls != 0 && settings->controls == 0)
+    clutter_device_manager_disable_pointer_a11y (device_manager);
+
+  device_manager->priv->pointer_a11y_settings = *settings;
+}
+
+/**
+ * clutter_device_manager_get_pointer_a11y_settings:
+ * @device_manager: a #ClutterDeviceManager
+ * @settings: a pointer to a #ClutterPointerA11ySettings
+ *
+ * Gets the current pointer accessibility settings
+ **/
+void
+clutter_device_manager_get_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
+                                                  ClutterPointerA11ySettings *settings)
+{
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  *settings = device_manager->priv->pointer_a11y_settings;
+}
+
+/**
+ * clutter_device_manager_set_pointer_a11y_dwell_click_type:
+ * @device_manager: a #ClutterDeviceManager
+ * @click_type: type of click as #ClutterPointerA11yDwellClickType
+ *
+ * Sets the dwell click type
+ **/
+void
+clutter_device_manager_set_pointer_a11y_dwell_click_type (ClutterDeviceManager             *device_manager,
+                                                          ClutterPointerA11yDwellClickType  click_type)
+{
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  device_manager->priv->pointer_a11y_settings.dwell_click_type = click_type;
+}
diff --git a/clutter/clutter/clutter-device-manager.h b/clutter/clutter/clutter-device-manager.h
index 1cbf030..5fbd395 100644
--- a/clutter/clutter/clutter-device-manager.h
+++ b/clutter/clutter/clutter-device-manager.h
@@ -74,6 +74,27 @@ typedef struct _ClutterKbdA11ySettings
 } ClutterKbdA11ySettings;
 
 /**
+ * ClutterPointerA11ySettings:
+ *
+ * The #ClutterPointerA11ySettings structure contains pointer accessibility
+ * settings
+ *
+ */
+typedef struct _ClutterPointerA11ySettings
+{
+  ClutterPointerA11yFlags controls;
+  ClutterPointerA11yDwellClickType dwell_click_type;
+  ClutterPointerA11yDwellMode dwell_mode;
+  ClutterPointerA11yDwellDirection dwell_gesture_single;
+  ClutterPointerA11yDwellDirection dwell_gesture_double;
+  ClutterPointerA11yDwellDirection dwell_gesture_drag;
+  ClutterPointerA11yDwellDirection dwell_gesture_secondary;
+  gint secondary_click_delay;
+  gint dwell_delay;
+  gint dwell_threshold;
+} ClutterPointerA11ySettings;
+
+/**
  * ClutterDeviceManager:
  *
  * The #ClutterDeviceManager structure contains only private data
@@ -152,10 +173,23 @@ ClutterVirtualDeviceType clutter_device_manager_get_supported_virtual_device_typ
 CLUTTER_EXPORT
 void clutter_device_manager_set_kbd_a11y_settings (ClutterDeviceManager   *device_manager,
                                                    ClutterKbdA11ySettings *settings);
+
 CLUTTER_EXPORT
 void clutter_device_manager_get_kbd_a11y_settings (ClutterDeviceManager   *device_manager,
                                                    ClutterKbdA11ySettings *settings);
 
+CLUTTER_EXPORT
+void clutter_device_manager_set_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
+                                                       ClutterPointerA11ySettings *settings);
+
+CLUTTER_EXPORT
+void clutter_device_manager_get_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
+                                                       ClutterPointerA11ySettings *settings);
+
+CLUTTER_EXPORT
+void clutter_device_manager_set_pointer_a11y_dwell_click_type (ClutterDeviceManager             *device_manager,
+                                                               ClutterPointerA11yDwellClickType  click_type);
+
 G_END_DECLS
 
 #endif /* __CLUTTER_DEVICE_MANAGER_H__ */
diff --git a/clutter/clutter/clutter-effect-private.h b/clutter/clutter/clutter-effect-private.h
index c1e9b3b..87f3484 100644
--- a/clutter/clutter/clutter-effect-private.h
+++ b/clutter/clutter/clutter-effect-private.h
@@ -7,7 +7,7 @@ G_BEGIN_DECLS
 
 gboolean        _clutter_effect_pre_paint               (ClutterEffect           *effect);
 void            _clutter_effect_post_paint              (ClutterEffect           *effect);
-gboolean        _clutter_effect_get_paint_volume        (ClutterEffect           *effect,
+gboolean        _clutter_effect_modify_paint_volume     (ClutterEffect           *effect,
                                                          ClutterPaintVolume      *volume);
 gboolean        _clutter_effect_has_custom_paint_volume (ClutterEffect           *effect);
 void            _clutter_effect_paint                   (ClutterEffect           *effect,
diff --git a/clutter/clutter/clutter-effect.c b/clutter/clutter/clutter-effect.c
index 82cf671..a7c06d9 100644
--- a/clutter/clutter/clutter-effect.c
+++ b/clutter/clutter/clutter-effect.c
@@ -188,8 +188,8 @@ clutter_effect_real_post_paint (ClutterEffect *effect)
 }
 
 static gboolean
-clutter_effect_real_get_paint_volume (ClutterEffect      *effect,
-                                      ClutterPaintVolume *volume)
+clutter_effect_real_modify_paint_volume (ClutterEffect      *effect,
+                                         ClutterPaintVolume *volume)
 {
   return TRUE;
 }
@@ -252,7 +252,7 @@ clutter_effect_class_init (ClutterEffectClass *klass)
 
   klass->pre_paint = clutter_effect_real_pre_paint;
   klass->post_paint = clutter_effect_real_post_paint;
-  klass->get_paint_volume = clutter_effect_real_get_paint_volume;
+  klass->modify_paint_volume = clutter_effect_real_modify_paint_volume;
   klass->paint = clutter_effect_real_paint;
   klass->pick = clutter_effect_real_pick;
 }
@@ -297,13 +297,14 @@ _clutter_effect_pick (ClutterEffect           *effect,
 }
 
 gboolean
-_clutter_effect_get_paint_volume (ClutterEffect      *effect,
-                                  ClutterPaintVolume *volume)
+_clutter_effect_modify_paint_volume (ClutterEffect      *effect,
+                                     ClutterPaintVolume *volume)
 {
   g_return_val_if_fail (CLUTTER_IS_EFFECT (effect), FALSE);
   g_return_val_if_fail (volume != NULL, FALSE);
 
-  return CLUTTER_EFFECT_GET_CLASS (effect)->get_paint_volume (effect, volume);
+  return CLUTTER_EFFECT_GET_CLASS (effect)->modify_paint_volume (effect,
+                                                                 volume);
 }
 
 gboolean
@@ -311,7 +312,7 @@ _clutter_effect_has_custom_paint_volume (ClutterEffect *effect)
 {
   g_return_val_if_fail (CLUTTER_IS_EFFECT (effect), FALSE);
 
-  return CLUTTER_EFFECT_GET_CLASS (effect)->get_paint_volume != clutter_effect_real_get_paint_volume;
+  return CLUTTER_EFFECT_GET_CLASS (effect)->modify_paint_volume != clutter_effect_real_modify_paint_volume;
 }
 
 /**
diff --git a/clutter/clutter/clutter-effect.h b/clutter/clutter/clutter-effect.h
index d25a63e..6f280d9 100644
--- a/clutter/clutter/clutter-effect.h
+++ b/clutter/clutter/clutter-effect.h
@@ -60,7 +60,7 @@ struct _ClutterEffect
  * ClutterEffectClass:
  * @pre_paint: virtual function
  * @post_paint: virtual function
- * @get_paint_volume: virtual function
+ * @modify_paint_volume: virtual function
  * @paint: virtual function
  * @pick: virtual function
  *
@@ -74,16 +74,16 @@ struct _ClutterEffectClass
   ClutterActorMetaClass parent_class;
 
   /*< public >*/
-  gboolean (* pre_paint)        (ClutterEffect           *effect);
-  void     (* post_paint)       (ClutterEffect           *effect);
+  gboolean (* pre_paint)           (ClutterEffect           *effect);
+  void     (* post_paint)          (ClutterEffect           *effect);
 
-  gboolean (* get_paint_volume) (ClutterEffect           *effect,
-                                 ClutterPaintVolume      *volume);
+  gboolean (* modify_paint_volume) (ClutterEffect           *effect,
+                                    ClutterPaintVolume      *volume);
 
-  void     (* paint)            (ClutterEffect           *effect,
-                                 ClutterEffectPaintFlags  flags);
-  void     (* pick)             (ClutterEffect           *effect,
-                                 ClutterEffectPaintFlags  flags);
+  void     (* paint)               (ClutterEffect           *effect,
+                                    ClutterEffectPaintFlags  flags);
+  void     (* pick)                (ClutterEffect           *effect,
+                                    ClutterEffectPaintFlags  flags);
 
   /*< private >*/
   void (* _clutter_effect4) (void);
diff --git a/clutter/clutter/clutter-enum-types.h.in b/clutter/clutter/clutter-enum-types.h.in
index 2e5b670..17f9ee6 100644
--- a/clutter/clutter/clutter-enum-types.h.in
+++ b/clutter/clutter/clutter-enum-types.h.in
@@ -13,7 +13,7 @@ G_BEGIN_DECLS
 /*** END file-header ***/
 
 /*** BEGIN file-production ***/
-/* enumerations from "@filename@" */
+/* enumerations from "@basename@" */
 /*** END file-production ***/
 
 /*** BEGIN value-header ***/
diff --git a/clutter/clutter/clutter-enums.h b/clutter/clutter/clutter-enums.h
index 9cb2967..c91f4cb 100644
--- a/clutter/clutter/clutter-enums.h
+++ b/clutter/clutter/clutter-enums.h
@@ -278,24 +278,6 @@ typedef enum
 } ClutterAnimationMode;
 
 /**
- * ClutterFontFlags:
- * @CLUTTER_FONT_MIPMAPPING: Set to use mipmaps for the glyph cache textures.
- * @CLUTTER_FONT_HINTING: Set to enable hinting on the glyphs.
- *
- * Runtime flags to change the font quality. To be used with
- * clutter_set_font_flags().
- *
- * Since: 1.0
- *
- * Deprecated: 1.22: Use #cairo_font_options_t instead
- */
-typedef enum /*< prefix=CLUTTER_FONT >*/
-{
-  CLUTTER_FONT_MIPMAPPING = (1 << 0),
-  CLUTTER_FONT_HINTING    = (1 << 1)
-} ClutterFontFlags;
-
-/**
  * ClutterTextDirection:
  * @CLUTTER_TEXT_DIRECTION_DEFAULT: Use the default setting, as returned
  *   by clutter_get_default_text_direction()
@@ -444,6 +426,88 @@ typedef enum
 } ClutterKeyboardA11yFlags;
 
 /**
+ * ClutterPointerA11yFlags:
+ * @CLUTTER_A11Y_POINTER_ENABLED:
+ * @CLUTTER_A11Y_SECONDARY_CLICK_ENABLED:
+ * @CLUTTER_A11Y_DWELL_ENABLED:
+ *
+ * Pointer accessibility features applied to a ClutterInputDevice pointer.
+ *
+ */
+typedef enum {
+  CLUTTER_A11Y_SECONDARY_CLICK_ENABLED   = 1 << 0,
+  CLUTTER_A11Y_DWELL_ENABLED             = 1 << 1,
+} ClutterPointerA11yFlags;
+
+/**
+ * ClutterPointerA11yDwellClickType:
+ * @CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE: Internal use only
+ * @CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY:
+ * @CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY:
+ * @CLUTTER_A11Y_DWELL_CLICK_TYPE_MIDDLE:
+ * @CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE:
+ * @CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG:
+ *
+ * Dwell click types.
+ *
+ */
+typedef enum {
+  CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE,
+  CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY,
+  CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY,
+  CLUTTER_A11Y_DWELL_CLICK_TYPE_MIDDLE,
+  CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE,
+  CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG,
+} ClutterPointerA11yDwellClickType;
+
+/**
+ * ClutterPointerA11yDwellDirection:
+ * @CLUTTER_A11Y_DWELL_DIRECTION_NONE:
+ * @CLUTTER_A11Y_DWELL_DIRECTION_LEFT:
+ * @CLUTTER_A11Y_DWELL_DIRECTION_RIGHT:
+ * @CLUTTER_A11Y_DWELL_DIRECTION_UP:
+ * @CLUTTER_A11Y_DWELL_DIRECTION_DOWN:
+ *
+ * Dwell gesture directions.
+ *
+ */
+typedef enum {
+  CLUTTER_A11Y_DWELL_DIRECTION_NONE,
+  CLUTTER_A11Y_DWELL_DIRECTION_LEFT,
+  CLUTTER_A11Y_DWELL_DIRECTION_RIGHT,
+  CLUTTER_A11Y_DWELL_DIRECTION_UP,
+  CLUTTER_A11Y_DWELL_DIRECTION_DOWN,
+} ClutterPointerA11yDwellDirection;
+
+/**
+ * ClutterPointerA11yDwellMode:
+ * @CLUTTER_A11Y_DWELL_MODE_WINDOW:
+ * @CLUTTER_A11Y_DWELL_MODE_GESTURE:
+ *
+ * Dwell mode.
+ *
+ */
+typedef enum {
+  CLUTTER_A11Y_DWELL_MODE_WINDOW,
+  CLUTTER_A11Y_DWELL_MODE_GESTURE,
+} ClutterPointerA11yDwellMode;
+
+/**
+ * ClutterPointerA11yTimeoutType:
+ * @CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK:
+ * @CLUTTER_A11Y_TIMEOUT_TYPE_DWELL:
+ * @CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE:
+ *
+ * Pointer accessibility timeout type.
+ *
+ */
+typedef enum {
+  CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK,
+  CLUTTER_A11Y_TIMEOUT_TYPE_DWELL,
+  CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE,
+} ClutterPointerA11yTimeoutType;
+
+/**
  * ClutterActorFlags:
  * @CLUTTER_ACTOR_MAPPED: the actor will be painted (is visible, and inside
  *   a toplevel, and all parents visible)
@@ -892,8 +956,6 @@ typedef enum /*< prefix=CLUTTER_SCROLL >*/
 
 /**
  * ClutterStageState:
- * @CLUTTER_STAGE_STATE_FULLSCREEN: Fullscreen mask
- * @CLUTTER_STAGE_STATE_OFFSCREEN: Offscreen mask (deprecated)
  * @CLUTTER_STAGE_STATE_ACTIVATED: Activated mask
  *
  * Stage state masks, used by the #ClutterEvent of type %CLUTTER_STAGE_STATE.
@@ -902,19 +964,15 @@ typedef enum /*< prefix=CLUTTER_SCROLL >*/
  */
 typedef enum
 {
-  CLUTTER_STAGE_STATE_FULLSCREEN       = (1 << 1),
-  CLUTTER_STAGE_STATE_OFFSCREEN        = (1 << 2),
   CLUTTER_STAGE_STATE_ACTIVATED        = (1 << 3)
 } ClutterStageState;
 
 /**
  * ClutterFeatureFlags:
- * @CLUTTER_FEATURE_TEXTURE_NPOT: Set if NPOTS textures supported.
  * @CLUTTER_FEATURE_SWAP_THROTTLE: Set if backend throttles buffer swaps.
  * @CLUTTER_FEATURE_TEXTURE_YUV: Set if YUV based textures supported.
  * @CLUTTER_FEATURE_TEXTURE_READ_PIXELS: Set if texture pixels can be read.
  * @CLUTTER_FEATURE_STAGE_STATIC: Set if stage size if fixed (i.e framebuffer)
- * @CLUTTER_FEATURE_STAGE_USER_RESIZE: Set if stage is able to be user resized.
  * @CLUTTER_FEATURE_STAGE_CURSOR: Set if stage has a graphical cursor.
  * @CLUTTER_FEATURE_SHADERS_GLSL: Set if the backend supports GLSL shaders.
  * @CLUTTER_FEATURE_OFFSCREEN: Set if the backend supports offscreen rendering.
@@ -928,12 +986,10 @@ typedef enum
  */
 typedef enum
 {
-  CLUTTER_FEATURE_TEXTURE_NPOT           = (1 << 2),
   CLUTTER_FEATURE_SWAP_THROTTLE          = (1 << 3),
   CLUTTER_FEATURE_TEXTURE_YUV            = (1 << 4),
   CLUTTER_FEATURE_TEXTURE_READ_PIXELS    = (1 << 5),
   CLUTTER_FEATURE_STAGE_STATIC           = (1 << 6),
-  CLUTTER_FEATURE_STAGE_USER_RESIZE      = (1 << 7),
   CLUTTER_FEATURE_STAGE_CURSOR           = (1 << 8),
   CLUTTER_FEATURE_SHADERS_GLSL           = (1 << 9),
   CLUTTER_FEATURE_OFFSCREEN              = (1 << 10),
diff --git a/clutter/clutter/clutter-event.c b/clutter/clutter/clutter-event.c
index 8e7782d..8ccf0e8 100644
--- a/clutter/clutter/clutter-event.c
+++ b/clutter/clutter/clutter-event.c
@@ -1021,6 +1021,9 @@ clutter_event_get_event_sequence (const ClutterEvent *event)
       event->type == CLUTTER_TOUCH_END ||
       event->type == CLUTTER_TOUCH_CANCEL)
     return event->touch.sequence;
+  else if (event->type == CLUTTER_ENTER ||
+           event->type == CLUTTER_LEAVE)
+    return event->crossing.sequence;
 
   return NULL;
 }
diff --git a/clutter/clutter/clutter-event.h b/clutter/clutter/clutter-event.h
index 15596d9..54155cd 100644
--- a/clutter/clutter/clutter-event.h
+++ b/clutter/clutter/clutter-event.h
@@ -269,6 +269,7 @@ struct _ClutterCrossingEvent
   gfloat x;
   gfloat y;
   ClutterInputDevice *device;
+  ClutterEventSequence *sequence;
   ClutterActor *related;
 };
 
diff --git a/clutter/clutter/clutter-feature.c b/clutter/clutter/clutter-feature.c
index 6ce7627..5741391 100644
--- a/clutter/clutter/clutter-feature.c
+++ b/clutter/clutter/clutter-feature.c
@@ -64,17 +64,13 @@ clutter_features_from_cogl (guint cogl_flags)
 {
   ClutterFeatureFlags clutter_flags = 0;
   
-  if (cogl_flags & COGL_FEATURE_TEXTURE_NPOT)
-    clutter_flags |= CLUTTER_FEATURE_TEXTURE_NPOT;
-
   if (cogl_flags & COGL_FEATURE_TEXTURE_YUV)
     clutter_flags |= CLUTTER_FEATURE_TEXTURE_YUV;
   
   if (cogl_flags & COGL_FEATURE_TEXTURE_READ_PIXELS)
     clutter_flags |= CLUTTER_FEATURE_TEXTURE_READ_PIXELS;
   
-  if (cogl_flags & COGL_FEATURE_SHADERS_GLSL)
-    clutter_flags |= CLUTTER_FEATURE_SHADERS_GLSL;
+  clutter_flags |= CLUTTER_FEATURE_SHADERS_GLSL;
   
   if (cogl_flags & COGL_FEATURE_OFFSCREEN)
     clutter_flags |= CLUTTER_FEATURE_OFFSCREEN;
diff --git a/clutter/clutter/clutter-input-device.c b/clutter/clutter/clutter-input-device.c
index 0697e3a..c289f81 100644
--- a/clutter/clutter/clutter-input-device.c
+++ b/clutter/clutter/clutter-input-device.c
@@ -107,6 +107,9 @@ clutter_input_device_dispose (GObject *gobject)
       device->associated = NULL;
     }
 
+  if (device->accessibility_virtual_device)
+    g_clear_object (&device->accessibility_virtual_device);
+
   g_clear_pointer (&device->axes, g_array_unref);
   g_clear_pointer (&device->keys, g_array_unref);
   g_clear_pointer (&device->scroll_info, g_array_unref);
@@ -834,6 +837,7 @@ _clutter_input_device_set_actor (ClutterInputDevice   *device,
           event->crossing.x = device->current_x;
           event->crossing.y = device->current_y;
           event->crossing.related = actor;
+          event->crossing.sequence = sequence;
           clutter_event_set_device (event, device);
 
           /* we need to make sure that this event is processed
@@ -870,6 +874,7 @@ _clutter_input_device_set_actor (ClutterInputDevice   *device,
           event->crossing.y = device->current_y;
           event->crossing.source = actor;
           event->crossing.related = old_actor;
+          event->crossing.sequence = sequence;
           clutter_event_set_device (event, device);
 
           /* see above */
@@ -1034,9 +1039,10 @@ _clutter_input_device_update (ClutterInputDevice   *device,
   ClutterActor *new_cursor_actor;
   ClutterActor *old_cursor_actor;
   ClutterPoint point = { -1, -1 };
+  ClutterInputDeviceType device_type = device->device_type;
 
-  if (device->device_type == CLUTTER_KEYBOARD_DEVICE)
-    return NULL;
+  g_assert (device_type != CLUTTER_KEYBOARD_DEVICE &&
+            device_type != CLUTTER_PAD_DEVICE);
 
   stage = device->stage;
   if (G_UNLIKELY (stage == NULL))
diff --git a/clutter/clutter/clutter-input-pointer-a11y-private.h b/clutter/clutter/clutter-input-pointer-a11y-private.h
new file mode 100644
index 0000000..6648909
--- /dev/null
+++ b/clutter/clutter/clutter-input-pointer-a11y-private.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2019 Red Hat
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Author: Olivier Fourdan <[e-mail]>
+ */
+
+#ifndef __CLUTTER_INPUT_POINTER_A11Y_H__
+#define __CLUTTER_INPUT_POINTER_A11Y_H__
+
+#include <clutter/clutter-types.h>
+#include "clutter-enum-types.h"
+
+G_BEGIN_DECLS
+
+void _clutter_input_pointer_a11y_add_device      (ClutterInputDevice   *device);
+void _clutter_input_pointer_a11y_remove_device   (ClutterInputDevice   *device);
+void _clutter_input_pointer_a11y_on_motion_event (ClutterInputDevice   *device,
+                                                  float                 x,
+                                                  float                 y);
+void _clutter_input_pointer_a11y_on_button_event (ClutterInputDevice   *device,
+                                                  int                   button,
+                                                  gboolean              pressed);
+gboolean _clutter_is_input_pointer_a11y_enabled  (ClutterInputDevice     *device);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_INPUT_POINTER_A11Y_H__ */
diff --git a/clutter/clutter/clutter-input-pointer-a11y.c b/clutter/clutter/clutter-input-pointer-a11y.c
new file mode 100644
index 0000000..e55e0a6
--- /dev/null
+++ b/clutter/clutter/clutter-input-pointer-a11y.c
@@ -0,0 +1,669 @@
+/*
+ * Copyright (C) 2019 Red Hat
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Author: Olivier Fourdan <[e-mail]>
+ *
+ * This reimplements in Clutter the same behavior as mousetweaks original
+ * implementation by Gerd Kohlberger <gerdko gmail com>
+ * mousetweaks Copyright (C) 2007-2010 Gerd Kohlberger <gerdko gmail com>
+ */
+
+#include "clutter-build-config.h"
+
+#include "clutter-device-manager.h"
+#include "clutter-device-manager-private.h"
+#include "clutter-enum-types.h"
+#include "clutter-input-device.h"
+#include "clutter-input-pointer-a11y-private.h"
+#include "clutter-main.h"
+#include "clutter-virtual-input-device.h"
+
+static gboolean
+is_secondary_click_enabled (ClutterInputDevice *device)
+{
+  ClutterPointerA11ySettings settings;
+
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
+
+  return (settings.controls & CLUTTER_A11Y_SECONDARY_CLICK_ENABLED);
+}
+
+static gboolean
+is_dwell_click_enabled (ClutterInputDevice *device)
+{
+  ClutterPointerA11ySettings settings;
+
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
+
+  return (settings.controls & CLUTTER_A11Y_DWELL_ENABLED);
+}
+
+static unsigned int
+get_secondary_click_delay (ClutterInputDevice *device)
+{
+  ClutterPointerA11ySettings settings;
+
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
+
+  return settings.secondary_click_delay;
+}
+
+static unsigned int
+get_dwell_delay (ClutterInputDevice *device)
+{
+  ClutterPointerA11ySettings settings;
+
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
+
+  return settings.dwell_delay;
+}
+
+static unsigned int
+get_dwell_threshold (ClutterInputDevice *device)
+{
+  ClutterPointerA11ySettings settings;
+
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
+
+  return settings.dwell_threshold;
+}
+
+static ClutterPointerA11yDwellMode
+get_dwell_mode (ClutterInputDevice *device)
+{
+  ClutterPointerA11ySettings settings;
+
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
+
+  return settings.dwell_mode;
+}
+
+static ClutterPointerA11yDwellClickType
+get_dwell_click_type (ClutterInputDevice *device)
+{
+  ClutterPointerA11ySettings settings;
+
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
+#
+  return settings.dwell_click_type;
+}
+
+static ClutterPointerA11yDwellClickType
+get_dwell_click_type_for_direction (ClutterInputDevice               *device,
+                                    ClutterPointerA11yDwellDirection  direction)
+{
+  ClutterPointerA11ySettings settings;
+
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
+
+  if (direction == settings.dwell_gesture_single)
+    return CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY;
+  else if (direction == settings.dwell_gesture_double)
+    return CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE;
+  else if (direction == settings.dwell_gesture_drag)
+    return CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG;
+  else if (direction == settings.dwell_gesture_secondary)
+    return CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY;
+
+  return CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE;
+}
+
+static void
+emit_button_press (ClutterInputDevice *device,
+                   gint                button)
+{
+  clutter_virtual_input_device_notify_button (device->accessibility_virtual_device,
+                                              g_get_monotonic_time (),
+                                              button,
+                                              CLUTTER_BUTTON_STATE_PRESSED);
+}
+
+static void
+emit_button_release (ClutterInputDevice *device,
+                     gint                button)
+{
+  clutter_virtual_input_device_notify_button (device->accessibility_virtual_device,
+                                              g_get_monotonic_time (),
+                                              button,
+                                              CLUTTER_BUTTON_STATE_RELEASED);
+}
+
+static void
+emit_button_click (ClutterInputDevice *device,
+                   gint                button)
+{
+  emit_button_press (device, button);
+  emit_button_release (device, button);
+}
+
+static void
+restore_dwell_position (ClutterInputDevice *device)
+{
+  clutter_virtual_input_device_notify_absolute_motion (device->accessibility_virtual_device,
+                                                       g_get_monotonic_time (),
+                                                       device->ptr_a11y_data->dwell_x,
+                                                       device->ptr_a11y_data->dwell_y);
+}
+
+static gboolean
+trigger_secondary_click (gpointer data)
+{
+  ClutterInputDevice *device = data;
+
+  device->ptr_a11y_data->secondary_click_triggered = TRUE;
+  device->ptr_a11y_data->secondary_click_timer = 0;
+
+  g_signal_emit_by_name (device->device_manager,
+                         "ptr-a11y-timeout-stopped",
+                         device,
+                         CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK);
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+start_secondary_click_timeout (ClutterInputDevice *device)
+{
+  unsigned int delay = get_secondary_click_delay (device);
+
+  device->ptr_a11y_data->secondary_click_timer =
+    clutter_threads_add_timeout (delay, trigger_secondary_click, device);
+
+  g_signal_emit_by_name (device->device_manager,
+                         "ptr-a11y-timeout-started",
+                         device,
+                         CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK,
+                         delay);
+}
+
+static void
+stop_secondary_click_timeout (ClutterInputDevice *device)
+{
+  if (device->ptr_a11y_data->secondary_click_timer)
+    {
+      g_source_remove (device->ptr_a11y_data->secondary_click_timer);
+      device->ptr_a11y_data->secondary_click_timer = 0;
+
+      g_signal_emit_by_name (device->device_manager,
+                             "ptr-a11y-timeout-stopped",
+                             device,
+                             CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK);
+    }
+  device->ptr_a11y_data->secondary_click_triggered = FALSE;
+}
+
+static gboolean
+pointer_has_moved (ClutterInputDevice *device)
+{
+  float dx, dy;
+  gint threshold;
+
+  dx = device->ptr_a11y_data->dwell_x - device->ptr_a11y_data->current_x;
+  dy = device->ptr_a11y_data->dwell_y - device->ptr_a11y_data->current_y;
+  threshold = get_dwell_threshold (device);
+
+  /* Pythagorean theorem */
+  return ((dx * dx) + (dy * dy)) > (threshold * threshold);
+}
+
+static gboolean
+is_secondary_click_pending (ClutterInputDevice *device)
+{
+  return device->ptr_a11y_data->secondary_click_timer != 0;
+}
+
+static gboolean
+is_secondary_click_triggered (ClutterInputDevice *device)
+{
+  return device->ptr_a11y_data->secondary_click_triggered;
+}
+
+static gboolean
+is_dwell_click_pending (ClutterInputDevice *device)
+{
+  return device->ptr_a11y_data->dwell_timer != 0;
+}
+
+static gboolean
+is_dwell_dragging (ClutterInputDevice *device)
+{
+  return device->ptr_a11y_data->dwell_drag_started;
+}
+
+static gboolean
+is_dwell_gesturing (ClutterInputDevice *device)
+{
+  return device->ptr_a11y_data->dwell_gesture_started;
+}
+
+static gboolean
+has_button_pressed (ClutterInputDevice *device)
+{
+  return device->ptr_a11y_data->n_btn_pressed > 0;
+}
+
+static gboolean
+should_start_secondary_click_timeout (ClutterInputDevice *device)
+{
+  return !is_dwell_dragging (device);
+}
+
+static gboolean
+should_start_dwell (ClutterInputDevice *device)
+{
+  /* We should trigger a dwell if we've not already started one, and if
+   * no button is currently pressed or we are in the middle of a dwell
+   * drag action.
+   */
+  return !is_dwell_click_pending (device) &&
+         (is_dwell_dragging (device) ||
+          !has_button_pressed (device));
+}
+
+static gboolean
+should_stop_dwell (ClutterInputDevice *device)
+{
+  /* We should stop a dwell if the motion exceeds the threshold, unless
+   * we've started a gesture, because we want to keep the original dwell
+   * location to both detect a gesture and restore the original pointer
+   * location once the gesture is finished.
+   */
+  return pointer_has_moved (device) &&
+         !is_dwell_gesturing (device);
+}
+
+
+static gboolean
+should_update_dwell_position (ClutterInputDevice *device)
+{
+  return !is_dwell_gesturing (device) &&
+         !is_dwell_click_pending (device) &&
+         !is_secondary_click_pending (device);
+}
+
+static void
+update_dwell_click_type (ClutterInputDevice *device)
+{
+  ClutterPointerA11ySettings settings;
+  ClutterPointerA11yDwellClickType dwell_click_type;
+
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
+
+  dwell_click_type = settings.dwell_click_type;
+  switch (dwell_click_type)
+    {
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE:
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY:
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_MIDDLE:
+      dwell_click_type = CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY;
+      break;
+
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG:
+      if (!is_dwell_dragging (device))
+        dwell_click_type = CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY;
+      break;
+
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY:
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE:
+    default:
+      break;
+    }
+
+  if (dwell_click_type != settings.dwell_click_type)
+    {
+      settings.dwell_click_type = dwell_click_type;
+      clutter_device_manager_set_pointer_a11y_settings (device->device_manager,
+                                                        &settings);
+
+      g_signal_emit_by_name (device->device_manager,
+                             "ptr-a11y-dwell-click-type-changed",
+                             dwell_click_type);
+    }
+}
+
+static void
+emit_dwell_click (ClutterInputDevice               *device,
+                  ClutterPointerA11yDwellClickType  dwell_click_type)
+{
+  switch (dwell_click_type)
+    {
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY:
+      emit_button_click (device, CLUTTER_BUTTON_PRIMARY);
+      break;
+
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE:
+      emit_button_click (device, CLUTTER_BUTTON_PRIMARY);
+      emit_button_click (device, CLUTTER_BUTTON_PRIMARY);
+      break;
+
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG:
+      if (is_dwell_dragging (device))
+        {
+          emit_button_release (device, CLUTTER_BUTTON_PRIMARY);
+          device->ptr_a11y_data->dwell_drag_started = FALSE;
+        }
+      else
+        {
+          emit_button_press (device, CLUTTER_BUTTON_PRIMARY);
+          device->ptr_a11y_data->dwell_drag_started = TRUE;
+        }
+      break;
+
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY:
+      emit_button_click (device, CLUTTER_BUTTON_SECONDARY);
+      break;
+
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_MIDDLE:
+      emit_button_click (device, CLUTTER_BUTTON_MIDDLE);
+      break;
+
+    case CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE:
+    default:
+      break;
+    }
+}
+
+static ClutterPointerA11yDwellDirection
+get_dwell_direction (ClutterInputDevice *device)
+{
+  float dx, dy;
+
+  dx = ABS (device->ptr_a11y_data->dwell_x - device->ptr_a11y_data->current_x);
+  dy = ABS (device->ptr_a11y_data->dwell_y - device->ptr_a11y_data->current_y);
+
+  /* The pointer hasn't moved */
+  if (!pointer_has_moved (device))
+    return CLUTTER_A11Y_DWELL_DIRECTION_NONE;
+
+  if (device->ptr_a11y_data->dwell_x < device->ptr_a11y_data->current_x)
+    {
+      if (dx > dy)
+        return CLUTTER_A11Y_DWELL_DIRECTION_LEFT;
+    }
+  else
+    {
+      if (dx > dy)
+        return CLUTTER_A11Y_DWELL_DIRECTION_RIGHT;
+    }
+
+  if (device->ptr_a11y_data->dwell_y < device->ptr_a11y_data->current_y)
+    return CLUTTER_A11Y_DWELL_DIRECTION_UP;
+
+  return CLUTTER_A11Y_DWELL_DIRECTION_DOWN;
+}
+
+static gboolean
+trigger_clear_dwell_gesture (gpointer data)
+{
+  ClutterInputDevice *device = data;
+
+  device->ptr_a11y_data->dwell_timer = 0;
+  device->ptr_a11y_data->dwell_gesture_started = FALSE;
+
+  return G_SOURCE_REMOVE;
+}
+
+static gboolean
+trigger_dwell_gesture (gpointer data)
+{
+  ClutterInputDevice *device = data;
+  ClutterPointerA11yDwellDirection direction;
+  unsigned int delay = get_dwell_delay (device);
+
+  restore_dwell_position (device);
+  direction = get_dwell_direction (device);
+  emit_dwell_click (device,
+                    get_dwell_click_type_for_direction (device,
+                                                        direction));
+
+  /* Do not clear the gesture right away, otherwise we'll start another one */
+  device->ptr_a11y_data->dwell_timer =
+    clutter_threads_add_timeout (delay, trigger_clear_dwell_gesture, device);
+
+  g_signal_emit_by_name (device->device_manager,
+                         "ptr-a11y-timeout-stopped",
+                         device,
+                         CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE);
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+start_dwell_gesture_timeout (ClutterInputDevice *device)
+{
+  unsigned int delay = get_dwell_delay (device);
+
+  device->ptr_a11y_data->dwell_timer =
+    clutter_threads_add_timeout (delay, trigger_dwell_gesture, device);
+  device->ptr_a11y_data->dwell_gesture_started = TRUE;
+
+  g_signal_emit_by_name (device->device_manager,
+                         "ptr-a11y-timeout-started",
+                         device,
+                         CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE,
+                         delay);
+}
+
+static gboolean
+trigger_dwell_click (gpointer data)
+{
+  ClutterInputDevice *device = data;
+
+  device->ptr_a11y_data->dwell_timer = 0;
+
+  g_signal_emit_by_name (device->device_manager,
+                         "ptr-a11y-timeout-stopped",
+                         device,
+                         CLUTTER_A11Y_TIMEOUT_TYPE_DWELL);
+
+  if (get_dwell_mode (device) == CLUTTER_A11Y_DWELL_MODE_GESTURE)
+    {
+      if (is_dwell_dragging (device))
+        emit_dwell_click (device, CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG);
+      else
+        start_dwell_gesture_timeout (device);
+    }
+  else
+    {
+      emit_dwell_click (device, get_dwell_click_type (device));
+      update_dwell_click_type (device);
+    }
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+start_dwell_timeout (ClutterInputDevice *device)
+{
+  unsigned int delay = get_dwell_delay (device);
+
+  device->ptr_a11y_data->dwell_timer =
+    clutter_threads_add_timeout (delay, trigger_dwell_click, device);
+
+  g_signal_emit_by_name (device->device_manager,
+                         "ptr-a11y-timeout-started",
+                         device,
+                         CLUTTER_A11Y_TIMEOUT_TYPE_DWELL,
+                         delay);
+}
+
+static void
+stop_dwell_timeout (ClutterInputDevice *device)
+{
+  if (device->ptr_a11y_data->dwell_timer)
+    {
+      g_source_remove (device->ptr_a11y_data->dwell_timer);
+      device->ptr_a11y_data->dwell_timer = 0;
+      device->ptr_a11y_data->dwell_gesture_started = FALSE;
+
+      g_signal_emit_by_name (device->device_manager,
+                             "ptr-a11y-timeout-stopped",
+                             device,
+                             CLUTTER_A11Y_TIMEOUT_TYPE_DWELL);
+    }
+}
+
+static void
+update_dwell_position (ClutterInputDevice *device)
+{
+  device->ptr_a11y_data->dwell_x = device->ptr_a11y_data->current_x;
+  device->ptr_a11y_data->dwell_y = device->ptr_a11y_data->current_y;
+}
+
+static void
+update_current_position (ClutterInputDevice *device,
+                         float               x,
+                         float               y)
+{
+  device->ptr_a11y_data->current_x = x;
+  device->ptr_a11y_data->current_y = y;
+}
+
+static gboolean
+is_device_core_pointer (ClutterInputDevice *device)
+{
+  ClutterInputDevice *core_pointer;
+
+  core_pointer = clutter_device_manager_get_core_device (device->device_manager,
+                                                         CLUTTER_POINTER_DEVICE);
+  if (core_pointer == NULL)
+    return FALSE;
+
+  return (core_pointer == device);
+}
+
+void
+_clutter_input_pointer_a11y_add_device (ClutterInputDevice *device)
+{
+  if (!is_device_core_pointer (device))
+    return;
+
+  device->accessibility_virtual_device =
+    clutter_device_manager_create_virtual_device (device->device_manager,
+                                                  CLUTTER_POINTER_DEVICE);
+
+  device->ptr_a11y_data = g_new0 (ClutterPtrA11yData, 1);
+}
+
+void
+_clutter_input_pointer_a11y_remove_device (ClutterInputDevice *device)
+{
+  if (!is_device_core_pointer (device))
+    return;
+
+  /* Terminate a drag if started */
+  if (is_dwell_dragging (device))
+    emit_dwell_click (device, CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG);
+
+  stop_dwell_timeout (device);
+  stop_secondary_click_timeout (device);
+
+  g_clear_pointer (&device->ptr_a11y_data, g_free);
+}
+
+void
+_clutter_input_pointer_a11y_on_motion_event (ClutterInputDevice *device,
+                                             float               x,
+                                             float               y)
+{
+  if (!is_device_core_pointer (device))
+    return;
+
+  if (!_clutter_is_input_pointer_a11y_enabled (device))
+    return;
+
+  update_current_position (device, x, y);
+
+  if (is_secondary_click_enabled (device))
+    {
+      if (pointer_has_moved (device))
+        stop_secondary_click_timeout (device);
+    }
+
+  if (is_dwell_click_enabled (device))
+    {
+      if (should_stop_dwell (device))
+        stop_dwell_timeout (device);
+      else if (should_start_dwell (device))
+        start_dwell_timeout (device);
+    }
+
+  if (should_update_dwell_position (device))
+    update_dwell_position (device);
+}
+
+void
+_clutter_input_pointer_a11y_on_button_event (ClutterInputDevice *device,
+                                             int                 button,
+                                             gboolean            pressed)
+{
+  if (!is_device_core_pointer (device))
+    return;
+
+  if (!_clutter_is_input_pointer_a11y_enabled (device))
+    return;
+
+  if (pressed)
+    {
+      device->ptr_a11y_data->n_btn_pressed++;
+
+      if (is_dwell_click_enabled (device))
+        stop_dwell_timeout (device);
+
+      if (is_dwell_dragging (device))
+        stop_dwell_timeout (device);
+
+      if (is_secondary_click_enabled (device))
+        {
+          if (button == CLUTTER_BUTTON_PRIMARY)
+            {
+              if (should_start_secondary_click_timeout (device))
+                start_secondary_click_timeout (device);
+            }
+          else if (is_secondary_click_pending (device))
+            {
+              stop_secondary_click_timeout (device);
+            }
+        }
+    }
+  else
+    {
+      if (has_button_pressed (device))
+        device->ptr_a11y_data->n_btn_pressed--;
+
+      if (is_secondary_click_triggered (device))
+        {
+          emit_button_click (device, CLUTTER_BUTTON_SECONDARY);
+          stop_secondary_click_timeout (device);
+        }
+
+      if (is_secondary_click_pending (device))
+        stop_secondary_click_timeout (device);
+
+      if (is_dwell_dragging (device))
+        emit_dwell_click (device, CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG);
+    }
+}
+
+gboolean
+_clutter_is_input_pointer_a11y_enabled (ClutterInputDevice *device)
+{
+  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), FALSE);
+
+  return (is_secondary_click_enabled (device) || is_dwell_click_enabled (device));
+}
diff --git a/clutter/clutter/clutter-main.c b/clutter/clutter/clutter-main.c
index 71ec0d8..0fad6c6 100644
--- a/clutter/clutter/clutter-main.c
+++ b/clutter/clutter/clutter-main.c
@@ -58,6 +58,7 @@
 #include "clutter-device-manager-private.h"
 #include "clutter-event-private.h"
 #include "clutter-feature.h"
+#include "clutter-input-pointer-a11y-private.h"
 #include "clutter-main.h"
 #include "clutter-master-clock.h"
 #include "clutter-mutter.h"
@@ -84,8 +85,6 @@ G_LOCK_DEFINE_STATIC (ClutterCntx);
 
 /* main lock and locking/unlocking functions */
 static GMutex clutter_threads_mutex;
-static GCallback clutter_threads_lock        = NULL;
-static GCallback clutter_threads_unlock      = NULL;
 
 /* command line options */
 static gboolean clutter_is_initialized       = FALSE;
@@ -145,38 +144,10 @@ static const GDebugKey clutter_paint_debug_keys[] = {
   { "damage-region", CLUTTER_DEBUG_PAINT_DAMAGE_REGION },
 };
 
-static void
-clutter_threads_impl_lock (void)
-{
-  g_mutex_lock (&clutter_threads_mutex);
-}
-
-static void
-clutter_threads_impl_unlock (void)
-{
-  /* we need to trylock here, in case the lock hasn't been acquired; on
-   * various systems trying to release a mutex that hasn't been acquired
-   * will cause a run-time error. trylock() will either fail, in which
-   * case we can release the lock we own; or it will succeeds, in which
-   * case we need to release the lock we just acquired. so we ignore the
-   * returned value.
-   *
-   * see: https://bugs.gnome.org/679439
-   */
-  g_mutex_trylock (&clutter_threads_mutex);
-  g_mutex_unlock (&clutter_threads_mutex);
-}
-
 static inline void
 clutter_threads_init_default (void)
 {
   g_mutex_init (&clutter_threads_mutex);
-
-  if (clutter_threads_lock == NULL)
-    clutter_threads_lock = clutter_threads_impl_lock;
-
-  if (clutter_threads_unlock == NULL)
-    clutter_threads_unlock = clutter_threads_impl_unlock;
 }
 
 #define ENVIRONMENT_GROUP       "Environment"
@@ -382,28 +353,6 @@ clutter_config_read (void)
   g_free (config_path);
 }
 
-/**
- * clutter_get_show_fps:
- *
- * Returns whether Clutter should print out the frames per second on the
- * console. You can enable this setting either using the
- * <literal>CLUTTER_SHOW_FPS</literal> environment variable or passing
- * the <literal>--clutter-show-fps</literal> command line argument. *
- *
- * Return value: %TRUE if Clutter should show the FPS.
- *
- * Since: 0.4
- *
- * Deprecated: 1.10: This function does not do anything. Use the environment
- *   variable or the configuration file to determine whether Clutter should
- *   print out the FPS counter on the console.
- */
-gboolean
-clutter_get_show_fps (void)
-{
-  return FALSE;
-}
-
 gboolean
 _clutter_context_get_show_fps (void)
 {
@@ -452,86 +401,6 @@ clutter_disable_accessibility (void)
   clutter_enable_accessibility = FALSE;
 }
 
-/**
- * clutter_redraw:
- *
- * Forces a redraw of the entire stage. Applications should never use this
- * function, but queue a redraw using clutter_actor_queue_redraw().
- *
- * This function should only be used by libraries integrating Clutter from
- * within another toolkit.
- *
- * Deprecated: 1.10: Use clutter_stage_ensure_redraw() instead.
- */
-void
-clutter_redraw (ClutterStage *stage)
-{
-  g_return_if_fail (CLUTTER_IS_STAGE (stage));
-
-  clutter_stage_ensure_redraw (stage);
-}
-
-/**
- * clutter_set_motion_events_enabled:
- * @enable: %TRUE to enable per-actor motion events
- *
- * Sets whether per-actor motion events should be enabled or not on
- * all #ClutterStage<!-- -->s managed by Clutter.
- *
- * If @enable is %FALSE the following events will not work:
- *
- *  - ClutterActor::motion-event, except on the #ClutterStage
- *  - ClutterActor::enter-event
- *  - ClutterActor::leave-event
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use clutter_stage_set_motion_events_enabled() instead.
- */
-void
-clutter_set_motion_events_enabled (gboolean enable)
-{
-  ClutterStageManager *stage_manager;
-  ClutterMainContext *context;
-  const GSList *l;
-
-  enable = !!enable;
-
-  context = _clutter_context_get_default ();
-  if (context->motion_events_per_actor == enable)
-    return;
-
-  /* store the flag for later query and for newly created stages */
-  context->motion_events_per_actor = enable;
-
-  /* propagate the change to all stages */
-  stage_manager = clutter_stage_manager_get_default ();
-
-  for (l = clutter_stage_manager_peek_stages (stage_manager);
-       l != NULL;
-       l = l->next)
-    {
-      clutter_stage_set_motion_events_enabled (l->data, enable);
-    }
-}
-
-/**
- * clutter_get_motion_events_enabled:
- *
- * Gets whether the per-actor motion events are enabled.
- *
- * Return value: %TRUE if the motion events are enabled
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use clutter_stage_get_motion_events_enabled() instead.
- */
-gboolean
-clutter_get_motion_events_enabled (void)
-{
-  return _clutter_context_get_motion_events_enabled ();
-}
-
 void
 _clutter_id_to_color (guint         id_,
                       ClutterColor *col)
@@ -783,69 +652,6 @@ clutter_main (void)
   clutter_main_loop_level--;
 }
 
-/**
- * clutter_threads_init:
- *
- * Initialises the Clutter threading mechanism, so that Clutter API can be
- * called by multiple threads, using clutter_threads_enter() and
- * clutter_threads_leave() to mark the critical sections.
- *
- * You must call g_thread_init() before this function.
- *
- * This function must be called before clutter_init().
- *
- * It is safe to call this function multiple times.
- *
- * Since: 0.4
- *
- * Deprecated: 1.10: This function does not do anything. Threading support
- *   is initialized when Clutter is initialized.
- */
-void
-clutter_threads_init (void)
-{
-}
-
-/**
- * clutter_threads_set_lock_functions: (skip)
- * @enter_fn: function called when aquiring the Clutter main lock
- * @leave_fn: function called when releasing the Clutter main lock
- *
- * Allows the application to replace the standard method that
- * Clutter uses to protect its data structures. Normally, Clutter
- * creates a single #GMutex that is locked by clutter_threads_enter(),
- * and released by clutter_threads_leave(); using this function an
- * application provides, instead, a function @enter_fn that is
- * called by clutter_threads_enter() and a function @leave_fn that is
- * called by clutter_threads_leave().
- *
- * The functions must provide at least same locking functionality
- * as the default implementation, but can also do extra application
- * specific processing.
- *
- * As an example, consider an application that has its own recursive
- * lock that when held, holds the Clutter lock as well. When Clutter
- * unlocks the Clutter lock when entering a recursive main loop, the
- * application must temporarily release its lock as well.
- *
- * Most threaded Clutter apps won't need to use this method.
- *
- * This method must be called before clutter_init(), and cannot
- * be called multiple times.
- *
- * Since: 0.4
- */
-void
-clutter_threads_set_lock_functions (GCallback enter_fn,
-                                    GCallback leave_fn)
-{
-  g_return_if_fail (clutter_threads_lock == NULL &&
-                    clutter_threads_unlock == NULL);
-
-  clutter_threads_lock = enter_fn;
-  clutter_threads_unlock = leave_fn;
-}
-
 gboolean
 _clutter_threads_dispatch (gpointer data)
 {
@@ -902,17 +708,11 @@ _clutter_threads_dispatch_free (gpointer data)
  *    SafeClosure *closure = data;
  *    gboolean res = FALSE;
  *
- *    // mark the critical section //
- *
- *    clutter_threads_enter();
- *
  *    // the callback does not need to acquire the Clutter
  *     / lock itself, as it is held by the this proxy handler
  *     //
  *    res = closure->callback (closure->data);
  *
- *    clutter_threads_leave();
- *
  *    return res;
  * }
  * static gulong
@@ -1092,69 +892,23 @@ clutter_threads_add_timeout (guint       interval,
 void
 _clutter_threads_acquire_lock (void)
 {
-  if (clutter_threads_lock != NULL)
-    (* clutter_threads_lock) ();
+  g_mutex_lock (&clutter_threads_mutex);
 }
 
 void
 _clutter_threads_release_lock (void)
 {
-  if (clutter_threads_unlock != NULL)
-    (* clutter_threads_unlock) ();
-}
-
-/**
- * clutter_threads_enter:
- *
- * Locks the Clutter thread lock.
- *
- * Since: 0.4
- *
- * Deprecated: 1.12: This function should not be used by application
- *   code; marking critical sections is not portable on various
- *   platforms. Instead of acquiring the Clutter lock, schedule UI
- *   updates from the main loop using clutter_threads_add_idle() or
- *   clutter_threads_add_timeout().
- */
-void
-clutter_threads_enter (void)
-{
-  _clutter_threads_acquire_lock ();
-}
-
-/**
- * clutter_threads_leave:
- *
- * Unlocks the Clutter thread lock.
- *
- * Since: 0.4
- *
- * Deprecated: 1.12: This function should not be used by application
- *   code; marking critical sections is not portable on various
- *   platforms. Instead of acquiring the Clutter lock, schedule UI
- *   updates from the main loop using clutter_threads_add_idle() or
- *   clutter_threads_add_timeout().
- */
-void
-clutter_threads_leave (void)
-{
-  _clutter_threads_release_lock ();
-}
-
-
-/**
- * clutter_get_debug_enabled:
- *
- * Check if Clutter has debugging enabled.
- *
- * Return value: %FALSE
- *
- * Deprecated: 1.10: This function does not do anything.
- */
-gboolean
-clutter_get_debug_enabled (void)
-{
-  return FALSE;
+  /* we need to trylock here, in case the lock hasn't been acquired; on
+   * various systems trying to release a mutex that hasn't been acquired
+   * will cause a run-time error. trylock() will either fail, in which
+   * case we can release the lock we own; or it will succeeds, in which
+   * case we need to release the lock we just acquired. so we ignore the
+   * returned value.
+   *
+   * see: https://bugs.gnome.org/679439
+   */
+  g_mutex_trylock (&clutter_threads_mutex);
+  g_mutex_unlock (&clutter_threads_mutex);
 }
 
 void
@@ -1204,7 +958,6 @@ clutter_context_get_default_unlocked (void)
       ctx->settings = clutter_settings_get_default ();
       _clutter_settings_set_backend (ctx->settings, ctx->backend);
 
-      ctx->motion_events_per_actor = TRUE;
       ctx->last_repaint_id = 1;
     }
 
@@ -1225,36 +978,6 @@ _clutter_context_get_default (void)
   return retval;
 }
 
-/**
- * clutter_get_timestamp:
- *
- * Returns the approximate number of microseconds passed since Clutter was
- * intialised.
- *
- * This function shdould not be used by application code.
- *
- * The output of this function depends on whether Clutter was configured to
- * enable its debugging code paths, so it's less useful than intended.
- *
- * Since Clutter 1.10, this function is an alias to g_get_monotonic_time()
- * if Clutter was configured to enable the debugging code paths.
- *
- * Return value: Number of microseconds since clutter_init() was called, or
- *   zero if Clutter was not configured with debugging code paths.
- *
- * Deprecated: 1.10: Use #GTimer or g_get_monotonic_time() for a proper
- *   timing source
- */
-gulong
-clutter_get_timestamp (void)
-{
-#ifdef CLUTTER_ENABLE_DEBUG
-  return (gulong) g_get_monotonic_time ();
-#else
-  return 0L;
-#endif
-}
-
 static gboolean
 clutter_arg_direction_cb (const char *key,
                           const char *value,
@@ -2005,6 +1728,36 @@ emit_pointer_event (ClutterEvent       *event,
 }
 
 static inline void
+emit_crossing_event (ClutterEvent       *event,
+                     ClutterInputDevice *device)
+{
+  ClutterMainContext *context = _clutter_context_get_default ();
+  ClutterEventSequence *sequence = clutter_event_get_event_sequence (event);
+  ClutterActor *grab_actor = NULL;
+
+  if (_clutter_event_process_filters (event))
+    return;
+
+  if (sequence)
+    {
+      if (device->sequence_grab_actors != NULL)
+        grab_actor = g_hash_table_lookup (device->sequence_grab_actors, sequence);
+    }
+  else
+    {
+      if (context->pointer_grab_actor != NULL)
+        grab_actor = context->pointer_grab_actor;
+      else if (device != NULL && device->pointer_grab_actor != NULL)
+        grab_actor = device->pointer_grab_actor;
+    }
+
+  if (grab_actor != NULL)
+    clutter_actor_event (grab_actor, event, FALSE);
+  else
+    emit_event_chain (event);
+}
+
+static inline void
 emit_touch_event (ClutterEvent       *event,
                   ClutterInputDevice *device)
 {
@@ -2177,7 +1930,7 @@ _clutter_process_event_details (ClutterActor        *stage,
           {
             ClutterActor *actor = NULL;
 
-            emit_pointer_event (event, device);
+            emit_crossing_event (event, device);
 
             actor = _clutter_input_device_update (device, NULL, FALSE);
             if (actor != stage)
@@ -2189,12 +1942,12 @@ _clutter_process_event_details (ClutterActor        *stage,
                 crossing->crossing.related = stage;
                 crossing->crossing.source = actor;
 
-                emit_pointer_event (crossing, device);
+                emit_crossing_event (crossing, device);
                 clutter_event_free (crossing);
               }
           }
         else
-          emit_pointer_event (event, device);
+          emit_crossing_event (event, device);
         break;
 
       case CLUTTER_LEAVE:
@@ -2213,10 +1966,10 @@ _clutter_process_event_details (ClutterActor        *stage,
             crossing->crossing.related = stage;
             crossing->crossing.source = device->cursor_actor;
 
-            emit_pointer_event (crossing, device);
+            emit_crossing_event (crossing, device);
             clutter_event_free (crossing);
           }
-        emit_pointer_event (event, device);
+        emit_crossing_event (event, device);
         break;
 
       case CLUTTER_DESTROY_NOTIFY:
@@ -2231,6 +1984,21 @@ _clutter_process_event_details (ClutterActor        *stage,
         break;
 
       case CLUTTER_MOTION:
+#ifdef CLUTTER_WINDOWING_X11
+        if (!clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))
+          {
+            if (_clutter_is_input_pointer_a11y_enabled (device))
+              {
+                ClutterInputDevice *core_pointer;
+                gfloat x, y;
+
+                clutter_event_get_coords (event, &x, &y);
+                core_pointer = clutter_device_manager_get_core_device (device->device_manager,
+                                                                       CLUTTER_POINTER_DEVICE);
+                _clutter_input_pointer_a11y_on_motion_event (core_pointer, x, y);
+              }
+          }
+#endif /* CLUTTER_WINDOWING_X11 */
         /* only the stage gets motion events if they are enabled */
         if (!clutter_stage_get_motion_events_enabled (CLUTTER_STAGE (stage)) &&
             event->any.source == NULL)
@@ -2269,6 +2037,22 @@ _clutter_process_event_details (ClutterActor        *stage,
       /* fallthrough from motion */
       case CLUTTER_BUTTON_PRESS:
       case CLUTTER_BUTTON_RELEASE:
+#ifdef CLUTTER_WINDOWING_X11
+        if (!clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))
+          {
+            if (_clutter_is_input_pointer_a11y_enabled (device) && (event->type != CLUTTER_MOTION))
+              {
+                ClutterInputDevice *core_pointer;
+
+                core_pointer = clutter_device_manager_get_core_device (device->device_manager,
+                                                                       CLUTTER_POINTER_DEVICE);
+
+                _clutter_input_pointer_a11y_on_button_event (core_pointer,
+                                                             event->button.button,
+                                                             event->type == CLUTTER_BUTTON_PRESS);
+              }
+          }
+#endif /* CLUTTER_WINDOWING_X11 */
       case CLUTTER_SCROLL:
       case CLUTTER_TOUCHPAD_PINCH:
       case CLUTTER_TOUCHPAD_SWIPE:
@@ -2490,7 +2274,7 @@ _clutter_process_event_details (ClutterActor        *stage,
         break;
 
       case CLUTTER_STAGE_STATE:
-        /* fullscreen / focus - forward to stage */
+        /* focus - forward to stage */
         event->any.source = stage;
         if (!_clutter_event_process_filters (event))
           clutter_stage_event (CLUTTER_STAGE (stage), event);
@@ -2596,24 +2380,6 @@ clutter_get_default_frame_rate (void)
   return context->frame_rate;
 }
 
-/**
- * clutter_set_default_frame_rate:
- * @frames_per_sec: the new default frame rate
- *
- * Sets the default frame rate. This frame rate will be used to limit
- * the number of frames drawn if Clutter is not able to synchronize
- * with the vertical refresh rate of the display. When synchronization
- * is possible, this value is ignored.
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: This function does not do anything any more.
- */
-void
-clutter_set_default_frame_rate (guint frames_per_sec)
-{
-}
-
 static void
 on_grab_actor_destroy (ClutterActor       *actor,
                        ClutterInputDevice *device)
@@ -2829,57 +2595,6 @@ clutter_input_device_get_grabbed_actor (ClutterInputDevice *device)
 }
 
 /**
- * clutter_grab_pointer_for_device:
- * @actor: a #ClutterActor
- * @id_: a device id, or -1
- *
- * Grabs all the pointer events coming from the device @id for @actor.
- *
- * If @id is -1 then this function is equivalent to clutter_grab_pointer().
- *
- * Since: 0.8
- *
- * Deprecated: 1.10: Use clutter_input_device_grab() instead.
- */
-void
-clutter_grab_pointer_for_device (ClutterActor *actor,
-                                 gint          id_)
-{
-  ClutterDeviceManager *manager;
-  ClutterInputDevice *dev;
-
-  g_return_if_fail (actor == NULL || CLUTTER_IS_ACTOR (actor));
-
-  /* essentially a global grab */
-  if (id_ == -1)
-    {
-      if (actor == NULL)
-        clutter_ungrab_pointer ();
-      else
-        clutter_grab_pointer (actor);
-
-      return;
-    }
-
-  manager = clutter_device_manager_get_default ();
-  if (manager == NULL)
-    return;
-
-  dev = clutter_device_manager_get_device (manager, id_);
-  if (dev == NULL)
-    return;
-
-  if (dev->device_type != CLUTTER_POINTER_DEVICE)
-    return;
-
-  if (actor == NULL)
-    clutter_input_device_ungrab (dev);
-  else
-    clutter_input_device_grab (dev, actor);
-}
-
-
-/**
  * clutter_ungrab_pointer:
  *
  * Removes an existing grab of the pointer.
@@ -2893,32 +2608,6 @@ clutter_ungrab_pointer (void)
 }
 
 /**
- * clutter_ungrab_pointer_for_device:
- * @id_: a device id
- *
- * Removes an existing grab of the pointer events for device @id_.
- *
- * Since: 0.8
- *
- * Deprecated: 1.10: Use clutter_input_device_ungrab() instead.
- */
-void
-clutter_ungrab_pointer_for_device (gint id_)
-{
-  ClutterDeviceManager *manager;
-  ClutterInputDevice *device;
-
-  manager = clutter_device_manager_get_default ();
-  if (manager == NULL)
-    return;
-
-  device = clutter_device_manager_get_device (manager, id_);
-  if (device != NULL)
-    clutter_input_device_ungrab (device);
-}
-
-
-/**
  * clutter_get_pointer_grab:
  *
  * Queries the current pointer grab of clutter.
@@ -3018,170 +2707,6 @@ clutter_get_keyboard_grab (void)
 }
 
 /**
- * clutter_clear_glyph_cache:
- *
- * Clears the internal cache of glyphs used by the Pango
- * renderer. This will free up some memory and GL texture
- * resources. The cache will be automatically refilled as more text is
- * drawn.
- *
- * Since: 0.8
- *
- * Deprecated: 1.10: Use clutter_get_font_map() and
- *   cogl_pango_font_map_clear_glyph_cache() instead.
- */
-void
-clutter_clear_glyph_cache (void)
-{
-  CoglPangoFontMap *font_map;
-
-  font_map = clutter_context_get_pango_fontmap ();
-  cogl_pango_font_map_clear_glyph_cache (font_map);
-}
-
-/**
- * clutter_set_font_flags:
- * @flags: The new flags
- *
- * Sets the font quality options for subsequent text rendering
- * operations.
- *
- * Using mipmapped textures will improve the quality for scaled down
- * text but will use more texture memory.
- *
- * Enabling hinting improves text quality for static text but may
- * introduce some artifacts if the text is animated.
- *
- * Since: 1.0
- *
- * Deprecated: 1.10: Use clutter_backend_set_font_options() and the
- *   #cairo_font_option_t API.
- */
-void
-clutter_set_font_flags (ClutterFontFlags flags)
-{
-  CoglPangoFontMap *font_map;
-  ClutterFontFlags old_flags, changed_flags;
-  const cairo_font_options_t *font_options;
-  cairo_font_options_t *new_font_options;
-  cairo_hint_style_t hint_style;
-  gboolean use_mipmapping;
-  ClutterBackend *backend;
-
-  backend = clutter_get_default_backend ();
-  font_map = clutter_context_get_pango_fontmap ();
-  font_options = clutter_backend_get_font_options (backend);
-  old_flags = 0;
-
-  if (cogl_pango_font_map_get_use_mipmapping (font_map))
-    old_flags |= CLUTTER_FONT_MIPMAPPING;
-
-  hint_style = cairo_font_options_get_hint_style (font_options);
-  if (hint_style != CAIRO_HINT_STYLE_DEFAULT &&
-      hint_style != CAIRO_HINT_STYLE_NONE)
-    old_flags |= CLUTTER_FONT_HINTING;
-
-  if (old_flags == flags)
-    return;
-
-  new_font_options = cairo_font_options_copy (font_options);
-
-  /* Only set the font options that have actually changed so we don't
-     override a detailed setting from the backend */
-  changed_flags = old_flags ^ flags;
-
-  if ((changed_flags & CLUTTER_FONT_MIPMAPPING))
-    {
-      use_mipmapping = (changed_flags & CLUTTER_FONT_MIPMAPPING) != 0;
-
-      cogl_pango_font_map_set_use_mipmapping (font_map, use_mipmapping);
-    }
-
-  if ((changed_flags & CLUTTER_FONT_HINTING))
-    {
-      hint_style = (flags & CLUTTER_FONT_HINTING)
-                 ? CAIRO_HINT_STYLE_FULL
-                 : CAIRO_HINT_STYLE_NONE;
-
-      cairo_font_options_set_hint_style (new_font_options, hint_style);
-    }
-
-  clutter_backend_set_font_options (backend, new_font_options);
-
-  cairo_font_options_destroy (new_font_options);
-}
-
-/**
- * clutter_get_font_flags:
- *
- * Gets the current font flags for rendering text. See
- * clutter_set_font_flags().
- *
- * Return value: The font flags
- *
- * Since: 1.0
- *
- * Deprecated: 1.10: Use clutter_backend_get_font_options() and the
- *   #cairo_font_options_t API.
- */
-ClutterFontFlags
-clutter_get_font_flags (void)
-{
-  CoglPangoFontMap *font_map = NULL;
-  const cairo_font_options_t *font_options;
-  ClutterFontFlags flags = 0;
-  cairo_hint_style_t hint_style;
-
-  font_map = clutter_context_get_pango_fontmap ();
-  if (cogl_pango_font_map_get_use_mipmapping (font_map))
-    flags |= CLUTTER_FONT_MIPMAPPING;
-
-  font_options =
-    clutter_backend_get_font_options (clutter_get_default_backend ());
-
-  hint_style = cairo_font_options_get_hint_style (font_options);
-  if (hint_style != CAIRO_HINT_STYLE_DEFAULT &&
-      hint_style != CAIRO_HINT_STYLE_NONE)
-    flags |= CLUTTER_FONT_HINTING;
-
-  return flags;
-}
-
-/**
- * clutter_get_input_device_for_id:
- * @id_: the unique id for a device
- *
- * Retrieves the #ClutterInputDevice from its @id_. This is a convenience
- * wrapper for clutter_device_manager_get_device() and it is functionally
- * equivalent to:
- *
- * |[
- *   ClutterDeviceManager *manager;
- *   ClutterInputDevice *device;
- *
- *   manager = clutter_device_manager_get_default ();
- *   device = clutter_device_manager_get_device (manager, id);
- * ]|
- *
- * Return value: (transfer none): a #ClutterInputDevice, or %NULL
- *
- * Since: 0.8
- *
- * Deprecated: 1.10: Use clutter_device_manager_get_device() instead.
- */
-ClutterInputDevice *
-clutter_get_input_device_for_id (gint id_)
-{
-  ClutterDeviceManager *manager;
-
-  manager = clutter_device_manager_get_default ();
-  if (manager == NULL)
-    return NULL;
-
-  return clutter_device_manager_get_device (manager, id_);
-}
-
-/**
  * clutter_get_font_map:
  *
  * Retrieves the #PangoFontMap instance used by Clutter.
@@ -3515,43 +3040,6 @@ _clutter_context_get_pick_mode (void)
   return context->pick_mode;
 }
 
-void
-_clutter_context_push_shader_stack (ClutterActor *actor)
-{
-  ClutterMainContext *context = _clutter_context_get_default ();
-
-  context->shaders = g_slist_prepend (context->shaders, actor);
-}
-
-ClutterActor *
-_clutter_context_peek_shader_stack (void)
-{
-  ClutterMainContext *context = _clutter_context_get_default ();
-
-  if (context->shaders != NULL)
-    return context->shaders->data;
-
-  return NULL;
-}
-
-ClutterActor *
-_clutter_context_pop_shader_stack (ClutterActor *actor)
-{
-  ClutterMainContext *context = _clutter_context_get_default ();
-
-  context->shaders = g_slist_remove (context->shaders, actor);
-
-  return _clutter_context_peek_shader_stack ();
-}
-
-gboolean
-_clutter_context_get_motion_events_enabled (void)
-{
-  ClutterMainContext *context = _clutter_context_get_default ();
-
-  return context->motion_events_per_actor;
-}
-
 /**
  * clutter_check_windowing_backend:
  * @backend_type: the name of the backend to check
diff --git a/clutter/clutter/clutter-main.h b/clutter/clutter/clutter-main.h
index 6bacc54..70e40f9 100644
--- a/clutter/clutter/clutter-main.h
+++ b/clutter/clutter/clutter-main.h
@@ -117,9 +117,6 @@ void                    clutter_disable_accessibility           (void);
 
 /* Threading functions */
 CLUTTER_EXPORT
-void                    clutter_threads_set_lock_functions      (GCallback enter_fn,
-                                                                 GCallback leave_fn);
-CLUTTER_EXPORT
 guint                   clutter_threads_add_idle                (GSourceFunc    func,
                                                                  gpointer       data);
 CLUTTER_EXPORT
diff --git a/clutter/clutter/clutter-marshal.list b/clutter/clutter/clutter-marshal.list
index acf961e..749ea7c 100644
--- a/clutter/clutter/clutter-marshal.list
+++ b/clutter/clutter/clutter-marshal.list
@@ -23,6 +23,7 @@ VOID:FLOAT,FLOAT
 VOID:INT,INT,INT,INT
 VOID:OBJECT
 VOID:OBJECT,FLAGS
+VOID:OBJECT,FLAGS,UINT
 VOID:OBJECT,FLOAT,FLOAT
 VOID:OBJECT,FLOAT,FLOAT,FLAGS
 VOID:OBJECT,OBJECT
diff --git a/clutter/clutter/clutter-master-clock-default.c b/clutter/clutter/clutter-master-clock-default.c
index 0647c3a..3197a32 100644
--- a/clutter/clutter/clutter-master-clock-default.c
+++ b/clutter/clutter/clutter-master-clock-default.c
@@ -64,9 +64,6 @@ struct _ClutterMasterClockDefault
   /* the current state of the clock, in usecs */
   gint64 cur_tick;
 
-  /* the previous state of the clock, in usecs, used to compute the delta */
-  gint64 prev_tick;
-
 #ifdef CLUTTER_ENABLE_DEBUG
   gint64 frame_budget;
   gint64 remaining_budget;
@@ -77,12 +74,6 @@ struct _ClutterMasterClockDefault
    */
   GSource *source;
 
-  /* If the master clock is idle that means it has
-   * fallen back to idle polling for timeline
-   * progressions and it may have been some time since
-   * the last real stage update.
-   */
-  guint idle : 1;
   guint ensure_next_iteration : 1;
 
   guint paused : 1;
@@ -275,78 +266,12 @@ master_clock_reschedule_stage_updates (ClutterMasterClockDefault *master_clock,
 static gint
 master_clock_next_frame_delay (ClutterMasterClockDefault *master_clock)
 {
-  gint64 now, next;
-  gint swap_delay;
-
   if (!master_clock_is_running (master_clock))
     return -1;
 
   /* If all of the stages are busy waiting for a swap-buffers to complete
    * then we wait for one to be ready.. */
-  swap_delay = master_clock_get_swap_wait_time (master_clock);
-  if (swap_delay != 0)
-    return swap_delay;
-
-  /* When we have sync-to-vblank, we count on swap-buffer requests (or
-   * swap-buffer-complete events if supported in the backend) to throttle our
-   * frame rate so no additional delay is needed to start the next frame.
-   *
-   * If the master-clock has become idle due to no timeline progression causing
-   * redraws then we can no longer rely on vblank synchronization because the
-   * last real stage update/redraw may have happened a long time ago and so we
-   * fallback to polling for timeline progressions every 1/frame_rate seconds.
-   *
-   * (NB: if there aren't even any timelines running then the master clock will
-   * be completely stopped in master_clock_is_running())
-   */
-  if (clutter_feature_available (CLUTTER_FEATURE_SWAP_THROTTLE) &&
-      !master_clock->idle)
-    {
-      CLUTTER_NOTE (SCHEDULER, "swap throttling available and updated stages");
-      return 0;
-    }
-
-  if (master_clock->prev_tick == 0)
-    {
-      /* If we weren't previously running, then draw the next frame
-       * immediately
-       */
-      CLUTTER_NOTE (SCHEDULER, "draw the first frame immediately");
-      return 0;
-    }
-
-  /* Otherwise, wait at least 1/frame_rate seconds since we last
-   * started a frame
-   */
-  now = g_source_get_time (master_clock->source);
-
-  next = master_clock->prev_tick;
-
-  /* If time has gone backwards then there's no way of knowing how
-     long we should wait so let's just dispatch immediately */
-  if (now <= next)
-    {
-      CLUTTER_NOTE (SCHEDULER, "Time has gone backwards");
-
-      return 0;
-    }
-
-  next += (1000000L / clutter_get_default_frame_rate ());
-
-  if (next <= now)
-    {
-      CLUTTER_NOTE (SCHEDULER, "Less than %lu microsecs",
-                    1000000L / (gulong) clutter_get_default_frame_rate ());
-
-      return 0;
-    }
-  else
-    {
-      CLUTTER_NOTE (SCHEDULER, "Waiting %" G_GINT64_FORMAT " msecs",
-                   (next - now) / 1000);
-
-      return (next - now) / 1000;
-    }
+  return master_clock_get_swap_wait_time (master_clock);
 }
 
 static void
@@ -412,8 +337,7 @@ master_clock_advance_timelines (ClutterMasterClockDefault *master_clock)
   for (l = timelines; l != NULL; l = l->next)
     _clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000);
 
-  g_slist_foreach (timelines, (GFunc) g_object_unref, NULL);
-  g_slist_free (timelines);
+  g_slist_free_full (timelines, g_object_unref);
 
 #ifdef CLUTTER_ENABLE_DEBUG
   if (_clutter_diagnostic_enabled ())
@@ -531,7 +455,6 @@ clutter_clock_dispatch (GSource     *source,
 {
   ClutterClockSource *clock_source = (ClutterClockSource *) source;
   ClutterMasterClockDefault *master_clock = clock_source->master_clock;
-  gboolean stages_updated = FALSE;
   GSList *stages;
 
   CLUTTER_NOTE (SCHEDULER, "Master clock [tick]");
@@ -551,8 +474,6 @@ clutter_clock_dispatch (GSource     *source,
    */
   stages = master_clock_list_ready_stages (master_clock);
 
-  master_clock->idle = FALSE;
-
   /* Each frame is split into three separate phases: */
 
   /* 1. process all the events; each stage goes through its events queue
@@ -565,19 +486,11 @@ clutter_clock_dispatch (GSource     *source,
   master_clock_advance_timelines (master_clock);
 
   /* 3. relayout and redraw the stages */
-  stages_updated = master_clock_update_stages (master_clock, stages);
-
-  /* The master clock goes idle if no stages were updated and falls back
-   * to polling for timeline progressions... */
-  if (!stages_updated)
-    master_clock->idle = TRUE;
+  master_clock_update_stages (master_clock, stages);
 
   master_clock_reschedule_stage_updates (master_clock, stages);
 
-  g_slist_foreach (stages, (GFunc) g_object_unref, NULL);
-  g_slist_free (stages);
-
-  master_clock->prev_tick = master_clock->cur_tick;
+  g_slist_free_full (stages, g_object_unref);
 
   _clutter_threads_release_lock ();
 
@@ -610,7 +523,6 @@ clutter_master_clock_default_init (ClutterMasterClockDefault *self)
   source = clutter_clock_source_new (self);
   self->source = source;
 
-  self->idle = FALSE;
   self->ensure_next_iteration = FALSE;
   self->paused = FALSE;
 
diff --git a/clutter/clutter/clutter-paint-nodes.c b/clutter/clutter/clutter-paint-nodes.c
index d5efd58..41c3439 100644
--- a/clutter/clutter/clutter-paint-nodes.c
+++ b/clutter/clutter/clutter-paint-nodes.c
@@ -75,8 +75,7 @@ _clutter_paint_node_init_types (void)
   cogl_pipeline_set_color (default_color_pipeline, &cogl_color);
 
   default_texture_pipeline = cogl_pipeline_new (ctx);
-  cogl_pipeline_set_layer_null_texture (default_texture_pipeline, 0,
-                                        COGL_TEXTURE_TYPE_2D);
+  cogl_pipeline_set_layer_null_texture (default_texture_pipeline, 0);
   cogl_pipeline_set_color (default_texture_pipeline, &cogl_color);
   cogl_pipeline_set_layer_wrap_mode (default_texture_pipeline, 0,
                                      COGL_PIPELINE_WRAP_MODE_AUTOMATIC);
diff --git a/clutter/clutter/clutter-path.c b/clutter/clutter/clutter-path.c
index 6ea433b..d80ddbe 100644
--- a/clutter/clutter/clutter-path.c
+++ b/clutter/clutter/clutter-path.c
@@ -295,8 +295,7 @@ clutter_path_clear (ClutterPath *path)
 {
   ClutterPathPrivate *priv = path->priv;
 
-  g_slist_foreach (priv->nodes, (GFunc) clutter_path_node_full_free, NULL);
-  g_slist_free (priv->nodes);
+  g_slist_free_full (priv->nodes, (GDestroyNotify) clutter_path_node_full_free);
 
   priv->nodes = priv->nodes_tail = NULL;
   priv->nodes_dirty = TRUE;
@@ -659,8 +658,7 @@ clutter_path_parse_description (const gchar  *p,
   return TRUE;
 
  fail:
-  g_slist_foreach (nodes, (GFunc) clutter_path_node_full_free, NULL);
-  g_slist_free (nodes);
+  g_slist_free_full (nodes, (GDestroyNotify) clutter_path_node_full_free);
   return FALSE;
 }
 
diff --git a/clutter/clutter/clutter-private.h b/clutter/clutter/clutter-private.h
index a5cd1fa..a97fd12 100644
--- a/clutter/clutter/clutter-private.h
+++ b/clutter/clutter/clutter-private.h
@@ -146,9 +146,6 @@ struct _ClutterMainContext
   ClutterActor *pointer_grab_actor;
   ClutterActor *keyboard_grab_actor;
 
-  /* stack of actors with shaders during paint */
-  GSList *shaders;
-
   /* fb bit masks for col<->id mapping in picking */
   gint fb_r_mask;
   gint fb_g_mask;
@@ -173,7 +170,6 @@ struct _ClutterMainContext
 
   /* boolean flags */
   guint is_initialized          : 1;
-  guint motion_events_per_actor : 1;
   guint defer_display_setup     : 1;
   guint options_parsed          : 1;
   guint show_fps                : 1;
@@ -198,10 +194,6 @@ void                    _clutter_context_lock                           (void);
 void                    _clutter_context_unlock                         (void);
 gboolean                _clutter_context_is_initialized                 (void);
 ClutterPickMode         _clutter_context_get_pick_mode                  (void);
-void                    _clutter_context_push_shader_stack              (ClutterActor *actor);
-ClutterActor *          _clutter_context_pop_shader_stack               (ClutterActor *actor);
-ClutterActor *          _clutter_context_peek_shader_stack              (void);
-gboolean                _clutter_context_get_motion_events_enabled      (void);
 gboolean                _clutter_context_get_show_fps                   (void);
 
 gboolean      _clutter_feature_init (GError **error);
@@ -303,6 +295,11 @@ gboolean        _clutter_util_matrix_decompose  (const ClutterMatrix *src,
                                                  ClutterVertex       *translate_p,
                                                  ClutterVertex4      *perspective_p);
 
+PangoDirection _clutter_pango_unichar_direction (gunichar ch);
+
+PangoDirection _clutter_pango_find_base_dir     (const gchar *text,
+                                                 gint         length);
+
 typedef struct _ClutterPlane
 {
   float v0[3];
diff --git a/clutter/clutter/clutter-script-parser.c b/clutter/clutter/clutter-script-parser.c
index 55e70da..b17a7d2 100644
--- a/clutter/clutter/clutter-script-parser.c
+++ b/clutter/clutter/clutter-script-parser.c
@@ -1636,14 +1636,17 @@ clutter_script_translate_parameters (ClutterScript  *script,
                                      GObject        *object,
                                      const gchar    *name,
                                      GList          *properties,
-                                     GArray        **params)
+                                     GPtrArray     **param_names,
+                                     GArray        **param_values)
 {
   ClutterScriptable *scriptable = NULL;
   ClutterScriptableIface *iface = NULL;
   GList *l, *unparsed;
   gboolean parse_custom = FALSE;
 
-  *params = g_array_new (FALSE, FALSE, sizeof (GParameter));
+  *param_names = g_ptr_array_new_with_free_func (g_free);
+  *param_values = g_array_new (FALSE, FALSE, sizeof (GValue));
+  g_array_set_clear_func (*param_values, (GDestroyNotify) g_value_unset);
 
   if (CLUTTER_IS_SCRIPTABLE (object))
     {
@@ -1659,7 +1662,7 @@ clutter_script_translate_parameters (ClutterScript  *script,
   for (l = properties; l != NULL; l = l->next)
     {
       PropertyInfo *pinfo = l->data;
-      GParameter param = { NULL };
+      GValue value = G_VALUE_INIT;
       gboolean res = FALSE;
 
       if (pinfo->is_child || pinfo->is_layout)
@@ -1676,12 +1679,12 @@ clutter_script_translate_parameters (ClutterScript  *script,
                     pinfo->name);
 
       if (parse_custom)
-        res = iface->parse_custom_node (scriptable, script, &param.value,
+        res = iface->parse_custom_node (scriptable, script, &value,
                                         pinfo->name,
                                         pinfo->node);
 
       if (!res)
-        res = _clutter_script_parse_node (script, &param.value,
+        res = _clutter_script_parse_node (script, &value,
                                           pinfo->name,
                                           pinfo->node,
                                           pinfo->pspec);
@@ -1693,9 +1696,8 @@ clutter_script_translate_parameters (ClutterScript  *script,
           continue;
         }
 
-      param.name = g_strdup (pinfo->name);
-
-      g_array_append_val (*params, param);
+      g_ptr_array_add (*param_names, g_strdup (pinfo->name));
+      g_array_append_val (*param_values, value);
 
       property_info_free (pinfo);
     }
@@ -1710,7 +1712,8 @@ clutter_script_construct_parameters (ClutterScript  *script,
                                      GType           gtype,
                                      const gchar    *name,
                                      GList          *properties,
-                                     GArray        **construct_params)
+                                     GPtrArray     **construct_param_names,
+                                     GArray        **construct_param_values)
 {
   GObjectClass *klass;
   GList *l, *unparsed;
@@ -1718,14 +1721,17 @@ clutter_script_construct_parameters (ClutterScript  *script,
   klass = g_type_class_ref (gtype);
   g_assert (klass != NULL);
 
-  *construct_params = g_array_new (FALSE, FALSE, sizeof (GParameter));
+  *construct_param_names = g_ptr_array_new_with_free_func (g_free);
+  *construct_param_values = g_array_new (FALSE, FALSE, sizeof (GValue));
+  g_array_set_clear_func (*construct_param_values,
+                          (GDestroyNotify) g_value_unset);
 
   unparsed = NULL;
 
   for (l = properties; l != NULL; l = l->next)
     {
       PropertyInfo *pinfo = l->data;
-      GParameter param = { NULL };
+      GValue value = G_VALUE_INIT;
       GParamSpec *pspec = NULL;
 
       /* we allow custom property names for classes, so if we
@@ -1749,9 +1755,7 @@ clutter_script_construct_parameters (ClutterScript  *script,
           continue;
         }
 
-      param.name = g_strdup (pinfo->name);
-
-      if (!_clutter_script_parse_node (script, &param.value,
+      if (!_clutter_script_parse_node (script, &value,
                                        pinfo->name,
                                        pinfo->node,
                                        pinfo->pspec))
@@ -1760,7 +1764,8 @@ clutter_script_construct_parameters (ClutterScript  *script,
           continue;
         }
 
-      g_array_append_val (*construct_params, param);
+      g_ptr_array_add (*construct_param_names, g_strdup (pinfo->name));
+      g_array_append_val (*construct_param_values, value);
 
       property_info_free (pinfo);
     }
@@ -2021,8 +2026,7 @@ add_children (ClutterScript *script,
       clutter_container_add_actor (container, CLUTTER_ACTOR (object));
     }
 
-  g_list_foreach (oinfo->children, (GFunc) g_free, NULL);
-  g_list_free (oinfo->children);
+  g_list_free_full (oinfo->children, g_free);
 
   oinfo->children = unresolved;
 }
@@ -2088,7 +2092,8 @@ _clutter_script_apply_properties (ClutterScript *script,
   gboolean set_custom_property = FALSE;
   GObject *object = oinfo->object;
   GList *properties;
-  GArray *params;
+  g_autoptr (GPtrArray) param_names = NULL;
+  g_autoptr (GArray) param_values = NULL;
   guint i;
 
   if (!oinfo->has_unresolved)
@@ -2112,34 +2117,31 @@ _clutter_script_apply_properties (ClutterScript *script,
                                                            object,
                                                            oinfo->id,
                                                            properties,
-                                                           &params);
+                                                           &param_names,
+                                                           &param_values);
 
   /* consume all the properties we could translate in this pass */
-  for (i = 0; i < params->len; i++)
+  for (i = 0; i < param_names->len; i++)
     {
-      GParameter *param = &g_array_index (params, GParameter, i);
+      char *name = g_ptr_array_index (param_names, i);
+      GValue *value = &g_array_index (param_values, GValue, i);
 
       CLUTTER_NOTE (SCRIPT,
                     "Setting %s property '%s' (type:%s) to object '%s' (id:%s)",
                     set_custom_property ? "custom" : "regular",
-                    param->name,
-                    g_type_name (G_VALUE_TYPE (&param->value)),
+                    name,
+                    g_type_name (G_VALUE_TYPE (value)),
                     g_type_name (oinfo->gtype),
                     oinfo->id);
 
       if (set_custom_property)
         iface->set_custom_property (scriptable, script,
-                                    param->name,
-                                    &param->value);
+                                    name,
+                                    value);
       else
-        g_object_set_property (object, param->name, &param->value);
-
-      g_free ((gchar *) param->name);
-      g_value_unset (&param->value);
+        g_object_set_property (object, name, value);
     }
 
-  g_array_free (params, TRUE);
-
   _clutter_script_check_unresolved (script, oinfo);
 }
 
@@ -2147,8 +2149,8 @@ void
 _clutter_script_construct_object (ClutterScript *script,
                                   ObjectInfo    *oinfo)
 {
-  GArray *params = NULL;
-  guint i;
+  g_autoptr (GPtrArray) param_names = NULL;
+  g_autoptr (GArray) param_values = NULL;
 
   /* we have completely updated the object */
   if (oinfo->object != NULL)
@@ -2191,25 +2193,14 @@ _clutter_script_construct_object (ClutterScript *script,
                                              oinfo->gtype,
                                              oinfo->id,
                                              properties,
-                                             &params);
+                                             &param_names,
+                                             &param_values);
 
       default_stage = clutter_stage_manager_get_default_stage (manager);
       oinfo->object = G_OBJECT (default_stage);
-
-      for (i = 0; i < params->len; i++)
-        {
-          GParameter *param = &g_array_index (params, GParameter, i);
-
-          g_free ((gchar *) param->name);
-          g_value_unset (&param->value);
-        }
-
-      g_array_free (params, TRUE);
     }
   else
     {
-      g_autoptr (GPtrArray) param_names = NULL;
-      GArray *param_values;
       GList *properties = oinfo->properties;
 
       /* every other object: first, we get the construction parameters */
@@ -2218,22 +2209,11 @@ _clutter_script_construct_object (ClutterScript *script,
                                              oinfo->gtype,
                                              oinfo->id,
                                              properties,
-                                             &params);
-
-      /* Convert GParameter → (GStrv, GValue[]) */
-      param_names = g_ptr_array_sized_new (params->len);
-      param_values = g_array_sized_new (TRUE, FALSE, sizeof (GValue), params->len);
-      for (i = 0; i < params->len; i++)
-        {
-          GParameter *param = &g_array_index (params, GParameter, i);
-
-          g_ptr_array_add (param_names, (gchar *) param->name);
-          g_array_append_val (param_values, param->value);
-        }
-      g_ptr_array_add (param_names, NULL);
+                                             &param_names,
+                                             &param_values);
 
       oinfo->object = g_object_new_with_properties (oinfo->gtype,
-                                                    params->len,
+                                                    param_names->len,
                                                     (const gchar **) param_names->pdata,
                                                     (const GValue *) param_values->data);
 
@@ -2242,17 +2222,6 @@ _clutter_script_construct_object (ClutterScript *script,
        * else too or only by this ClutterScript object.
        */
       g_object_ref_sink (oinfo->object);
-
-      for (i = 0; i < params->len; i++)
-        {
-          GParameter *param = &g_array_index (params, GParameter, i);
-
-          g_free ((gchar *) param->name);
-          g_value_unset (&param->value);
-        }
-
-      g_array_free (param_values, FALSE);
-      g_array_free (params, TRUE);
    }
 
   g_assert (oinfo->object != NULL);
diff --git a/clutter/clutter/clutter-script.c b/clutter/clutter/clutter-script.c
index 7a58cd0..5914545 100644
--- a/clutter/clutter/clutter-script.c
+++ b/clutter/clutter/clutter-script.c
@@ -263,8 +263,6 @@ enum
 
 static GParamSpec *obj_props[PROP_LAST];
 
-#define CLUTTER_SCRIPT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_SCRIPT, ClutterScriptPrivate))
-
 struct _ClutterScriptPrivate
 {
   GHashTable *objects;
@@ -346,15 +344,12 @@ object_info_free (gpointer data)
       g_free (oinfo->class_name);
       g_free (oinfo->type_func);
 
-      g_list_foreach (oinfo->properties, (GFunc) property_info_free, NULL);
-      g_list_free (oinfo->properties);
+      g_list_free_full (oinfo->properties, property_info_free);
 
-      g_list_foreach (oinfo->signals, (GFunc) signal_info_free, NULL);
-      g_list_free (oinfo->signals);
+      g_list_free_full (oinfo->signals, signal_info_free);
 
       /* these are ids */
-      g_list_foreach (oinfo->children, (GFunc) g_free, NULL);
-      g_list_free (oinfo->children);
+      g_list_free_full (oinfo->children, g_free);
 
       /* we unref top-level objects and leave the actors alone,
        * unless we are unmerging in which case we have to destroy
@@ -380,7 +375,7 @@ object_info_free (gpointer data)
 static void
 clutter_script_finalize (GObject *gobject)
 {
-  ClutterScriptPrivate *priv = CLUTTER_SCRIPT_GET_PRIVATE (gobject);
+  ClutterScriptPrivate *priv = CLUTTER_SCRIPT (gobject)->priv;
 
   g_object_unref (priv->parser);
   g_hash_table_destroy (priv->objects);
@@ -846,8 +841,7 @@ clutter_script_unmerge_objects (ClutterScript *script,
   for (l = data.ids; l != NULL; l = l->next)
     g_hash_table_remove (priv->objects, l->data);
 
-  g_slist_foreach (data.ids, (GFunc) g_free, NULL);
-  g_slist_free (data.ids);
+  g_slist_free_full (data.ids, g_free);
 
   clutter_script_ensure_objects (script);
 }
diff --git a/clutter/clutter/clutter-stage-manager.c b/clutter/clutter/clutter-stage-manager.c
index 7955a89..31b3a2b 100644
--- a/clutter/clutter/clutter-stage-manager.c
+++ b/clutter/clutter/clutter-stage-manager.c
@@ -89,8 +89,8 @@ clutter_stage_manager_dispose (GObject *gobject)
 
   stage_manager = CLUTTER_STAGE_MANAGER (gobject);
 
-  g_slist_foreach (stage_manager->stages, (GFunc) clutter_actor_destroy, NULL);
-  g_slist_free (stage_manager->stages);
+  g_slist_free_full (stage_manager->stages,
+                     (GDestroyNotify) clutter_actor_destroy);
   stage_manager->stages = NULL;
 
   G_OBJECT_CLASS (clutter_stage_manager_parent_class)->dispose (gobject);
diff --git a/clutter/clutter/clutter-stage-private.h b/clutter/clutter/clutter-stage-private.h
index 4799c29..b4255a4 100644
--- a/clutter/clutter/clutter-stage-private.h
+++ b/clutter/clutter/clutter-stage-private.h
@@ -40,6 +40,7 @@ void                _clutter_stage_paint_view            (ClutterStage          
                                                           ClutterStageView            *view,
                                                           const cairo_rectangle_int_t *clip);
 
+void                _clutter_stage_emit_after_paint      (ClutterStage          *stage);
 void                _clutter_stage_set_window            (ClutterStage          *stage,
                                                           ClutterStageWindow    *stage_window);
 ClutterStageWindow *_clutter_stage_get_window            (ClutterStage          *stage);
@@ -117,7 +118,6 @@ void            _clutter_stage_remove_touch_drag_actor (ClutterStage         *st
 
 ClutterStageState       _clutter_stage_get_state        (ClutterStage      *stage);
 gboolean                _clutter_stage_is_activated     (ClutterStage      *stage);
-gboolean                _clutter_stage_is_fullscreen    (ClutterStage      *stage);
 gboolean                _clutter_stage_update_state     (ClutterStage      *stage,
                                                          ClutterStageState  unset_state,
                                                          ClutterStageState  set_state);
diff --git a/clutter/clutter/clutter-stage-view-private.h b/clutter/clutter/clutter-stage-view-private.h
new file mode 100644
index 0000000..89c4259
--- /dev/null
+++ b/clutter/clutter/clutter-stage-view-private.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2019 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __CLUTTER_STAGE_VIEW_PRIVATE_H__
+#define __CLUTTER_STAGE_VIEW_PRIVATE_H__
+
+#include "clutter/clutter-stage-view.h"
+
+void clutter_stage_view_blit_offscreen (ClutterStageView            *view,
+                                        const cairo_rectangle_int_t *clip);
+
+gboolean clutter_stage_view_is_dirty_viewport (ClutterStageView *view);
+
+void clutter_stage_view_set_dirty_viewport (ClutterStageView *view,
+                                            gboolean          dirty);
+
+gboolean clutter_stage_view_is_dirty_projection (ClutterStageView *view);
+
+void clutter_stage_view_set_dirty_projection (ClutterStageView *view,
+                                              gboolean          dirty);
+
+
+#endif /* __CLUTTER_STAGE_VIEW_PRIVATE_H__ */
diff --git a/clutter/clutter/clutter-stage-view.c b/clutter/clutter/clutter-stage-view.c
index cd6cd35..a12261f 100644
--- a/clutter/clutter/clutter-stage-view.c
+++ b/clutter/clutter/clutter-stage-view.c
@@ -18,6 +18,7 @@
 #include "clutter-build-config.h"
 
 #include "clutter/clutter-stage-view.h"
+#include "clutter/clutter-stage-view-private.h"
 
 #include <cairo-gobject.h>
 #include <math.h>
@@ -61,6 +62,14 @@ clutter_stage_view_get_layout (ClutterStageView      *view,
   *rect = priv->layout;
 }
 
+/**
+ * clutter_stage_view_get_framebuffer:
+ * @view: a #ClutterStageView
+ *
+ * Retrieves the framebuffer of @view to draw to.
+ *
+ * Returns: (transfer none): a #CoglFramebuffer
+ */
 CoglFramebuffer *
 clutter_stage_view_get_framebuffer (ClutterStageView *view)
 {
@@ -73,6 +82,14 @@ clutter_stage_view_get_framebuffer (ClutterStageView *view)
     return priv->framebuffer;
 }
 
+/**
+ * clutter_stage_view_get_onscreen:
+ * @view: a #ClutterStageView
+ *
+ * Retrieves the onscreen framebuffer of @view if available.
+ *
+ * Returns: (transfer none): a #CoglFramebuffer
+ */
 CoglFramebuffer *
 clutter_stage_view_get_onscreen (ClutterStageView *view)
 {
diff --git a/clutter/clutter/clutter-stage-view.h b/clutter/clutter/clutter-stage-view.h
index 1264986..26bf10e 100644
--- a/clutter/clutter/clutter-stage-view.h
+++ b/clutter/clutter/clutter-stage-view.h
@@ -18,6 +18,10 @@
 #ifndef __CLUTTER_STAGE_VIEW_H__
 #define __CLUTTER_STAGE_VIEW_H__
 
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
 #include <cairo.h>
 #include <glib-object.h>
 #include <cogl/cogl.h>
@@ -57,22 +61,9 @@ void             clutter_stage_view_transform_to_onscreen (ClutterStageView *vie
                                                            gfloat           *x,
                                                            gfloat           *y);
 
-void clutter_stage_view_blit_offscreen (ClutterStageView            *view,
-					const cairo_rectangle_int_t *clip);
-
 CLUTTER_EXPORT
 float clutter_stage_view_get_scale (ClutterStageView *view);
 
-gboolean clutter_stage_view_is_dirty_viewport (ClutterStageView *view);
-
-void clutter_stage_view_set_dirty_viewport (ClutterStageView *view,
-                                            gboolean          dirty);
-
-gboolean clutter_stage_view_is_dirty_projection (ClutterStageView *view);
-
-void clutter_stage_view_set_dirty_projection (ClutterStageView *view,
-                                              gboolean          dirty);
-
 CLUTTER_EXPORT
 void clutter_stage_view_get_offscreen_transformation_matrix (ClutterStageView *view,
                                                              CoglMatrix       *matrix);
diff --git a/clutter/clutter/clutter-stage-window.c b/clutter/clutter/clutter-stage-window.c
index e8fa976..76421d6 100644
--- a/clutter/clutter/clutter-stage-window.c
+++ b/clutter/clutter/clutter-stage-window.c
@@ -63,16 +63,6 @@ _clutter_stage_window_set_title (ClutterStageWindow *window,
 }
 
 void
-_clutter_stage_window_set_fullscreen (ClutterStageWindow *window,
-                                      gboolean            is_fullscreen)
-{
-  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
-
-  if (iface->set_fullscreen)
-    iface->set_fullscreen (window, is_fullscreen);
-}
-
-void
 _clutter_stage_window_set_cursor_visible (ClutterStageWindow *window,
                                           gboolean            is_visible)
 {
@@ -82,14 +72,6 @@ _clutter_stage_window_set_cursor_visible (ClutterStageWindow *window,
     iface->set_cursor_visible (window, is_visible);
 }
 
-void
-_clutter_stage_window_set_user_resizable (ClutterStageWindow *window,
-                                          gboolean            is_resizable)
-{
-  CLUTTER_STAGE_WINDOW_GET_IFACE (window)->set_user_resizable (window,
-                                                               is_resizable);
-}
-
 gboolean
 _clutter_stage_window_realize (ClutterStageWindow *window)
 {
diff --git a/clutter/clutter/clutter-stage-window.h b/clutter/clutter/clutter-stage-window.h
index 6c36017..389ed05 100644
--- a/clutter/clutter/clutter-stage-window.h
+++ b/clutter/clutter/clutter-stage-window.h
@@ -30,12 +30,8 @@ struct _ClutterStageWindowInterface
 
   void              (* set_title)               (ClutterStageWindow *stage_window,
                                                  const gchar        *title);
-  void              (* set_fullscreen)          (ClutterStageWindow *stage_window,
-                                                 gboolean            is_fullscreen);
   void              (* set_cursor_visible)      (ClutterStageWindow *stage_window,
                                                  gboolean            cursor_visible);
-  void              (* set_user_resizable)      (ClutterStageWindow *stage_window,
-                                                 gboolean            is_resizable);
 
   gboolean          (* realize)                 (ClutterStageWindow *stage_window);
   void              (* unrealize)               (ClutterStageWindow *stage_window);
@@ -83,12 +79,8 @@ ClutterActor *    _clutter_stage_window_get_wrapper        (ClutterStageWindow *
 
 void              _clutter_stage_window_set_title          (ClutterStageWindow *window,
                                                             const gchar        *title);
-void              _clutter_stage_window_set_fullscreen     (ClutterStageWindow *window,
-                                                            gboolean            is_fullscreen);
 void              _clutter_stage_window_set_cursor_visible (ClutterStageWindow *window,
                                                             gboolean            is_visible);
-void              _clutter_stage_window_set_user_resizable (ClutterStageWindow *window,
-                                                            gboolean            is_resizable);
 
 gboolean          _clutter_stage_window_realize                 (ClutterStageWindow *window);
 void              _clutter_stage_window_unrealize               (ClutterStageWindow *window);
diff --git a/clutter/clutter/clutter-stage.c b/clutter/clutter/clutter-stage.c
index 1eea5b3..3a4e56f 100644
--- a/clutter/clutter/clutter-stage.c
+++ b/clutter/clutter/clutter-stage.c
@@ -72,9 +72,11 @@
 #include "clutter-private.h"
 #include "clutter-stage-manager-private.h"
 #include "clutter-stage-private.h"
+#include "clutter-stage-view-private.h"
 #include "clutter-private.h"
 
 #include "cogl/cogl.h"
+#include "cogl/cogl-trace.h"
 
 /* <private>
  * ClutterStageHint:
@@ -147,13 +149,13 @@ struct _ClutterStagePrivate
   gpointer paint_data;
   GDestroyNotify paint_notify;
 
+  cairo_rectangle_int_t view_clip;
+
   int update_freeze_count;
 
   guint relayout_pending       : 1;
   guint redraw_pending         : 1;
-  guint is_fullscreen          : 1;
   guint is_cursor_visible      : 1;
-  guint is_user_resizable      : 1;
   guint use_fog                : 1;
   guint throttle_motion_events : 1;
   guint use_alpha              : 1;
@@ -169,28 +171,27 @@ enum
   PROP_0,
 
   PROP_COLOR,
-  PROP_FULLSCREEN_SET,
-  PROP_OFFSCREEN,
   PROP_CURSOR_VISIBLE,
   PROP_PERSPECTIVE,
   PROP_TITLE,
-  PROP_USER_RESIZABLE,
   PROP_USE_FOG,
   PROP_FOG,
   PROP_USE_ALPHA,
   PROP_KEY_FOCUS,
   PROP_NO_CLEAR_HINT,
-  PROP_ACCEPT_FOCUS
+  PROP_ACCEPT_FOCUS,
+  PROP_LAST
 };
 
+static GParamSpec *obj_props[PROP_LAST] = { NULL, };
+
 enum
 {
-  FULLSCREEN,
-  UNFULLSCREEN,
   ACTIVATE,
   DEACTIVATE,
   DELETE_EVENT,
   AFTER_PAINT,
+  PAINT_VIEW,
   PRESENTED,
 
   LAST_SIGNAL
@@ -403,40 +404,37 @@ clutter_stage_allocate (ClutterActor           *self,
                                     flags | CLUTTER_DELEGATE_LAYOUT);
 
       /* Ensure the window is sized correctly */
-      if (!priv->is_fullscreen)
+      if (priv->min_size_changed)
         {
-          if (priv->min_size_changed)
-            {
-              gfloat min_width, min_height;
-              gboolean min_width_set, min_height_set;
-
-              g_object_get (G_OBJECT (self),
-                            "min-width", &min_width,
-                            "min-width-set", &min_width_set,
-                            "min-height", &min_height,
-                            "min-height-set", &min_height_set,
-                            NULL);
-
-              if (!min_width_set)
-                min_width = 1;
-              if (!min_height_set)
-                min_height = 1;
-
-              if (width < min_width)
-                width = min_width;
-              if (height < min_height)
-                height = min_height;
-
-              priv->min_size_changed = FALSE;
-            }
+          gfloat min_width, min_height;
+          gboolean min_width_set, min_height_set;
+
+          g_object_get (G_OBJECT (self),
+                        "min-width", &min_width,
+                        "min-width-set", &min_width_set,
+                        "min-height", &min_height,
+                        "min-height-set", &min_height_set,
+                        NULL);
+
+          if (!min_width_set)
+            min_width = 1;
+          if (!min_height_set)
+            min_height = 1;
+
+          if (width < min_width)
+            width = min_width;
+          if (height < min_height)
+            height = min_height;
+
+          priv->min_size_changed = FALSE;
+        }
 
-          if (window_size.width != CLUTTER_NEARBYINT (width) ||
-              window_size.height != CLUTTER_NEARBYINT (height))
-            {
-              _clutter_stage_window_resize (priv->impl,
-                                            CLUTTER_NEARBYINT (width),
-                                            CLUTTER_NEARBYINT (height));
-            }
+      if (window_size.width != CLUTTER_NEARBYINT (width) ||
+          window_size.height != CLUTTER_NEARBYINT (height))
+        {
+          _clutter_stage_window_resize (priv->impl,
+                                        CLUTTER_NEARBYINT (width),
+                                        CLUTTER_NEARBYINT (height));
         }
     }
   else
@@ -688,7 +686,22 @@ _clutter_stage_paint_view (ClutterStage                *stage,
   if (!priv->impl)
     return;
 
-  clutter_stage_do_paint_view (stage, view, clip);
+  COGL_TRACE_BEGIN_SCOPED (ClutterStagePaintView, "Paint (view)");
+
+  priv->view_clip = *clip;
+
+  if (g_signal_has_handler_pending (stage, stage_signals[PAINT_VIEW],
+                                    0, TRUE))
+    g_signal_emit (stage, stage_signals[PAINT_VIEW], 0, view);
+  else
+    CLUTTER_STAGE_GET_CLASS (stage)->paint_view (stage, view);
+
+  priv->view_clip = (cairo_rectangle_int_t) { 0 };
+}
+
+void
+_clutter_stage_emit_after_paint (ClutterStage *stage)
+{
   g_signal_emit (stage, stage_signals[AFTER_PAINT], 0);
 }
 
@@ -829,7 +842,7 @@ clutter_stage_emit_key_focus_event (ClutterStage *stage,
   else
     g_signal_emit_by_name (priv->key_focused_actor, "key-focus-out");
 
-  g_object_notify (G_OBJECT (stage), "key-focus");
+  g_object_notify_by_pspec (G_OBJECT (stage), obj_props[PROP_KEY_FOCUS]);
 }
 
 static void
@@ -844,40 +857,6 @@ clutter_stage_real_deactivate (ClutterStage *stage)
   clutter_stage_emit_key_focus_event (stage, FALSE);
 }
 
-static void
-clutter_stage_real_fullscreen (ClutterStage *stage)
-{
-  ClutterStagePrivate *priv = stage->priv;
-  cairo_rectangle_int_t geom;
-  ClutterActorBox box;
-
-  /* we need to force an allocation here because the size
-   * of the stage might have been changed by the backend
-   *
-   * this is a really bad solution to the issues caused by
-   * the fact that fullscreening the stage on the X11 backends
-   * is really an asynchronous operation
-   */
-  _clutter_stage_window_get_geometry (priv->impl, &geom);
-
-  box.x1 = 0;
-  box.y1 = 0;
-  box.x2 = geom.width;
-  box.y2 = geom.height;
-
-  /* we need to blow the caching on the Stage size, given that
-   * we're about to force an allocation, because if anything
-   * ends up querying the size of the stage during the allocate()
-   * call, like constraints or signal handlers, we'll get into an
-   * inconsistent state: the stage will report the old cached size,
-   * but the allocation will be updated anyway.
-   */
-  clutter_actor_set_size (CLUTTER_ACTOR (stage), -1.0, -1.0);
-  clutter_actor_allocate (CLUTTER_ACTOR (stage),
-                          &box,
-                          CLUTTER_ALLOCATION_NONE);
-}
-
 void
 _clutter_stage_queue_event (ClutterStage *stage,
                             ClutterEvent *event,
@@ -1225,22 +1204,31 @@ _clutter_stage_do_update (ClutterStage *stage)
   if (!CLUTTER_ACTOR_IS_REALIZED (stage))
     return FALSE;
 
+  COGL_TRACE_BEGIN_SCOPED (ClutterStageDoUpdate, "Update");
+
   /* NB: We need to ensure we have an up to date layout *before* we
    * check or clear the pending redraws flag since a relayout may
    * queue a redraw.
    */
+  COGL_TRACE_BEGIN (ClutterStageRelayout, "Layout");
+
   _clutter_stage_maybe_relayout (CLUTTER_ACTOR (stage));
 
+  COGL_TRACE_END (ClutterStageRelayout);
+
   if (!priv->redraw_pending)
     return FALSE;
 
   if (stage_was_relayout)
     pointers = _clutter_stage_check_updated_pointers (stage);
 
-  clutter_stage_maybe_finish_queue_redraws (stage);
+  COGL_TRACE_BEGIN (ClutterStagePaint, "Paint");
 
+  clutter_stage_maybe_finish_queue_redraws (stage);
   clutter_stage_do_redraw (stage);
 
+  COGL_TRACE_END (ClutterStagePaint);
+
   /* reset the guard, so that new redraws are possible */
   priv->redraw_pending = FALSE;
 
@@ -1254,12 +1242,16 @@ _clutter_stage_do_update (ClutterStage *stage)
     }
 #endif /* CLUTTER_ENABLE_DEBUG */
 
+  COGL_TRACE_BEGIN (ClutterStagePick, "Pick");
+
   while (pointers)
     {
       _clutter_input_device_update (pointers->data, NULL, TRUE);
       pointers = g_slist_delete_link (pointers, pointers);
     }
 
+  COGL_TRACE_END (ClutterStagePick);
+
   return TRUE;
 }
 
@@ -1303,14 +1295,8 @@ clutter_stage_real_queue_redraw (ClutterActor       *actor,
     return TRUE;
 
   if (_clutter_stage_window_ignoring_redraw_clips (stage_window))
-    {
-      _clutter_stage_window_add_redraw_clip (stage_window, NULL);
-      return FALSE;
-    }
+    return FALSE;
 
-  /* Convert the clip volume into stage coordinates and then into an
-   * axis aligned stage coordinates bounding box...
-   */
   if (redraw_clip == NULL)
     {
       _clutter_stage_window_add_redraw_clip (stage_window, NULL);
@@ -1320,6 +1306,8 @@ clutter_stage_real_queue_redraw (ClutterActor       *actor,
   if (redraw_clip->is_empty)
     return TRUE;
 
+  /* Convert the clip volume into stage coordinates and then into an
+   * axis aligned stage coordinates bounding box... */
   _clutter_paint_volume_get_stage_paint_box (redraw_clip,
                                              stage,
                                              &bounding_box);
@@ -1574,10 +1562,13 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
   return retval;
 }
 
-static ClutterStageView *
-get_view_at (ClutterStage *stage,
-             int           x,
-             int           y)
+/**
+ * clutter_stage_get_view_at: (skip)
+ */
+ClutterStageView *
+clutter_stage_get_view_at (ClutterStage *stage,
+                           float         x,
+                           float         y)
 {
   ClutterStagePrivate *priv = stage->priv;
   GList *l;
@@ -1624,7 +1615,7 @@ _clutter_stage_do_pick (ClutterStage   *stage,
   if (x < 0 || x >= stage_width || y < 0 || y >= stage_height)
     return actor;
 
-  view = get_view_at (stage, x, y);
+  view = clutter_stage_get_view_at (stage, x, y);
   if (view)
     return _clutter_stage_do_pick_on_view (stage, x, y, mode, view);
 
@@ -1703,11 +1694,6 @@ clutter_stage_set_property (GObject      *object,
                                           clutter_value_get_color (value));
       break;
 
-    case PROP_OFFSCREEN:
-      if (g_value_get_boolean (value))
-        g_warning ("Offscreen stages are currently not supported\n");
-      break;
-
     case PROP_CURSOR_VISIBLE:
       if (g_value_get_boolean (value))
         clutter_stage_show_cursor (stage);
@@ -1723,10 +1709,6 @@ clutter_stage_set_property (GObject      *object,
       clutter_stage_set_title (stage, g_value_get_string (value));
       break;
 
-    case PROP_USER_RESIZABLE:
-      clutter_stage_set_user_resizable (stage, g_value_get_boolean (value));
-      break;
-
     case PROP_USE_FOG:
       clutter_stage_set_use_fog (stage, g_value_get_boolean (value));
       break;
@@ -1777,14 +1759,6 @@ clutter_stage_get_property (GObject    *gobject,
       }
       break;
 
-    case PROP_OFFSCREEN:
-      g_value_set_boolean (value, FALSE);
-      break;
-
-    case PROP_FULLSCREEN_SET:
-      g_value_set_boolean (value, priv->is_fullscreen);
-      break;
-
     case PROP_CURSOR_VISIBLE:
       g_value_set_boolean (value, priv->is_cursor_visible);
       break;
@@ -1797,10 +1771,6 @@ clutter_stage_get_property (GObject    *gobject,
       g_value_set_string (value, priv->title);
       break;
 
-    case PROP_USER_RESIZABLE:
-      g_value_set_boolean (value, priv->is_user_resizable);
-      break;
-
     case PROP_USE_FOG:
       g_value_set_boolean (value, priv->use_fog);
       break;
@@ -1896,11 +1866,20 @@ clutter_stage_finalize (GObject *object)
 }
 
 static void
+clutter_stage_real_paint_view (ClutterStage     *stage,
+                               ClutterStageView *view)
+{
+  ClutterStagePrivate *priv = stage->priv;
+  const cairo_rectangle_int_t *clip = &priv->view_clip;
+
+  clutter_stage_do_paint_view (stage, view, clip);
+}
+
+static void
 clutter_stage_class_init (ClutterStageClass *klass)
 {
   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
   ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
-  GParamSpec *pspec;
 
   gobject_class->constructed = clutter_stage_constructed;
   gobject_class->set_property = clutter_stage_set_property;
@@ -1924,70 +1903,20 @@ clutter_stage_class_init (ClutterStageClass *klass)
   actor_class->queue_redraw = clutter_stage_real_queue_redraw;
   actor_class->apply_transform = clutter_stage_real_apply_transform;
 
-  /**
-   * ClutterStage:fullscreen:
-   *
-   * Whether the stage should be fullscreen or not.
-   *
-   * This property is set by calling clutter_stage_set_fullscreen()
-   * but since the actual implementation is delegated to the backend
-   * you should connect to the notify::fullscreen-set signal in order
-   * to get notification if the fullscreen state has been successfully
-   * achieved.
-   *
-   * Since: 1.0
-   */
-  pspec = g_param_spec_boolean ("fullscreen-set",
-                                P_("Fullscreen Set"),
-                                P_("Whether the main stage is fullscreen"),
-                                FALSE,
-                                CLUTTER_PARAM_READABLE);
-  g_object_class_install_property (gobject_class,
-                                   PROP_FULLSCREEN_SET,
-                                   pspec);
-  /**
-   * ClutterStage:offscreen:
-   *
-   * Whether the stage should be rendered in an offscreen buffer.
-   *
-   * Deprecated: 1.10: This property does not do anything.
-   */
-  pspec = g_param_spec_boolean ("offscreen",
-                                P_("Offscreen"),
-                                P_("Whether the main stage should be rendered offscreen"),
-                                FALSE,
-                                CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
-  g_object_class_install_property (gobject_class,
-                                   PROP_OFFSCREEN,
-                                   pspec);
+  klass->paint_view = clutter_stage_real_paint_view;
+
   /**
    * ClutterStage:cursor-visible:
    *
    * Whether the mouse pointer should be visible
    */
-  pspec = g_param_spec_boolean ("cursor-visible",
-                                P_("Cursor Visible"),
-                                P_("Whether the mouse pointer is visible on the main stage"),
-                                TRUE,
-                                CLUTTER_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class,
-                                   PROP_CURSOR_VISIBLE,
-                                   pspec);
-  /**
-   * ClutterStage:user-resizable:
-   *
-   * Whether the stage is resizable via user interaction.
-   *
-   * Since: 0.4
-   */
-  pspec = g_param_spec_boolean ("user-resizable",
-                                P_("User Resizable"),
-                                P_("Whether the stage is able to be resized via user interaction"),
-                                FALSE,
-                                CLUTTER_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class,
-                                   PROP_USER_RESIZABLE,
-                                   pspec);
+  obj_props[PROP_CURSOR_VISIBLE] =
+      g_param_spec_boolean ("cursor-visible",
+                            P_("Cursor Visible"),
+                            P_("Whether the mouse pointer is visible on the main stage"),
+                            TRUE,
+                            CLUTTER_PARAM_READWRITE);
+
   /**
    * ClutterStage:color:
    *
@@ -1996,13 +1925,13 @@ clutter_stage_class_init (ClutterStageClass *klass)
    * Deprecated: 1.10: Use the #ClutterActor:background-color property of
    *   #ClutterActor instead.
    */
-  pspec = clutter_param_spec_color ("color",
-                                    P_("Color"),
-                                    P_("The color of the stage"),
-                                    &default_stage_color,
-                                    CLUTTER_PARAM_READWRITE |
-                                    G_PARAM_DEPRECATED);
-  g_object_class_install_property (gobject_class, PROP_COLOR, pspec);
+  obj_props[PROP_COLOR] =
+      clutter_param_spec_color ("color",
+                                P_("Color"),
+                                P_("The color of the stage"),
+                                &default_stage_color,
+                                CLUTTER_PARAM_READWRITE |
+                                G_PARAM_DEPRECATED);
 
   /**
    * ClutterStage:perspective:
@@ -2012,14 +1941,12 @@ clutter_stage_class_init (ClutterStageClass *klass)
    *
    * Since: 0.8
    */
-  pspec = g_param_spec_boxed ("perspective",
-                              P_("Perspective"),
-                              P_("Perspective projection parameters"),
-                              CLUTTER_TYPE_PERSPECTIVE,
-                              CLUTTER_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class,
-                                   PROP_PERSPECTIVE,
-                                   pspec);
+  obj_props[PROP_PERSPECTIVE] =
+      g_param_spec_boxed ("perspective",
+                          P_("Perspective"),
+                          P_("Perspective projection parameters"),
+                          CLUTTER_TYPE_PERSPECTIVE,
+                          CLUTTER_PARAM_READWRITE);
 
   /**
    * ClutterStage:title:
@@ -2028,12 +1955,12 @@ clutter_stage_class_init (ClutterStageClass *klass)
    *
    * Since: 0.4
    */
-  pspec = g_param_spec_string ("title",
-                               P_("Title"),
-                               P_("Stage Title"),
-                               NULL,
-                               CLUTTER_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class, PROP_TITLE, pspec);
+  obj_props[PROP_TITLE] =
+      g_param_spec_string ("title",
+                           P_("Title"),
+                           P_("Stage Title"),
+                           NULL,
+                           CLUTTER_PARAM_READWRITE);
 
   /**
    * ClutterStage:use-fog:
@@ -2046,12 +1973,12 @@ clutter_stage_class_init (ClutterStageClass *klass)
    *
    * Deprecated: 1.10: This property does not do anything.
    */
-  pspec = g_param_spec_boolean ("use-fog",
-                                P_("Use Fog"),
-                                P_("Whether to enable depth cueing"),
-                                FALSE,
-                                CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
-  g_object_class_install_property (gobject_class, PROP_USE_FOG, pspec);
+  obj_props[PROP_USE_FOG] =
+      g_param_spec_boolean ("use-fog",
+                            P_("Use Fog"),
+                            P_("Whether to enable depth cueing"),
+                            FALSE,
+                            CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
 
   /**
    * ClutterStage:fog:
@@ -2063,12 +1990,12 @@ clutter_stage_class_init (ClutterStageClass *klass)
    *
    * Deprecated: 1.10: This property does not do anything.
    */
-  pspec = g_param_spec_boxed ("fog",
-                              P_("Fog"),
-                              P_("Settings for the depth cueing"),
-                              CLUTTER_TYPE_FOG,
-                              CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
-  g_object_class_install_property (gobject_class, PROP_FOG, pspec);
+  obj_props[PROP_FOG] =
+      g_param_spec_boxed ("fog",
+                          P_("Fog"),
+                          P_("Settings for the depth cueing"),
+                          CLUTTER_TYPE_FOG,
+                          CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
 
   /**
    * ClutterStage:use-alpha:
@@ -2080,12 +2007,12 @@ clutter_stage_class_init (ClutterStageClass *klass)
    *
    * Since: 1.2
    */
-  pspec = g_param_spec_boolean ("use-alpha",
-                                P_("Use Alpha"),
-                                P_("Whether to honour the alpha component of the stage color"),
-                                FALSE,
-                                CLUTTER_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class, PROP_USE_ALPHA, pspec);
+  obj_props[PROP_USE_ALPHA] =
+      g_param_spec_boolean ("use-alpha",
+                            P_("Use Alpha"),
+                            P_("Whether to honour the alpha component of the stage color"),
+                            FALSE,
+                            CLUTTER_PARAM_READWRITE);
 
   /**
    * ClutterStage:key-focus:
@@ -2097,12 +2024,12 @@ clutter_stage_class_init (ClutterStageClass *klass)
    *
    * Since: 1.2
    */
-  pspec = g_param_spec_object ("key-focus",
-                               P_("Key Focus"),
-                               P_("The currently key focused actor"),
-                               CLUTTER_TYPE_ACTOR,
-                               CLUTTER_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class, PROP_KEY_FOCUS, pspec);
+  obj_props[PROP_KEY_FOCUS] =
+      g_param_spec_object ("key-focus",
+                           P_("Key Focus"),
+                           P_("The currently key focused actor"),
+                           CLUTTER_TYPE_ACTOR,
+                           CLUTTER_PARAM_READWRITE);
 
   /**
    * ClutterStage:no-clear-hint:
@@ -2114,12 +2041,12 @@ clutter_stage_class_init (ClutterStageClass *klass)
    *
    * Since: 1.4
    */
-  pspec = g_param_spec_boolean ("no-clear-hint",
-                                P_("No Clear Hint"),
-                                P_("Whether the stage should clear its contents"),
-                                FALSE,
-                                CLUTTER_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class, PROP_NO_CLEAR_HINT, pspec);
+  obj_props[PROP_NO_CLEAR_HINT] =
+      g_param_spec_boolean ("no-clear-hint",
+                            P_("No Clear Hint"),
+                            P_("Whether the stage should clear its contents"),
+                            FALSE,
+                            CLUTTER_PARAM_READWRITE);
 
   /**
    * ClutterStage:accept-focus:
@@ -2128,46 +2055,15 @@ clutter_stage_class_init (ClutterStageClass *klass)
    *
    * Since: 1.6
    */
-  pspec = g_param_spec_boolean ("accept-focus",
-                                P_("Accept Focus"),
-                                P_("Whether the stage should accept focus on show"),
-                                TRUE,
-                                CLUTTER_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class, PROP_ACCEPT_FOCUS, pspec);
+  obj_props[PROP_ACCEPT_FOCUS] =
+      g_param_spec_boolean ("accept-focus",
+                            P_("Accept Focus"),
+                            P_("Whether the stage should accept focus on show"),
+                            TRUE,
+                            CLUTTER_PARAM_READWRITE);
+
+  g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
 
-  /**
-   * ClutterStage::fullscreen:
-   * @stage: the stage which was fullscreened
-   *
-   * The ::fullscreen signal is emitted when the stage is made fullscreen.
-   *
-   * Since: 0.6
-   */
-  stage_signals[FULLSCREEN] =
-    g_signal_new (I_("fullscreen"),
-		  G_TYPE_FROM_CLASS (gobject_class),
-		  G_SIGNAL_RUN_FIRST,
-		  G_STRUCT_OFFSET (ClutterStageClass, fullscreen),
-		  NULL, NULL,
-		  _clutter_marshal_VOID__VOID,
-		  G_TYPE_NONE, 0);
-  /**
-   * ClutterStage::unfullscreen:
-   * @stage: the stage which has left a fullscreen state.
-   *
-   * The ::unfullscreen signal is emitted when the stage leaves a fullscreen
-   * state.
-   *
-   * Since: 0.6
-   */
-  stage_signals[UNFULLSCREEN] =
-    g_signal_new (I_("unfullscreen"),
-		  G_TYPE_FROM_CLASS (gobject_class),
-		  G_SIGNAL_RUN_LAST,
-		  G_STRUCT_OFFSET (ClutterStageClass, unfullscreen),
-		  NULL, NULL,
-		  _clutter_marshal_VOID__VOID,
-		  G_TYPE_NONE, 0);
   /**
    * ClutterStage::activate:
    * @stage: the stage which was activated
@@ -2252,6 +2148,28 @@ clutter_stage_class_init (ClutterStageClass *klass)
                   G_TYPE_NONE, 0);
 
   /**
+   * ClutterStage::paint-view:
+   * @stage: the stage that received the event
+   * @view: a #ClutterStageView
+   *
+   * The ::paint-view signal is emitted before a #ClutterStageView is being
+   * painted.
+   *
+   * The view is painted in the default handler. Hence, if you want to perform
+   * some action after the view is painted, like reading the contents of the
+   * framebuffer, use g_signal_connect_after() or pass %G_CONNECT_AFTER.
+   */
+  stage_signals[PAINT_VIEW] =
+    g_signal_new (I_("paint-view"),
+                  G_TYPE_FROM_CLASS (gobject_class),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (ClutterStageClass, paint_view),
+                  NULL, NULL,
+                  _clutter_marshal_VOID__OBJECT,
+                  G_TYPE_NONE, 1,
+                  CLUTTER_TYPE_STAGE_VIEW);
+
+  /**
    * ClutterStage::presented: (skip)
    * @stage: the stage that received the event
    * @frame_event: a #CoglFrameEvent
@@ -2268,7 +2186,6 @@ clutter_stage_class_init (ClutterStageClass *klass)
                   G_TYPE_NONE, 2,
                   G_TYPE_INT, G_TYPE_POINTER);
 
-  klass->fullscreen = clutter_stage_real_fullscreen;
   klass->activate = clutter_stage_real_activate;
   klass->deactivate = clutter_stage_real_deactivate;
   klass->delete_event = clutter_stage_real_delete_event;
@@ -2319,21 +2236,12 @@ clutter_stage_init (ClutterStage *self)
 
   priv->event_queue = g_queue_new ();
 
-  priv->is_fullscreen = FALSE;
-  priv->is_user_resizable = FALSE;
   priv->is_cursor_visible = TRUE;
   priv->use_fog = FALSE;
   priv->throttle_motion_events = TRUE;
   priv->min_size_changed = FALSE;
   priv->sync_delay = -1;
-
-  /* XXX - we need to keep the invariant that calling
-   * clutter_set_motion_event_enabled() before the stage creation
-   * will cause motion event delivery to be disabled on any newly
-   * created stage. this can go away when we break API and remove
-   * deprecated functions.
-   */
-  priv->motion_events_enabled = _clutter_context_get_motion_events_enabled ();
+  priv->motion_events_enabled = TRUE;
 
   clutter_actor_set_background_color (CLUTTER_ACTOR (self),
                                       &default_stage_color);
@@ -2452,7 +2360,7 @@ clutter_stage_set_color (ClutterStage       *stage,
 {
   clutter_actor_set_background_color (CLUTTER_ACTOR (stage), color);
 
-  g_object_notify (G_OBJECT (stage), "color");
+  g_object_notify_by_pspec (G_OBJECT (stage), obj_props[PROP_COLOR]);
 }
 
 /**
@@ -2717,136 +2625,6 @@ _clutter_stage_get_viewport (ClutterStage *stage,
 }
 
 /**
- * clutter_stage_set_fullscreen:
- * @stage: a #ClutterStage
- * @fullscreen: %TRUE to to set the stage fullscreen
- *
- * Asks to place the stage window in the fullscreen or unfullscreen
- * states.
- *
- ( Note that you shouldn't assume the window is definitely full screen
- * afterward, because other entities (e.g. the user or window manager)
- * could unfullscreen it again, and not all window managers honor
- * requests to fullscreen windows.
- *
- * If you want to receive notification of the fullscreen state you
- * should either use the #ClutterStage::fullscreen and
- * #ClutterStage::unfullscreen signals, or use the notify signal
- * for the #ClutterStage:fullscreen-set property
- *
- * Since: 1.0
- */
-void
-clutter_stage_set_fullscreen (ClutterStage *stage,
-                              gboolean      fullscreen)
-{
-  ClutterStagePrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_STAGE (stage));
-
-  priv = stage->priv;
-
-  if (priv->is_fullscreen != fullscreen)
-    {
-      ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
-      ClutterStageWindowInterface *iface;
-
-      iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
-
-      /* Only set if backend implements.
-       *
-       * Also see clutter_stage_event() for setting priv->is_fullscreen
-       * on state change event.
-       */
-      if (iface->set_fullscreen)
-	iface->set_fullscreen (impl, fullscreen);
-    }
-
-  /* If the backend did fullscreen the stage window then we need to resize
-   * the stage and update its viewport so we queue a relayout.  Note: if the
-   * fullscreen request is handled asynchronously we can't rely on this
-   * queue_relayout to update the viewport, but for example the X backend
-   * will recieve a ConfigureNotify after a successful resize which is how
-   * we ensure the viewport is updated on X.
-   */
-  clutter_actor_queue_relayout (CLUTTER_ACTOR (stage));
-}
-
-/**
- * clutter_stage_get_fullscreen:
- * @stage: a #ClutterStage
- *
- * Retrieves whether the stage is full screen or not
- *
- * Return value: %TRUE if the stage is full screen
- *
- * Since: 1.0
- */
-gboolean
-clutter_stage_get_fullscreen (ClutterStage *stage)
-{
-  g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
-
-  return stage->priv->is_fullscreen;
-}
-
-/**
- * clutter_stage_set_user_resizable:
- * @stage: a #ClutterStage
- * @resizable: whether the stage should be user resizable.
- *
- * Sets if the stage is resizable by user interaction (e.g. via
- * window manager controls)
- *
- * Since: 0.4
- */
-void
-clutter_stage_set_user_resizable (ClutterStage *stage,
-                                  gboolean      resizable)
-{
-  ClutterStagePrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_STAGE (stage));
-
-  priv = stage->priv;
-
-  if (clutter_feature_available (CLUTTER_FEATURE_STAGE_USER_RESIZE)
-      && priv->is_user_resizable != resizable)
-    {
-      ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
-      ClutterStageWindowInterface *iface;
-
-      iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
-      if (iface->set_user_resizable)
-        {
-          priv->is_user_resizable = resizable;
-
-          iface->set_user_resizable (impl, resizable);
-
-          g_object_notify (G_OBJECT (stage), "user-resizable");
-        }
-    }
-}
-
-/**
- * clutter_stage_get_user_resizable:
- * @stage: a #ClutterStage
- *
- * Retrieves the value set with clutter_stage_set_user_resizable().
- *
- * Return value: %TRUE if the stage is resizable by the user.
- *
- * Since: 0.4
- */
-gboolean
-clutter_stage_get_user_resizable (ClutterStage *stage)
-{
-  g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
-
-  return stage->priv->is_user_resizable;
-}
-
-/**
  * clutter_stage_show_cursor:
  * @stage: a #ClutterStage
  *
@@ -2872,7 +2650,8 @@ clutter_stage_show_cursor (ClutterStage *stage)
 
           iface->set_cursor_visible (impl, TRUE);
 
-          g_object_notify (G_OBJECT (stage), "cursor-visible");
+          g_object_notify_by_pspec (G_OBJECT (stage),
+                                    obj_props[PROP_CURSOR_VISIBLE]);
         }
     }
 }
@@ -2905,7 +2684,8 @@ clutter_stage_hide_cursor (ClutterStage *stage)
 
           iface->set_cursor_visible (impl, FALSE);
 
-          g_object_notify (G_OBJECT (stage), "cursor-visible");
+          g_object_notify_by_pspec (G_OBJECT (stage),
+                                    obj_props[PROP_CURSOR_VISIBLE]);
         }
     }
 }
@@ -2949,6 +2729,8 @@ clutter_stage_read_pixels (ClutterStage *stage,
   float pixel_height;
   uint8_t *pixels;
 
+  COGL_TRACE_BEGIN_SCOPED (ClutterStageReadPixels, "Read Pixels");
+
   g_return_val_if_fail (CLUTTER_IS_STAGE (stage), NULL);
 
   priv = stage->priv;
@@ -3014,7 +2796,11 @@ clutter_stage_read_pixels (ClutterStage *stage,
  * @y: Y coordinate to check
  *
  * Checks the scene at the coordinates @x and @y and returns a pointer
- * to the #ClutterActor at those coordinates.
+ * to the #ClutterActor at those coordinates. The result is the actor which
+ * would be at the specified location on the next redraw, and is not
+ * necessarily that which was there on the previous redraw. This allows the
+ * function to perform chronologically correctly after any queued changes to
+ * the scene, and even if nothing has been drawn.
  *
  * By using @pick_mode it is possible to control which actors will be
  * painted and thus available.
@@ -3051,13 +2837,9 @@ gboolean
 clutter_stage_event (ClutterStage *stage,
                      ClutterEvent *event)
 {
-  ClutterStagePrivate *priv;
-
   g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
-  priv = stage->priv;
-
   if (event->type == CLUTTER_DELETE)
     {
       gboolean retval = FALSE;
@@ -3077,24 +2859,6 @@ clutter_stage_event (ClutterStage *stage,
   if (clutter_actor_event (CLUTTER_ACTOR (stage), event, FALSE))
     return TRUE;
 
-  if (event->stage_state.changed_mask & CLUTTER_STAGE_STATE_FULLSCREEN)
-    {
-      if (event->stage_state.new_state & CLUTTER_STAGE_STATE_FULLSCREEN)
-	{
-	  priv->is_fullscreen = TRUE;
-	  g_signal_emit (stage, stage_signals[FULLSCREEN], 0);
-
-          g_object_notify (G_OBJECT (stage), "fullscreen-set");
-	}
-      else
-	{
-	  priv->is_fullscreen = FALSE;
-	  g_signal_emit (stage, stage_signals[UNFULLSCREEN], 0);
-
-          g_object_notify (G_OBJECT (stage), "fullscreen-set");
-	}
-    }
-
   if (event->stage_state.changed_mask & CLUTTER_STAGE_STATE_ACTIVATED)
     {
       if (event->stage_state.new_state & CLUTTER_STAGE_STATE_ACTIVATED)
@@ -3133,7 +2897,7 @@ clutter_stage_set_title (ClutterStage       *stage,
   if (CLUTTER_STAGE_WINDOW_GET_IFACE(impl)->set_title != NULL)
     CLUTTER_STAGE_WINDOW_GET_IFACE (impl)->set_title (impl, priv->title);
 
-  g_object_notify (G_OBJECT (stage), "title");
+  g_object_notify_by_pspec (G_OBJECT (stage), obj_props[PROP_TITLE]);
 }
 
 /**
@@ -3233,7 +2997,7 @@ clutter_stage_set_key_focus (ClutterStage *stage,
   else
     g_signal_emit_by_name (stage, "key-focus-in");
 
-  g_object_notify (G_OBJECT (stage), "key-focus");
+  g_object_notify_by_pspec (G_OBJECT (stage), obj_props[PROP_KEY_FOCUS]);
 }
 
 /**
@@ -3911,7 +3675,7 @@ clutter_stage_set_use_alpha (ClutterStage *stage,
 
       clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
 
-      g_object_notify (G_OBJECT (stage), "use-alpha");
+      g_object_notify_by_pspec (G_OBJECT (stage), obj_props[PROP_USE_ALPHA]);
     }
 }
 
@@ -3949,8 +3713,6 @@ clutter_stage_get_use_alpha (ClutterStage *stage)
  * If the current size of @stage is smaller than the minimum size, the
  * @stage will be resized to the new @width and @height
  *
- * This function has no effect if @stage is fullscreen
- *
  * Since: 1.2
  */
 void
@@ -4127,7 +3889,7 @@ clutter_stage_set_no_clear_hint (ClutterStage *stage,
 
   priv->stage_hints = new_hints;
 
-  g_object_notify (G_OBJECT (stage), "no-clear-hint");
+  g_object_notify_by_pspec (G_OBJECT (stage), obj_props[PROP_NO_CLEAR_HINT]);
 }
 
 /**
@@ -4369,7 +4131,7 @@ clutter_stage_set_accept_focus (ClutterStage *stage,
   if (priv->accept_focus != accept_focus)
     {
       _clutter_stage_window_set_accept_focus (priv->impl, accept_focus);
-      g_object_notify (G_OBJECT (stage), "accept-focus");
+      g_object_notify_by_pspec (G_OBJECT (stage), obj_props[PROP_ACCEPT_FOCUS]);
     }
 }
 
@@ -4638,20 +4400,6 @@ _clutter_stage_is_activated (ClutterStage *stage)
 }
 
 /*< private >
- * _clutter_stage_is_fullscreen:
- * @stage: a #ClutterStage
- *
- * Checks whether the @stage state includes %CLUTTER_STAGE_STATE_FULLSCREEN.
- *
- * Return value: %TRUE if the @stage is fullscreen
- */
-gboolean
-_clutter_stage_is_fullscreen (ClutterStage *stage)
-{
-  return (stage->priv->current_state & CLUTTER_STAGE_STATE_FULLSCREEN) != 0;
-}
-
-/*< private >
  * _clutter_stage_update_state:
  * @stage: a #ClutterStage
  * @unset_flags: flags to unset
diff --git a/clutter/clutter/clutter-stage.h b/clutter/clutter/clutter-stage.h
index 5730af7..c28904b 100644
--- a/clutter/clutter/clutter-stage.h
+++ b/clutter/clutter/clutter-stage.h
@@ -30,6 +30,7 @@
 
 #include <clutter/clutter-types.h>
 #include <clutter/clutter-group.h>
+#include <clutter/clutter-stage-view.h>
 
 G_BEGIN_DECLS
 
@@ -61,8 +62,6 @@ struct _ClutterStage
 };
 /**
  * ClutterStageClass:
- * @fullscreen: handler for the #ClutterStage::fullscreen signal
- * @unfullscreen: handler for the #ClutterStage::unfullscreen signal
  * @activate: handler for the #ClutterStage::activate signal
  * @deactivate: handler for the #ClutterStage::deactivate signal
  * @delete_event: handler for the #ClutterStage::delete-event signal
@@ -79,17 +78,18 @@ struct _ClutterStageClass
 
   /*< public >*/
   /* signals */
-  void (* fullscreen)   (ClutterStage *stage);
-  void (* unfullscreen) (ClutterStage *stage);
   void (* activate)     (ClutterStage *stage);
   void (* deactivate)   (ClutterStage *stage);
 
   gboolean (* delete_event) (ClutterStage *stage,
                              ClutterEvent *event);
 
+  void (* paint_view) (ClutterStage     *stage,
+                       ClutterStageView *view);
+
   /*< private >*/
   /* padding for future expansion */
-  gpointer _padding_dummy[31];
+  gpointer _padding_dummy[30];
 };
 
 /**
@@ -168,11 +168,6 @@ CLUTTER_EXPORT
 void            clutter_stage_get_perspective                   (ClutterStage          *stage,
 			                                         ClutterPerspective    *perspective);
 CLUTTER_EXPORT
-void            clutter_stage_set_fullscreen                    (ClutterStage          *stage,
-                                                                 gboolean               fullscreen);
-CLUTTER_EXPORT
-gboolean        clutter_stage_get_fullscreen                    (ClutterStage          *stage);
-CLUTTER_EXPORT
 void            clutter_stage_show_cursor                       (ClutterStage          *stage);
 CLUTTER_EXPORT
 void            clutter_stage_hide_cursor                       (ClutterStage          *stage);
@@ -181,11 +176,6 @@ void            clutter_stage_set_title                         (ClutterStage   
                                                                  const gchar           *title);
 CLUTTER_EXPORT
 const gchar *   clutter_stage_get_title                         (ClutterStage          *stage);
-CLUTTER_EXPORT
-void            clutter_stage_set_user_resizable                (ClutterStage          *stage,
-						                 gboolean               resizable);
-CLUTTER_EXPORT
-gboolean        clutter_stage_get_user_resizable                (ClutterStage          *stage);
 
 CLUTTER_EXPORT
 void            clutter_stage_set_minimum_size                  (ClutterStage          *stage,
@@ -274,6 +264,10 @@ gboolean clutter_stage_capture (ClutterStage          *stage,
                                 cairo_rectangle_int_t *rect,
                                 ClutterCapture       **captures,
                                 int                   *n_captures);
+CLUTTER_EXPORT
+ClutterStageView * clutter_stage_get_view_at (ClutterStage *stage,
+                                              float         x,
+                                              float         y);
 
 G_END_DECLS
 
diff --git a/clutter/clutter/clutter-text-buffer.c b/clutter/clutter/clutter-text-buffer.c
index f3a40d6..1436921 100644
--- a/clutter/clutter/clutter-text-buffer.c
+++ b/clutter/clutter/clutter-text-buffer.c
@@ -171,7 +171,7 @@ clutter_text_buffer_normal_insert_text (ClutterTextBuffer *buffer,
 
   /* Actual text insertion */
   at = g_utf8_offset_to_pointer (pv->normal_text, position) - pv->normal_text;
-  g_memmove (pv->normal_text + at + n_bytes, pv->normal_text + at, pv->normal_text_bytes - at);
+  memmove (pv->normal_text + at + n_bytes, pv->normal_text + at, pv->normal_text_bytes - at);
   memcpy (pv->normal_text + at, chars, n_bytes);
 
   /* Book keeping */
@@ -201,7 +201,7 @@ clutter_text_buffer_normal_delete_text (ClutterTextBuffer *buffer,
       start = g_utf8_offset_to_pointer (pv->normal_text, position) - pv->normal_text;
       end = g_utf8_offset_to_pointer (pv->normal_text, position + n_chars) - pv->normal_text;
 
-      g_memmove (pv->normal_text + start, pv->normal_text + end, pv->normal_text_bytes + 1 - end);
+      memmove (pv->normal_text + start, pv->normal_text + end, pv->normal_text_bytes + 1 - end);
       pv->normal_text_chars -= n_chars;
       pv->normal_text_bytes -= (end - start);
 
@@ -228,8 +228,8 @@ clutter_text_buffer_real_inserted_text (ClutterTextBuffer *buffer,
                                      const gchar    *chars,
                                      guint           n_chars)
 {
-  g_object_notify (G_OBJECT (buffer), "text");
-  g_object_notify (G_OBJECT (buffer), "length");
+  g_object_notify_by_pspec (G_OBJECT (buffer), obj_props[PROP_TEXT]);
+  g_object_notify_by_pspec (G_OBJECT (buffer), obj_props[PROP_LENGTH]);
 }
 
 static void
@@ -237,8 +237,8 @@ clutter_text_buffer_real_deleted_text (ClutterTextBuffer *buffer,
                                     guint           position,
                                     guint           n_chars)
 {
-  g_object_notify (G_OBJECT (buffer), "text");
-  g_object_notify (G_OBJECT (buffer), "length");
+  g_object_notify_by_pspec (G_OBJECT (buffer), obj_props[PROP_TEXT]);
+  g_object_notify_by_pspec (G_OBJECT (buffer), obj_props[PROP_LENGTH]);
 }
 
 /* --------------------------------------------------------------------------------
@@ -598,7 +598,7 @@ clutter_text_buffer_set_max_length (ClutterTextBuffer *buffer,
     clutter_text_buffer_delete_text (buffer, max_length, -1);
 
   buffer->priv->max_length = max_length;
-  g_object_notify (G_OBJECT (buffer), "max-length");
+  g_object_notify_by_pspec (G_OBJECT (buffer), obj_props[PROP_MAX_LENGTH]);
 }
 
 /**
diff --git a/clutter/clutter/clutter-text.c b/clutter/clutter/clutter-text.c
index 000bbbb..7bc6565 100644
--- a/clutter/clutter/clutter-text.c
+++ b/clutter/clutter/clutter-text.c
@@ -751,7 +751,7 @@ clutter_text_create_layout_no_cache (ClutterText       *text,
       if (priv->password_char != 0)
         pango_dir = PANGO_DIRECTION_NEUTRAL;
       else
-        pango_dir = pango_find_base_dir (contents, contents_len);
+        pango_dir = _clutter_pango_find_base_dir (contents, contents_len);
 
       if (pango_dir == PANGO_DIRECTION_NEUTRAL)
         {
@@ -4821,7 +4821,7 @@ buffer_notify_max_length (ClutterTextBuffer *buffer,
                           GParamSpec        *spec,
                           ClutterText       *self)
 {
-  g_object_notify (G_OBJECT (self), "max-length");
+  g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_MAX_LENGTH]);
 }
 
 static void
@@ -4920,9 +4920,9 @@ clutter_text_set_buffer (ClutterText       *self,
 
   obj = G_OBJECT (self);
   g_object_freeze_notify (obj);
-  g_object_notify (obj, "buffer");
-  g_object_notify (obj, "text");
-  g_object_notify (obj, "max-length");
+  g_object_notify_by_pspec (obj, obj_props[PROP_BUFFER]);
+  g_object_notify_by_pspec (obj, obj_props[PROP_TEXT]);
+  g_object_notify_by_pspec (obj, obj_props[PROP_MAX_LENGTH]);
   g_object_thaw_notify (obj);
 }
 
diff --git a/clutter/clutter/clutter-util.c b/clutter/clutter/clutter-util.c
index ed52b69..917da76 100644
--- a/clutter/clutter/clutter-util.c
+++ b/clutter/clutter/clutter-util.c
@@ -32,6 +32,7 @@
 
 #include "clutter-build-config.h"
 
+#include <fribidi.h>
 #include <math.h>
 
 #include "clutter-debug.h"
@@ -105,8 +106,9 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
     }
 }
 
-void _clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
-                                        ClutterRect                 *dest)
+void
+_clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
+                                   ClutterRect                 *dest)
 {
   *dest = (ClutterRect) {
     .origin = {
@@ -120,8 +122,9 @@ void _clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
   };
 }
 
-void _clutter_util_rectangle_int_extents (const  ClutterRect    *src,
-                                          cairo_rectangle_int_t *dest)
+void
+_clutter_util_rectangle_int_extents (const  ClutterRect    *src,
+                                     cairo_rectangle_int_t *dest)
 {
   ClutterRect tmp = *src;
 
@@ -135,10 +138,11 @@ void _clutter_util_rectangle_int_extents (const  ClutterRect    *src,
   };
 }
 
-void _clutter_util_rectangle_offset (const cairo_rectangle_int_t *src,
-                                     int                          x,
-                                     int                          y,
-                                     cairo_rectangle_int_t       *dest)
+void
+_clutter_util_rectangle_offset (const cairo_rectangle_int_t *src,
+                                int                          x,
+                                int                          y,
+                                cairo_rectangle_int_t       *dest)
 {
   *dest = *src;
 
@@ -696,3 +700,45 @@ clutter_interval_register_progress_func (GType               value_type,
 
   G_UNLOCK (progress_funcs);
 }
+
+PangoDirection
+_clutter_pango_unichar_direction (gunichar ch)
+{
+  FriBidiCharType fribidi_ch_type;
+
+  G_STATIC_ASSERT (sizeof (FriBidiChar) == sizeof (gunichar));
+
+  fribidi_ch_type = fribidi_get_bidi_type (ch);
+
+  if (!FRIBIDI_IS_STRONG (fribidi_ch_type))
+    return PANGO_DIRECTION_NEUTRAL;
+  else if (FRIBIDI_IS_RTL (fribidi_ch_type))
+    return PANGO_DIRECTION_RTL;
+  else
+    return PANGO_DIRECTION_LTR;
+}
+
+PangoDirection
+_clutter_pango_find_base_dir (const gchar *text,
+                              gint         length)
+{
+  PangoDirection dir = PANGO_DIRECTION_NEUTRAL;
+  const gchar *p;
+
+  g_return_val_if_fail (text != NULL || length == 0, PANGO_DIRECTION_NEUTRAL);
+
+  p = text;
+  while ((length < 0 || p < text + length) && *p)
+    {
+      gunichar wc = g_utf8_get_char (p);
+
+      dir = _clutter_pango_unichar_direction (wc);
+
+      if (dir != PANGO_DIRECTION_NEUTRAL)
+        break;
+
+      p = g_utf8_next_char (p);
+    }
+
+  return dir;
+}
diff --git a/clutter/clutter/clutter.h b/clutter/clutter/clutter.h
index 231d8cd..ec84691 100644
--- a/clutter/clutter/clutter.h
+++ b/clutter/clutter/clutter.h
@@ -101,6 +101,7 @@
 #include "clutter-snap-constraint.h"
 #include "clutter-stage.h"
 #include "clutter-stage-manager.h"
+#include "clutter-stage-view.h"
 #include "clutter-tap-action.h"
 #include "clutter-test-utils.h"
 #include "clutter-texture.h"
diff --git a/clutter/clutter/cogl/clutter-stage-cogl.c b/clutter/clutter/cogl/clutter-stage-cogl.c
index e0c3918..8f97a5f 100644
--- a/clutter/clutter/cogl/clutter-stage-cogl.c
+++ b/clutter/clutter/cogl/clutter-stage-cogl.c
@@ -45,6 +45,9 @@
 #include "clutter-main.h"
 #include "clutter-private.h"
 #include "clutter-stage-private.h"
+#include "clutter-stage-view-private.h"
+
+#include "cogl/cogl-trace.h"
 
 typedef struct _ClutterStageViewCoglPrivate
 {
@@ -78,6 +81,10 @@ enum
 };
 
 static void
+clutter_stage_cogl_schedule_update (ClutterStageWindow *stage_window,
+                                    gint                sync_delay);
+
+static void
 clutter_stage_cogl_unrealize (ClutterStageWindow *stage_window)
 {
   CLUTTER_NOTE (BACKEND, "Unrealizing Cogl stage [%p]", stage_window);
@@ -122,6 +129,16 @@ _clutter_stage_cogl_presented (ClutterStageCogl *stage_cogl,
     }
 
   _clutter_stage_presented (stage_cogl->wrapper, frame_event, frame_info);
+
+  if (frame_event == COGL_FRAME_EVENT_COMPLETE &&
+      stage_cogl->update_time != -1)
+    {
+      ClutterStageWindow *stage_window = CLUTTER_STAGE_WINDOW (stage_cogl);
+
+      stage_cogl->update_time = -1;
+      clutter_stage_cogl_schedule_update (stage_window,
+                                          stage_cogl->last_sync_delay);
+    }
 }
 
 static gboolean
@@ -152,10 +169,15 @@ clutter_stage_cogl_schedule_update (ClutterStageWindow *stage_window,
   gint64 now;
   float refresh_rate;
   gint64 refresh_interval;
+  int64_t min_render_time_allowed;
+  int64_t max_render_time_allowed;
+  int64_t next_presentation_time;
 
   if (stage_cogl->update_time != -1)
     return;
 
+  stage_cogl->last_sync_delay = sync_delay;
+
   now = g_get_monotonic_time ();
 
   if (sync_delay < 0)
@@ -164,30 +186,56 @@ clutter_stage_cogl_schedule_update (ClutterStageWindow *stage_window,
       return;
     }
 
-  /* We only extrapolate presentation times for 150ms  - this is somewhat
-   * arbitrary. The reasons it might not be accurate for larger times are
-   * that the refresh interval might be wrong or the vertical refresh
-   * might be downclocked if nothing is going on onscreen.
-   */
-  if (stage_cogl->last_presentation_time == 0||
-      stage_cogl->last_presentation_time < now - 150000)
+  refresh_rate = stage_cogl->refresh_rate;
+  if (refresh_rate <= 0.0)
+    refresh_rate = clutter_get_default_frame_rate ();
+
+  refresh_interval = (gint64) (0.5 + G_USEC_PER_SEC / refresh_rate);
+  if (refresh_interval == 0)
     {
       stage_cogl->update_time = now;