cally: avoid creating accessible during actor removal

If the ClutterActor does not have an accessible created, then avoid requesting one. Without this, we risk creating an accessible during the removal of the actor. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1083
clutter: add clutter_actor_has_accessible()
2020-02-24 22:21:24 +00:00 · 2020-02-24 22:21:24 +00:00 · 2020-02-24 22:21:24 +00:00
832 changed files with 55622 additions and 43991 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -103,4 +103,3 @@ doc/reference/meta.types
 .dirstamp
 **/tags.*
 build/
-subprojects/sysprof/
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,10 +1,9 @@
-image: registry.gitlab.gnome.org/gnome/mutter/master:v4
+image: registry.gitlab.gnome.org/gnome/mutter/master:v3

 stages:
 - review
 - build
 - test
- - coverage

 check-commit-log:
  stage: review
@@ -17,9 +16,8 @@ check-commit-log:

 build-mutter:
  stage: build
-  needs: []
  script:
-    - meson . build -Dbuildtype=debugoptimized -Db_coverage=true -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
+    - meson . build -Dbuildtype=debugoptimized -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
    - ninja -C build
    - ninja -C build install
  artifacts:
@@ -30,30 +28,16 @@ build-mutter:
    - merge_requests
    - /^.*$/

-build-without-opengl-and-glx:
-  stage: build
-  needs: []
-  script:
-    - meson . build -Dbuildtype=debugoptimized -Dopengl=false -Dglx=false -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
-    - ninja -C build
-    - ninja -C build install
-  artifacts:
-    paths:
-      - build/meson-logs
-  only:
-    - merge_requests
-    - /^.*$/
-
 build-without-native-backend-and-wayland:
  stage: build
-  needs: []
  script:
    - meson . build -Dbuildtype=debugoptimized -Dnative_backend=false -Dudev=false -Dwayland=false -Dcore_tests=false --werror --prefix /usr
    - ninja -C build
    - ninja -C build install
  artifacts:
+    expire_in: 1 day
    paths:
-      - build/meson-logs
+      - build
  only:
    - merge_requests
    - /^.*$/
@@ -62,13 +46,13 @@ test-mutter:
  stage: test
  dependencies:
    - build-mutter
-  needs: ["build-mutter"]
  variables:
    XDG_RUNTIME_DIR: "$CI_PROJECT_DIR/runtime-dir"
    GSETTINGS_SCHEMA_DIR: "$CI_PROJECT_DIR/build/data"
    G_SLICE: "always-malloc"
    MALLOC_CHECK_: "3"
    NO_AT_BRIDGE: "1"
+    MALLOC_PERTURB_: "123"
  script:
    - dconf update
    - mkdir -m 700 $XDG_RUNTIME_DIR
@@ -76,36 +60,14 @@ test-mutter:
    - >
      dbus-run-session -- xvfb-run -s '+iglx -noreset'
      meson test -C build --no-rebuild -t 10 --verbose --no-stdsplit --print-errorlogs --wrap catchsegv
-  artifacts:
-    expire_in: 1 day
-    paths:
-      - build
  only:
    - merge_requests
    - /^.*$/

-test-mutter-coverage:
-  stage: coverage
-  dependencies:
-    - test-mutter
-  needs: ["test-mutter"]
-  script:
-    - ninja -C build coverage
-    - cat build/meson-logs/coverage.txt
-  artifacts:
-    paths:
-      - build/meson-logs
-  when: manual
-  except:
-    refs:
-      - tags
-      - master
-
 can-build-gnome-shell:
  stage: test
  dependencies:
    - build-mutter
-  needs: ["build-mutter"]
  before_script:
    - meson install --no-rebuild -C build
  script:
--- a/.gitlab-ci/Dockerfile
+++ b/.gitlab-ci/Dockerfile
@@ -1,28 +1,32 @@
 # Rebuild and push with
 #
 #     cd .gitlab-ci/
-#     podman build --format docker --no-cache -t registry.gitlab.gnome.org/gnome/mutter/master:v4 .
-#     podman push registry.gitlab.gnome.org/gnome/mutter/master:v4
+#     podman build --format docker --no-cache -t registry.gitlab.gnome.org/gnome/mutter/master:v3 .
+#     podman push registry.gitlab.gnome.org/gnome/mutter/master:v3
 #

-FROM fedora:32
+FROM fedora:31

 RUN dnf -y update && dnf -y upgrade && \
    dnf install -y 'dnf-command(builddep)' && \
    dnf install -y 'dnf-command(copr)' && \
+    dnf copr enable -y fmuellner/gnome-shell-ci && \
    dnf copr enable -y jadahl/mutter-ci && \
+    dnf -y update && dnf -y upgrade && \

-    dnf builddep -y mutter --setopt=install_weak_deps=False && \
+    dnf builddep -y mutter && \
+
+    # Until Fedora catches up with new build-deps
+    dnf install -y 'pkgconfig(graphene-gobject-1.0)' 'pkgconfig(sysprof-capture-3)' && \

    # For running unit tests
-    dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 \
-        '*/xvfb-run' gdm-lib accountsservice-libs gnome-control-center gcovr \
-        libnma python3-gobject python3-dbusmock \
-        --setopt=install_weak_deps=False && \
+    dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 '*/xvfb-run' gdm-lib accountsservice-libs gnome-control-center && \

    # GNOME Shell
    dnf builddep -y gnome-shell --setopt=install_weak_deps=False && \
-    dnf remove -y gnome-bluetooth-libs-devel && \
+    dnf remove -y gnome-bluetooth-libs-devel dbus-glib-devel upower-devel python3-devel && \
    dnf remove -y --noautoremove mutter mutter-devel && \

+    dnf upgrade -y 'pkgconfig(libpipewire-0.3)' && \
+
    dnf clean all
--- a/.gitlab-ci/check-commit-log.sh
+++ b/.gitlab-ci/check-commit-log.sh
@@ -19,7 +19,7 @@ fi
 function commit_message_has_url() {
  commit=$1
  commit_message=$(git show -s --format='format:%b' $commit)
-  echo "$commit_message" | grep -qe "\($CI_MERGE_REQUEST_PROJECT_URL/\(-/\)\?\(issues\|merge_requests\)/[0-9]\+\|https://bugzilla.gnome.org/show_bug.cgi?id=[0-9]\+\)"
+  echo "$commit_message" | grep -qe "\($CI_MERGE_REQUEST_PROJECT_URL/\(issues\|merge_requests\)/[0-9]\+\|https://bugzilla.gnome.org/show_bug.cgi?id=[0-9]\+\)"
  return $?
 }

--- a/166
+++ b/166
@@ -1,169 +1,3 @@
-3.37.90
-=======
-* Fix using NEAREST filter for backgrounds on scaled monitors [Daniel V.; !1346]
-* Screencast fixes and improvements [Jonas; !1361, !1377, !1391]
-* Support tap-button-map and tap-drag-lock touchpad settings [Giusy; !1319]
-* Fix wine copy & paste [Sebastian; !1369]
-* Fix shadows of server-side decorated XWayland windows [Olivier; #1358]
-* Replace some loaded terms with more descriptive ones [Olivier; !1396]
-* Add API to launch trusted wayland clients [Sergio; #741]
-* Skip displays with 'non-desktop' property set [Philipp; !1393]
-* Invalidate offscreen effect cache on video memory purge [Daniel V.; !1374]
-* Add wl_shm support for 10 bpc and 16 bpc half float formats [Jonas; !804]
-* Fixed crashes [Jonas, Erik, Martin; !1365, !1375, #1343]
-* Misc. bug fixes and cleanups [Daniel V., Carlos, Olivier, Christian,
-  Daniel * G., Jonas, Florian; !1370, !1376, !1385, !1352, !1386, !1390,
-  !1388, !1397, !1398, !1401]
-
-Contributors:
-  Jonas Ådahl, Sergio Costas, Olivier Fourdan, Carlos Garnacho,
-  Christian Hergert, Sebastian Keller, Erik Kurzinger, Giusy Margarita,
-  Daniel García Moreno, Florian Müllner, Daniel van Vugt, Martin Whitaker,
-  Philipp Zabel
-
-Translators:
-  Fabio Tomat [fur], Rafael Fontenelle [pt_BR], Jordi Mas [ca],
-  Yuri Chornoivan [uk], Alexandre Franke [fr]
-
-3.37.3
-======
-* Support custom keyboard layouts in $XDG_CONFIG_HOME/xkb [Peter; !936]
-* Optimize resource scale computation [Jonas D.; !1196, !1276, !1343]
-* Allow animating ClutterActor's content property [Georges; !1301]
-* Implement backgrounds as ClutterContent [Georges; !1302]
-* Add ClutterAlignContraint:pivot-point property [Jonas D.; !737]
-* Fix crash on area screenshots with fractional scaling [Sebastian; !1320]
-* Do not paint textures of fully obscured windows [Robert; !1326]
-* Use a more appropriate combine function on opaque areas [Daniel; !1331]
-* Fix remote desktop being broken without screencast session [Olivier; #1307]
-* Remove more long-deprecated Clutter APIs [Adam, Georges; !1194, !1332]
-* Drive each monitor by its own frame clock [Jonas Å.; !1285]
-* Fix copy/paste failures on X11 [Carlos; !1350]
-* Mipmap background texture rendering [Daniel; !1347]
-* Plugged memory leaks [Sebastian, Jonas D.; !1293, !1281, !1304]
-* Misc. bug fixes and cleanups [Jonas Å., Jonas D., Daniel, Corentin, Carlos,
-  Sebastian, Michel, Robert, Florian; !1288, !1289, !1291, !1296, !1292, !1298,
-  !1300, !1303, !1290, !1287, !1306, !1305, !1308, !1313, !1250, !1314, !1267,
-  !1275, !1317, !1270, !1322, !1181, !1282, !1325, !1323, !1240, !1295, !1329,
-  !1333, !1334, !1336, !1341, #1312, !1345, !1349, !1356, #873, !1310, !1357]
-
-Contributors:
-  Jonas Dreßler, Michel Dänzer, Olivier Fourdan, Carlos Garnacho,
-  Peter Hutterer, Adam Jackson, Sebastian Keller, Robert Mader, Florian Müllner,
-  Georges Basile Stavracas Neto, Corentin Noël, Daniel van Vugt, Jonas Ådahl
-
-3.37.2
-======
-* Fix move-to-center keybinding with multiple monitors [Sergey; #1073]
-* Fix stuck buttons when a virtual device is destroyed [Carlos; !1239]
-* Use workarea when centering new windows [Akatsuki; #964]
-* Limit mipmap levels when rendering background [Daniel; !1003]
-* Broadcast clipboard/primary offers [Carlos; !1253]
-* Support primary-selection protocol from wayland-protocols [Carlos; !1255]
-* Fix monitor screen cast on X11 [Jonas Å.; !1251]
-* Support a "blank" cursor type [Florian; !1244]
-* Improve stage view damage tracking [Jonas Å.; !1237]
-* Implement touch-mode detecation for the X11 backend [Carlos; !1278]
-* Drop external keyboard detection from touch-mode heuristics [Carlos; !1277]
-* Optimize actor allocations [Jonas D.; !1247]
-* Fixed crashes [Daniel, Carlos, Jonas Å., Jonas D.; !1256, !1258, !1217, !1280]
-* Misc. bug fixes and cleanups [Christian, Jonas D., Olivier, Ting-Wei,
-  Jonas Å., Marco, Corentin, Daniel, Robert, Niels, Florian, Simon; !1231,
-  !1228, !1238, !1229, !1192, !1236, !1171, !1134, #1126, !1234, !1230, !1210,
-  !1242, !1243, !1252, !1113, !1232, !1259, !1245, !1265, !1180, !1261, !788,
-  !1264, !1235, !1218, !1150, !1274, !1271, !1279, !1283, !1272]
-
-Contributors:
-  Marco Trevisan (Treviño), Akatsuki, Jonas Dreßler, Olivier Fourdan,
-  Carlos Garnacho, Niels De Graef, Ting-Wei Lan, Robert Mader, Simon McVittie,
-  Florian Müllner, Corentin Noël, Christian Rauch, Daniel van Vugt,
-  Sergey Zigachev, Jonas Ådahl
-
-3.37.1
-======
-* Fix screencasting non-maximized windows [Jonas Å.; !1174]
-* Make window-aliveness checks less aggressive [Jonas Å.; !1182]
-* Fix stylus coordinates when using screen rotation [Jonas T.; #1118]
-* Preserve keyboard state on VT switch [Olivier; !1185]
-* Remove Clutter's drag and drop actions [Jonas D.; !789]
-* Cancel clicks/gestures actions on disable [Georges; !1188]
-* Fix various clipboard issues [Carlos; !1186, !1198, !1203, !1204, !1206]
-* Fix trackball button scrolling [Phillip; #1120]
-* Fix tiled monitor support [Jonas; !1199]
-* Support unredirecting fullscreen wayland surfaces [Jonas Å.; !798]
-* Support area screencasts [Jonas Å.; !1207]
-* Synchronize shadows to server-side decorations [Olivier; !1214]
-* Allow inhibiting remote access [Jonas Å.; !1212]
-* Fix overview key on X11 when using multiple keyboard layouts [Olivier; !1219]
-* Fixed crashes [Jonas, D., Carlos; !1173, !1183, !1012]
-* Misc. bug fixes and cleanups [Andre, Georges, Christian, Jonas Å., Andre,
-  Simon, Florian, Carlos, Adam, Marco, Thomas, Elias, Pekka, Jonas D.,
-  Laurent; !1169, !1168, !1166, !1170, !1167, !1172, !1175, !1176, !1184,
-  !1126, !1187, !1191, !1195, !1179, !1200, !1193, !1209, !1213, !1208,
-  #1074, !1223]
-
-Contributors:
-  Marco Trevisan (Treviño), Elias Aebi, Thomas Hindoe Paaboel Andersen,
-  Laurent Bigonville, Jonas Dreßler, Olivier Fourdan, Carlos Garnacho,
-  Adam Jackson, Andre Moreira Magalhaes, Simon McVittie, Florian Müllner,
-  Georges Basile Stavracas Neto, Pekka Paalanen, Christian Rauch, Jonas Troeger,
-  Phillip Wood, Jonas Ådahl
-
-Translators:
-  Dušan Kazik [sk], Christian Kirbach [de]
-
-3.36.0
-======
-* Fix placement of popup windows in multi-monitor setups [Jonas; !1110]
-* Fix invisible mouse cursor on some hardware [Jonas; !1079]
-
-Contributors:
-  Jonas Ådahl
-
-Translators:
-  Aurimas Černius [lt], Goran Vidović [hr], Anders Jonsson [sv],
-  Guillaume Bernard [fr], Milo Casagrande [it], Daniel Korostil [uk],
-  Andre Klapper [cy], Aman Alam [pa], Nathan Follens [nl]
-
-3.35.92
-=======
-* Fix visibility of initially hidden windows [Jonas Å.; !1066]
-* Avoid flicker when (un)redirecting windows [Sebastian; #997]
-* Let BindConstraints update the preferred size [Emmanuele; !1070]
-* Learn about GLES3 [Adam; !882]
-* Ping windows on every window focus [Jonas D.; !891]
-* Remove overhead from hot code paths [Christian;
-  #1056, !1081, !1083, !1071, !1087]
-* Allow remote desktop services to inhibit animations [Jonas Å.; !838]
-* Update screen-cast code to PipeWire 0.3 API [Wim; !1062]
-* Make check-alive timeouts configurable [Jonas Å.; !1080]
-* Make each stage view correspond to a single CRTC [Jonas Å.; !1042]
-* Implement scaled/transformed hardware cursors [Robert; !526]
-* Use DMA buffers for screencasting if possible [Georges; !1086]
-* Make Xwayland startup asynchronous [Carlos; !944]
-* Fix clipping glitches in long text entries [Jonas D.; !1096]
-* Add side channel for starting required X11 services [Carlos; !945]
-* Support synchronized wayland popup moving [Jonas Å.; !705]
-* Fixed crashes [Olivier, Jonas Å.; !1073, !1093]
-* Plugged memory leaks [Sebastian, Jonas Å.; !1089, !1095]
-* Misc. bug fixes and cleanups [Jonas Å, Olivier, Florian, Daniel, Jonas D.,
-  Robert, Sebastian, Christian, Arun, Carlos, worldofpeace; !1061, #1043,
-  !1067, !1068, !1065, !835, !1058, !1069, !1075, #1060, !1077, !423, !1090,
-  !1088, !1094, #1067, !1064, !1099, !957, !1000, !1082]
-
-Contributors:
-  Emmanuele Bassi, Jonas Dreßler, Olivier Fourdan, Carlos Garnacho,
-  Christian Hergert, Adam Jackson, Sebastian Keller, Robert Mader,
-  Florian Müllner, Georges Basile Stavracas Neto, Arun Raghavan, Wim Taymans,
-  Daniel van Vugt, worldofpeace, Jonas Ådahl
-
-Translators:
-  Yi-Jyun Pan [zh_TW], Asier Sarasua Garmendia [eu], Rafael Fontenelle [pt_BR],
-  Emin Tufan Çetin [tr], Daniel Mustieles [es], Balázs Úr [hu],
-  Gwan-gyeong Mun [ko], Marek Černocký [cs], Fran Dieguez [gl],
-  Kukuh Syafaat [id], Alan Mortensen [da], Piotr Drąg [pl], sicklylife [ja],
-  Matej Urbančič [sl]
-
 3.35.91
 =======
 * Honor accelerometer orientation on monitor config changes [Hans; !959]
--- a/clutter/clutter/cally/cally-group.c
+++ b/clutter/clutter/cally/cally-group.c
@@ -0,0 +1,147 @@
+/* CALLY - The Clutter Accessibility Implementation Library
+ *
+ * Copyright (C) 2008 Igalia, S.L.
+ *
+ * Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
+ *
+ * Based on GailContainer from GAIL
+ * Copyright 2001, 2002, 2003 Sun Microsystems 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, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:cally-group
+ * @Title: CallyGroup
+ * @short_description: Implementation of the ATK interfaces for a #ClutterGroup
+ * @see_also: #ClutterGroup
+ *
+ * #CallyGroup implements the required ATK interfaces of #ClutterGroup
+ * In particular it exposes each of the Clutter actors contained in the
+ * group.
+ */
+
+#include "clutter-build-config.h"
+
+#include "cally-group.h"
+#include "cally-actor-private.h"
+
+static gint       cally_group_get_n_children  (AtkObject *obj);
+static AtkObject* cally_group_ref_child       (AtkObject *obj,
+                                              gint       i);
+static void       cally_group_real_initialize (AtkObject *obj,
+                                              gpointer   data);
+
+G_DEFINE_TYPE (CallyGroup, cally_group, CALLY_TYPE_ACTOR)
+
+static void
+cally_group_class_init (CallyGroupClass *klass)
+{
+/*   GObjectClass   *gobject_class = G_OBJECT_CLASS (klass); */
+  AtkObjectClass *class         = ATK_OBJECT_CLASS (klass);
+
+  class->get_n_children = cally_group_get_n_children;
+  class->ref_child      = cally_group_ref_child;
+  class->initialize     = cally_group_real_initialize;
+}
+
+static void
+cally_group_init (CallyGroup      *group)
+{
+  /* nothing to do yet */
+}
+
+/**
+ * cally_group_new:
+ * @actor: a #ClutterGroup
+ *
+ * Creates a #CallyGroup for @actor
+ *
+ * Return value: the newly created #CallyGroup
+ *
+ * Since: 1.4
+ */
+AtkObject *
+cally_group_new (ClutterActor *actor)
+{
+  GObject   *object     = NULL;
+  AtkObject *accessible = NULL;
+
+  g_return_val_if_fail (CLUTTER_IS_GROUP (actor), NULL);
+
+  object = g_object_new (CALLY_TYPE_GROUP, NULL);
+
+  accessible = ATK_OBJECT (object);
+  atk_object_initialize (accessible, actor);
+
+  return accessible;
+}
+
+static gint
+cally_group_get_n_children (AtkObject *obj)
+{
+  ClutterActor *actor = NULL;
+  gint          count = 0;
+
+  g_return_val_if_fail (CALLY_IS_GROUP (obj), count);
+
+  actor = CALLY_GET_CLUTTER_ACTOR (obj);
+
+  if (actor == NULL) /* defunct */
+    return 0;
+
+  g_return_val_if_fail (CLUTTER_IS_GROUP(actor), count);
+
+  count = clutter_actor_get_n_children (actor);
+
+  return count;
+}
+
+static AtkObject*
+cally_group_ref_child (AtkObject *obj,
+                       gint       i)
+{
+  AtkObject    *accessible = NULL;
+  ClutterActor *actor      = NULL;
+  ClutterActor *child      = NULL;
+
+  g_return_val_if_fail (CALLY_IS_GROUP (obj), NULL);
+  g_return_val_if_fail ((i >= 0), NULL);
+
+  actor = CALLY_GET_CLUTTER_ACTOR (obj);
+
+  g_return_val_if_fail (CLUTTER_IS_GROUP(actor), NULL);
+  child = clutter_actor_get_child_at_index (actor, i);
+
+  if (!child)
+    return NULL;
+
+  accessible = clutter_actor_get_accessible (child);
+
+  if (accessible != NULL)
+    g_object_ref (accessible);
+
+  return accessible;
+}
+
+static void
+cally_group_real_initialize (AtkObject *obj,
+                            gpointer   data)
+{
+  ATK_OBJECT_CLASS (cally_group_parent_class)->initialize (obj, data);
+
+  obj->role = ATK_ROLE_PANEL;
+}
--- a/clutter/clutter/cally/cally-group.h
+++ b/clutter/clutter/cally/cally-group.h
@@ -0,0 +1,87 @@
+/* CALLY - The Clutter Accessibility Implementation Library
+ *
+ * Copyright (C) 2008 Igalia, S.L.
+ *
+ * Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
+ *
+ * Based on GailContainer from GAIL
+ * Copyright 2001, 2002, 2003 Sun Microsystems 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 __CALLY_GROUP_H__
+#define __CALLY_GROUP_H__
+
+#if !defined(__CALLY_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <cally/cally.h> can be included directly."
+#endif
+
+#include <cally/cally-actor.h>
+#include <clutter/clutter.h>
+
+G_BEGIN_DECLS
+
+#define CALLY_TYPE_GROUP                         (cally_group_get_type ())
+#define CALLY_GROUP(obj)                         (G_TYPE_CHECK_INSTANCE_CAST ((obj), CALLY_TYPE_GROUP, CallyGroup))
+#define CALLY_GROUP_CLASS(klass)                 (G_TYPE_CHECK_CLASS_CAST ((klass), CALLY_TYPE_GROUP, CallyGroupClass))
+#define CALLY_IS_GROUP(obj)                      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CALLY_TYPE_GROUP))
+#define CALLY_IS_GROUP_CLASS(klass)              (G_TYPE_CHECK_CLASS_TYPE ((klass), CALLY_TYPE_GROUP))
+#define CALLY_GROUP_GET_CLASS(obj)               (G_TYPE_INSTANCE_GET_CLASS ((obj), CALLY_TYPE_GROUP, CallyGroupClass))
+
+typedef struct _CallyGroup        CallyGroup;
+typedef struct _CallyGroupClass   CallyGroupClass;
+typedef struct _CallyGroupPrivate CallyGroupPrivate;
+
+/**
+ * CallyGroup:
+ *
+ * The <structname>CallyGroup</structname> structure contains only
+ * private data and should be accessed using the provided API
+ *
+ * Since: 1.4
+ */
+struct _CallyGroup
+{
+  /*< private >*/
+  CallyActor parent;
+
+  CallyGroupPrivate *priv;
+};
+
+/**
+ * CallyGroupClass:
+ *
+ * The <structname>CallyGroupClass</structname> structure contains only
+ * private data
+ *
+ * Since: 1.4
+ */
+struct _CallyGroupClass
+{
+  /*< private >*/
+  CallyActorClass parent_class;
+
+  /* padding for future expansion */
+  gpointer _padding_dummy[8];
+};
+
+CLUTTER_EXPORT
+GType      cally_group_get_type (void) G_GNUC_CONST;
+CLUTTER_EXPORT
+AtkObject* cally_group_new      (ClutterActor *actor);
+
+G_END_DECLS
+
+#endif /* __CALLY_GROUP_H__ */
--- a/clutter/clutter/cally/cally-rectangle.c
+++ b/clutter/clutter/cally/cally-rectangle.c
@@ -0,0 +1,98 @@
+/* CALLY - The Clutter Accessibility Implementation Library
+ *
+ * Copyright (C) 2009 Igalia, S.L.
+ *
+ * Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
+ *
+ * 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, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:cally-rectangle
+ * @short_description: Implementation of the ATK interfaces for a #ClutterRectangle
+ * @see_also: #ClutterRectangle
+ *
+ * #CallyRectangle implements the required ATK interfaces of #ClutterRectangle
+ *
+ * In particular it sets a proper role for the rectangle.
+ */
+
+#include "clutter-build-config.h"
+
+#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
+
+#include "cally-rectangle.h"
+#include "cally-actor-private.h"
+
+#include "clutter-color.h"
+#include "deprecated/clutter-rectangle.h"
+
+/* AtkObject */
+static void                  cally_rectangle_real_initialize (AtkObject *obj,
+                                                              gpointer   data);
+
+G_DEFINE_TYPE (CallyRectangle, cally_rectangle, CALLY_TYPE_ACTOR)
+
+static void
+cally_rectangle_class_init (CallyRectangleClass *klass)
+{
+/*   GObjectClass   *gobject_class = G_OBJECT_CLASS (klass); */
+  AtkObjectClass *class         = ATK_OBJECT_CLASS (klass);
+
+  class->initialize      = cally_rectangle_real_initialize;
+}
+
+static void
+cally_rectangle_init (CallyRectangle *rectangle)
+{
+  /* nothing to do yet */
+}
+
+/**
+ * cally_rectangle_new:
+ * @actor: a #ClutterActor
+ *
+ * Creates a new #CallyRectangle for the given @actor. @actor must be
+ * a #ClutterRectangle.
+ *
+ * Return value: the newly created #AtkObject
+ *
+ * Since: 1.4
+ */
+AtkObject*
+cally_rectangle_new (ClutterActor *actor)
+{
+  GObject   *object     = NULL;
+  AtkObject *accessible = NULL;
+
+  g_return_val_if_fail (CLUTTER_IS_RECTANGLE (actor), NULL);
+
+  object = g_object_new (CALLY_TYPE_RECTANGLE, NULL);
+
+  accessible = ATK_OBJECT (object);
+  atk_object_initialize (accessible, actor);
+
+  return accessible;
+}
+
+static void
+cally_rectangle_real_initialize (AtkObject *obj,
+                                 gpointer   data)
+{
+  ATK_OBJECT_CLASS (cally_rectangle_parent_class)->initialize (obj, data);
+
+  obj->role = ATK_ROLE_IMAGE;
+}
--- a/clutter/clutter/cally/cally-rectangle.h
+++ b/clutter/clutter/cally/cally-rectangle.h
@@ -0,0 +1,84 @@
+/* CALLY - The Clutter Accessibility Implementation Library
+ *
+ * Copyright (C) 2009 Igalia, S.L.
+ *
+ * Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
+ *
+ * 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 __CALLY_RECTANGLE_H__
+#define __CALLY_RECTANGLE_H__
+
+#if !defined(__CALLY_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <cally/cally.h> can be included directly."
+#endif
+
+#include <cally/cally-actor.h>
+#include <clutter/clutter.h>
+
+G_BEGIN_DECLS
+
+#define CALLY_TYPE_RECTANGLE            (cally_rectangle_get_type ())
+#define CALLY_RECTANGLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CALLY_TYPE_RECTANGLE, CallyRectangle))
+#define CALLY_RECTANGLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), CALLY_TYPE_RECTANGLE, CallyRectangleClass))
+#define CALLY_IS_RECTANGLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CALLY_TYPE_RECTANGLE))
+#define CALLY_IS_RECTANGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CALLY_TYPE_RECTANGLE))
+#define CALLY_RECTANGLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CALLY_TYPE_RECTANGLE, CallyRectangleClass))
+
+typedef struct _CallyRectangle         CallyRectangle;
+typedef struct _CallyRectangleClass    CallyRectangleClass;
+typedef struct _CallyRectanglePrivate  CallyRectanglePrivate;
+
+/**
+ * CallyRectangle:
+ *
+ * The <structname>CallyRectangle</structname> structure contains only private
+ * data and should be accessed using the provided API
+ *
+ * Since: 1.4
+ */
+struct _CallyRectangle
+{
+  /*< private >*/
+  CallyActor parent;
+
+  CallyRectanglePrivate *priv;
+};
+
+/**
+ * CallyRectangleClass:
+ *
+ * The <structname>CallyRectangleClass</structname> structure contains
+ * only private data
+ *
+ * Since: 1.4
+ */
+struct _CallyRectangleClass
+{
+  /*< private >*/
+  CallyActorClass parent_class;
+
+  /* padding for future expansion */
+  gpointer _padding_dummy[8];
+};
+
+CLUTTER_EXPORT
+GType      cally_rectangle_get_type (void) G_GNUC_CONST;
+CLUTTER_EXPORT
+AtkObject* cally_rectangle_new      (ClutterActor *actor);
+
+G_END_DECLS
+
+#endif /* __CALLY_RECTANGLE_H__ */
--- a/clutter/clutter/cally/cally-stage.c
+++ b/clutter/clutter/cally/cally-stage.c
@@ -63,7 +63,7 @@ struct _CallyStagePrivate

 G_DEFINE_TYPE_WITH_CODE (CallyStage,
                         cally_stage,
-                         CALLY_TYPE_ACTOR,
+                         CALLY_TYPE_GROUP,
                         G_ADD_PRIVATE (CallyStage)
                         G_IMPLEMENT_INTERFACE (ATK_TYPE_WINDOW,
                                                cally_stage_window_interface_init));
--- a/clutter/clutter/cally/cally-stage.h
+++ b/clutter/clutter/cally/cally-stage.h
@@ -25,7 +25,7 @@
 #error "Only <cally/cally.h> can be included directly."
 #endif

-#include <cally/cally-actor.h>
+#include <cally/cally-group.h>
 #include <clutter/clutter.h>

 G_BEGIN_DECLS
@@ -52,7 +52,7 @@ typedef struct _CallyStagePrivate CallyStagePrivate;
 struct _CallyStage
 {
  /*< private >*/
-  CallyActor parent;
+  CallyGroup parent;

  CallyStagePrivate *priv;
 };
@@ -68,7 +68,7 @@ struct _CallyStage
 struct _CallyStageClass
 {
  /*< private >*/
-  CallyActorClass parent_class;
+  CallyGroupClass parent_class;

  /* padding for future expansion */
  gpointer _padding_dummy[16];
--- a/clutter/clutter/cally/cally.c
+++ b/clutter/clutter/cally/cally.c
@@ -36,8 +36,10 @@
 #include "cally.h"

 #include "cally-actor.h"
+#include "cally-group.h"
 #include "cally-stage.h"
 #include "cally-text.h"
+#include "cally-rectangle.h"
 #include "cally-clone.h"

 #include "cally-factory.h"
@@ -50,8 +52,10 @@

 /* factories initialization*/
 CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_ACTOR, cally_actor, cally_actor_new)
+CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_GROUP, cally_group, cally_group_new)
 CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_STAGE, cally_stage, cally_stage_new)
 CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_TEXT, cally_text, cally_text_new)
+CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_RECTANGLE, cally_rectangle, cally_rectangle_new)
 CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_CLONE, cally_clone, cally_clone_new)

 /**
@@ -69,8 +73,10 @@ cally_accessibility_init (void)
 {
  /* setting the factories */
  CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_ACTOR, cally_actor);
+  CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_GROUP, cally_group);
  CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_STAGE, cally_stage);
  CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_TEXT, cally_text);
+  CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_RECTANGLE, cally_rectangle);
  CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_CLONE, cally_clone);

  /* Initialize the CallyUtility class */
--- a/clutter/clutter/cally/cally.h
+++ b/clutter/clutter/cally/cally.h
@@ -26,7 +26,9 @@
 #include "cally-actor.h"
 #include "cally-clone.h"
 #include "cally-factory.h"
+#include "cally-group.h"
 #include "cally-main.h"
+#include "cally-rectangle.h"
 #include "cally-root.h"
 #include "cally-stage.h"
 #include "cally-text.h"
--- a/clutter/clutter/clutter-action.h
+++ b/clutter/clutter/clutter-action.h
@@ -33,11 +33,28 @@

 G_BEGIN_DECLS

-#define CLUTTER_TYPE_ACTION (clutter_action_get_type ())
+#define CLUTTER_TYPE_ACTION             (clutter_action_get_type ())
+#define CLUTTER_ACTION(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ACTION, ClutterAction))
+#define CLUTTER_IS_ACTION(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ACTION))
+#define CLUTTER_ACTION_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_ACTION, ClutterActionClass))
+#define CLUTTER_IS_ACTION_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_ACTION))
+#define CLUTTER_ACTION_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_ACTION, ClutterActionClass))

-CLUTTER_EXPORT
-G_DECLARE_DERIVABLE_TYPE (ClutterAction, clutter_action,
-                          CLUTTER, ACTION, ClutterActorMeta);
+typedef struct _ClutterActionClass      ClutterActionClass;
+
+/**
+ * ClutterAction:
+ *
+ * The #ClutterAction structure contains only private data and
+ * should be accessed using the provided API.
+ *
+ * Since: 1.4
+ */
+struct _ClutterAction
+{
+  /*< private >*/
+  ClutterActorMeta parent_instance;
+};

 /**
 * ClutterActionClass:
@@ -61,6 +78,9 @@ struct _ClutterActionClass
  void (* _clutter_action8) (void);
 };

+CLUTTER_EXPORT
+GType clutter_action_get_type (void) G_GNUC_CONST;
+
 /* ClutterActor API */
 CLUTTER_EXPORT
 void           clutter_actor_add_action            (ClutterActor  *self,
--- a/clutter/clutter/clutter-actor-box.c
+++ b/clutter/clutter/clutter-actor-box.c
@@ -615,32 +615,6 @@ clutter_actor_box_scale (ClutterActorBox *box,
  box->y2 *= scale;
 }

-/**
- * clutter_actor_box_is_initialized:
- * @box: a #ClutterActorBox
- *
- * Checks if @box has been initialized, a #ClutterActorBox is uninitialized
- * if it has a size of -1 at an origin of 0, 0.
- *
- * Returns: %TRUE if the box is uninitialized, %FALSE if it isn't
- */
-gboolean
-clutter_actor_box_is_initialized (ClutterActorBox *box)
-{
-  gboolean x1_uninitialized, x2_uninitialized;
-  gboolean y1_uninitialized, y2_uninitialized;
-
-  g_return_val_if_fail (box != NULL, TRUE);
-
-  x1_uninitialized = isinf (box->x1);
-  x2_uninitialized = isinf (box->x2) && signbit (box->x2);
-  y1_uninitialized = isinf (box->y1);
-  y2_uninitialized = isinf (box->y2) && signbit (box->y2);
-
-  return !x1_uninitialized || !x2_uninitialized ||
-         !y1_uninitialized || !y2_uninitialized;
-}
-
 G_DEFINE_BOXED_TYPE_WITH_CODE (ClutterActorBox, clutter_actor_box,
                               clutter_actor_box_copy,
                               clutter_actor_box_free,
--- a/clutter/clutter/clutter-actor-meta.c
+++ b/clutter/clutter/clutter-actor-meta.c
@@ -81,49 +81,24 @@ static void
 on_actor_destroy (ClutterActor     *actor,
                  ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv =
-    clutter_actor_meta_get_instance_private (meta);
-
-  priv->actor = NULL;
+  meta->priv->actor = NULL;
 }

 static void
 clutter_actor_meta_real_set_actor (ClutterActorMeta *meta,
                                   ClutterActor     *actor)
 {
-  ClutterActorMetaPrivate *priv =
-    clutter_actor_meta_get_instance_private (meta);
-
-  g_warn_if_fail (!priv->actor ||
-                  !CLUTTER_ACTOR_IN_PAINT (priv->actor));
-  g_warn_if_fail (!actor || !CLUTTER_ACTOR_IN_PAINT (actor));
-
-  if (priv->actor == actor)
+  if (meta->priv->actor == actor)
    return;

-  g_clear_signal_handler (&priv->destroy_id, priv->actor);
+  g_clear_signal_handler (&meta->priv->destroy_id, meta->priv->actor);

-  priv->actor = actor;
+  meta->priv->actor = actor;

-  if (priv->actor != NULL)
-    priv->destroy_id = g_signal_connect (priv->actor, "destroy",
-                                         G_CALLBACK (on_actor_destroy),
-                                         meta);
-}
-
-static void
-clutter_actor_meta_real_set_enabled (ClutterActorMeta *meta,
-                                     gboolean          is_enabled)
-{
-  ClutterActorMetaPrivate *priv =
-    clutter_actor_meta_get_instance_private (meta);
-
-  g_warn_if_fail (!priv->actor ||
-                  !CLUTTER_ACTOR_IN_PAINT (priv->actor));
-
-  priv->is_enabled = is_enabled;
-
-  g_object_notify_by_pspec (G_OBJECT (meta), obj_props[PROP_ENABLED]);
+  if (meta->priv->actor != NULL)
+    meta->priv->destroy_id = g_signal_connect (meta->priv->actor, "destroy",
+                                               G_CALLBACK (on_actor_destroy),
+                                               meta);
 }

 static void
@@ -156,21 +131,20 @@ clutter_actor_meta_get_property (GObject    *gobject,
                                 GValue     *value,
                                 GParamSpec *pspec)
 {
-  ClutterActorMetaPrivate *priv =
-    clutter_actor_meta_get_instance_private (CLUTTER_ACTOR_META (gobject));
+  ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject);

  switch (prop_id)
    {
    case PROP_ACTOR:
-      g_value_set_object (value, priv->actor);
+      g_value_set_object (value, meta->priv->actor);
      break;

    case PROP_NAME:
-      g_value_set_string (value, priv->name);
+      g_value_set_string (value, meta->priv->name);
      break;

    case PROP_ENABLED:
-      g_value_set_boolean (value, priv->is_enabled);
+      g_value_set_boolean (value, meta->priv->is_enabled);
      break;

    default:
@@ -182,8 +156,7 @@ clutter_actor_meta_get_property (GObject    *gobject,
 static void
 clutter_actor_meta_finalize (GObject *gobject)
 {
-  ClutterActorMetaPrivate *priv =
-    clutter_actor_meta_get_instance_private (CLUTTER_ACTOR_META (gobject));
+  ClutterActorMetaPrivate *priv = CLUTTER_ACTOR_META (gobject)->priv;

  if (priv->actor != NULL)
    g_clear_signal_handler (&priv->destroy_id, priv->actor);
@@ -199,7 +172,6 @@ clutter_actor_meta_class_init (ClutterActorMetaClass *klass)
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  klass->set_actor = clutter_actor_meta_real_set_actor;
-  klass->set_enabled = clutter_actor_meta_real_set_enabled;

  /**
   * ClutterActorMeta:actor:
@@ -254,11 +226,9 @@ clutter_actor_meta_class_init (ClutterActorMetaClass *klass)
 void
 clutter_actor_meta_init (ClutterActorMeta *self)
 {
-  ClutterActorMetaPrivate *priv =
-    clutter_actor_meta_get_instance_private (self);
-
-  priv->is_enabled = TRUE;
-  priv->priority = CLUTTER_ACTOR_META_PRIORITY_DEFAULT;
+  self->priv = clutter_actor_meta_get_instance_private (self);
+  self->priv->is_enabled = TRUE;
+  self->priv->priority = CLUTTER_ACTOR_META_PRIORITY_DEFAULT;
 }

 /**
@@ -276,17 +246,13 @@ void
 clutter_actor_meta_set_name (ClutterActorMeta *meta,
                             const gchar      *name)
 {
-  ClutterActorMetaPrivate *priv;
-
  g_return_if_fail (CLUTTER_IS_ACTOR_META (meta));

-  priv = clutter_actor_meta_get_instance_private (meta);
-
-  if (g_strcmp0 (priv->name, name) == 0)
+  if (g_strcmp0 (meta->priv->name, name) == 0)
    return;

-  g_free (priv->name);
-  priv->name = g_strdup (name);
+  g_free (meta->priv->name);
+  meta->priv->name = g_strdup (name);

  g_object_notify_by_pspec (G_OBJECT (meta), obj_props[PROP_NAME]);
 }
@@ -307,13 +273,9 @@ clutter_actor_meta_set_name (ClutterActorMeta *meta,
 const gchar *
 clutter_actor_meta_get_name (ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_ACTOR_META (meta), NULL);

-  priv = clutter_actor_meta_get_instance_private (meta);
-
-  return priv->name;
+  return meta->priv->name;
 }

 /**
@@ -329,17 +291,16 @@ void
 clutter_actor_meta_set_enabled (ClutterActorMeta *meta,
                                gboolean          is_enabled)
 {
-  ClutterActorMetaPrivate *priv;
-
  g_return_if_fail (CLUTTER_IS_ACTOR_META (meta));

-  priv = clutter_actor_meta_get_instance_private (meta);
  is_enabled = !!is_enabled;

-  if (priv->is_enabled == is_enabled)
+  if (meta->priv->is_enabled == is_enabled)
    return;

-  CLUTTER_ACTOR_META_GET_CLASS (meta)->set_enabled (meta, is_enabled);
+  meta->priv->is_enabled = is_enabled;
+
+  g_object_notify_by_pspec (G_OBJECT (meta), obj_props[PROP_ENABLED]);
 }

 /**
@@ -355,13 +316,9 @@ clutter_actor_meta_set_enabled (ClutterActorMeta *meta,
 gboolean
 clutter_actor_meta_get_enabled (ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_ACTOR_META (meta), FALSE);

-  priv = clutter_actor_meta_get_instance_private (meta);
-
-  return priv->is_enabled;
+  return meta->priv->is_enabled;
 }

 /*
@@ -397,54 +354,40 @@ _clutter_actor_meta_set_actor (ClutterActorMeta *meta,
 ClutterActor *
 clutter_actor_meta_get_actor (ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_ACTOR_META (meta), NULL);

-  priv = clutter_actor_meta_get_instance_private (meta);
-
-  return priv->actor;
+  return meta->priv->actor;
 }

 void
 _clutter_actor_meta_set_priority (ClutterActorMeta *meta,
                                  gint priority)
 {
-  ClutterActorMetaPrivate *priv;
-
  g_return_if_fail (CLUTTER_IS_ACTOR_META (meta));

-  priv = clutter_actor_meta_get_instance_private (meta);
-
  /* This property shouldn't be modified after the actor meta is in
     use because ClutterMetaGroup doesn't resort the list when it
     changes. If we made the priority public then we could either make
     the priority a construct-only property or listen for
     notifications on the property from the ClutterMetaGroup and
     resort. */
-  g_return_if_fail (priv->actor == NULL);
+  g_return_if_fail (meta->priv->actor == NULL);

-  priv->priority = priority;
+  meta->priv->priority = priority;
 }

 gint
 _clutter_actor_meta_get_priority (ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_ACTOR_META (meta), 0);

-  priv = clutter_actor_meta_get_instance_private (meta);
-
-  return priv->priority;
+  return meta->priv->priority;
 }

 gboolean
 _clutter_actor_meta_is_internal (ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv =
-    clutter_actor_meta_get_instance_private (meta);
-  gint priority = priv->priority;
+  gint priority = meta->priv->priority;

  return (priority <= CLUTTER_ACTOR_META_PRIORITY_INTERNAL_LOW ||
          priority >= CLUTTER_ACTOR_META_PRIORITY_INTERNAL_HIGH);
@@ -491,21 +434,19 @@ void
 _clutter_meta_group_add_meta (ClutterMetaGroup *group,
                              ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv =
-    clutter_actor_meta_get_instance_private (meta);
  GList *prev = NULL, *l;

-  if (priv->actor != NULL)
+  if (meta->priv->actor != NULL)
    {
      g_warning ("The meta of type '%s' with name '%s' is "
                 "already attached to actor '%s'",
                 G_OBJECT_TYPE_NAME (meta),
-                 priv->name != NULL
-                   ? priv->name
+                 meta->priv->name != NULL
+                   ? meta->priv->name
                   : "<unknown>",
-                 clutter_actor_get_name (priv->actor) != NULL
-                   ? clutter_actor_get_name (priv->actor)
-                   : G_OBJECT_TYPE_NAME (priv->actor));
+                 clutter_actor_get_name (meta->priv->actor) != NULL
+                   ? clutter_actor_get_name (meta->priv->actor)
+                   : G_OBJECT_TYPE_NAME (meta->priv->actor));
      return;
    }

@@ -541,16 +482,13 @@ void
 _clutter_meta_group_remove_meta (ClutterMetaGroup *group,
                                 ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv =
-    clutter_actor_meta_get_instance_private (meta);
-
-  if (priv->actor != group->actor)
+  if (meta->priv->actor != group->actor)
    {
      g_warning ("The meta of type '%s' with name '%s' is not "
                 "attached to the actor '%s'",
                 G_OBJECT_TYPE_NAME (meta),
-                 priv->name != NULL
-                   ? priv->name
+                 meta->priv->name != NULL
+                   ? meta->priv->name
                   : "<unknown>",
                 clutter_actor_get_name (group->actor) != NULL
                   ? clutter_actor_get_name (group->actor)
@@ -693,10 +631,8 @@ _clutter_meta_group_get_meta (ClutterMetaGroup *group,
  for (l = group->meta; l != NULL; l = l->next)
    {
      ClutterActorMeta *meta = l->data;
-      ClutterActorMetaPrivate *priv =
-        clutter_actor_meta_get_instance_private (meta);

-      if (g_strcmp0 (priv->name, name) == 0)
+      if (g_strcmp0 (meta->priv->name, name) == 0)
        return meta;
    }

@@ -716,8 +652,6 @@ _clutter_meta_group_get_meta (ClutterMetaGroup *group,
 const gchar *
 _clutter_actor_meta_get_debug_name (ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv =
-    clutter_actor_meta_get_instance_private (meta);
-
-  return priv->name != NULL ? priv->name : G_OBJECT_TYPE_NAME (meta);
+  return meta->priv->name != NULL ? meta->priv->name
+                                  : G_OBJECT_TYPE_NAME (meta);
 }
--- a/clutter/clutter/clutter-actor-meta.h
+++ b/clutter/clutter/clutter-actor-meta.h
@@ -33,13 +33,31 @@

 G_BEGIN_DECLS

-#define CLUTTER_TYPE_ACTOR_META (clutter_actor_meta_get_type ())
+#define CLUTTER_TYPE_ACTOR_META                 (clutter_actor_meta_get_type ())
+#define CLUTTER_ACTOR_META(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ACTOR_META, ClutterActorMeta))
+#define CLUTTER_IS_ACTOR_META(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ACTOR_META))
+#define CLUTTER_ACTOR_META_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_ACTOR_META, ClutterActorMetaClass))
+#define CLUTTER_IS_ACTOR_META_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_ACTOR_META))
+#define CLUTTER_ACTOR_META_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_ACTOR_META, ClutterActorMetaClass))

-CLUTTER_EXPORT
-G_DECLARE_DERIVABLE_TYPE (ClutterActorMeta, clutter_actor_meta,
-                          CLUTTER, ACTOR_META, GInitiallyUnowned);
+typedef struct _ClutterActorMetaPrivate         ClutterActorMetaPrivate;
+typedef struct _ClutterActorMetaClass           ClutterActorMetaClass;

-typedef struct _ClutterActorMetaPrivate ClutterActorMetaPrivate;
+/**
+ * ClutterActorMeta:
+ *
+ * The #ClutterActorMeta structure contains only
+ * private data and should be accessed using the provided API
+ *
+ * Since: 1.4
+ */
+struct _ClutterActorMeta
+{
+  /*< private >*/
+  GInitiallyUnowned parent_instance;
+
+  ClutterActorMetaPrivate *priv;
+};

 /**
 * ClutterActorMetaClass:
@@ -69,9 +87,6 @@ struct _ClutterActorMetaClass
  void (* set_actor) (ClutterActorMeta *meta,
                      ClutterActor     *actor);

-  void (* set_enabled) (ClutterActorMeta *meta,
-                        gboolean          is_enabled);
-
  /*< private >*/
  void (* _clutter_meta1) (void);
  void (* _clutter_meta2) (void);
@@ -79,8 +94,12 @@ struct _ClutterActorMetaClass
  void (* _clutter_meta4) (void);
  void (* _clutter_meta5) (void);
  void (* _clutter_meta6) (void);
+  void (* _clutter_meta7) (void);
 };

+CLUTTER_EXPORT
+GType clutter_actor_meta_get_type (void) G_GNUC_CONST;
+
 CLUTTER_EXPORT
 void            clutter_actor_meta_set_name     (ClutterActorMeta *meta,
                                                 const gchar      *name);
--- a/clutter/clutter/clutter-actor-private.h
+++ b/clutter/clutter/clutter-actor-private.h
@@ -110,12 +110,35 @@ typedef ClutterActorTraverseVisitFlags (*ClutterTraverseCallback) (ClutterActor
 typedef gboolean (*ClutterForeachCallback) (ClutterActor *actor,
                                            gpointer      user_data);

+typedef struct _AnchorCoord             AnchorCoord;
 typedef struct _SizeRequest             SizeRequest;

 typedef struct _ClutterLayoutInfo       ClutterLayoutInfo;
 typedef struct _ClutterTransformInfo    ClutterTransformInfo;
 typedef struct _ClutterAnimationInfo    ClutterAnimationInfo;

+/* Internal helper struct to represent a point that can be stored in
+   either direct pixel coordinates or as a fraction of the actor's
+   size. It is used for the anchor point, scale center and rotation
+   centers. */
+struct _AnchorCoord
+{
+  gboolean is_fractional;
+
+  union
+  {
+    /* Used when is_fractional == TRUE */
+    struct
+    {
+      gdouble x;
+      gdouble y;
+    } fraction;
+
+    /* Use when is_fractional == FALSE */
+    graphene_point3d_t units;
+  } v;
+};
+
 struct _SizeRequest
 {
  guint  age;
@@ -160,15 +183,24 @@ ClutterLayoutInfo *             _clutter_actor_peek_layout_info

 struct _ClutterTransformInfo
 {
-  /* rotation */
+  /* rotation (angle and center) */
  gdouble rx_angle;
+  AnchorCoord rx_center;
+
  gdouble ry_angle;
+  AnchorCoord ry_center;
+
  gdouble rz_angle;
+  AnchorCoord rz_center;

  /* scaling */
  gdouble scale_x;
  gdouble scale_y;
  gdouble scale_z;
+  AnchorCoord scale_center;
+
+  /* anchor point */
+  AnchorCoord anchor;

  /* translation */
  graphene_point3d_t translation;
@@ -281,18 +313,14 @@ void                            _clutter_actor_detach_clone
 void                            _clutter_actor_queue_redraw_on_clones                   (ClutterActor *actor);
 void                            _clutter_actor_queue_relayout_on_clones                 (ClutterActor *actor);
 void                            _clutter_actor_queue_only_relayout                      (ClutterActor *actor);
-void                            clutter_actor_clear_stage_views_recursive               (ClutterActor *actor);
+void                            _clutter_actor_queue_update_resource_scale_recursive    (ClutterActor *actor);

-float                           clutter_actor_get_real_resource_scale                   (ClutterActor *actor);
+gboolean                        _clutter_actor_get_real_resource_scale                  (ClutterActor *actor,
+                                                                                         float        *resource_scale);

 ClutterPaintNode *              clutter_actor_create_texture_paint_node                 (ClutterActor *self,
                                                                                         CoglTexture  *texture);

-void clutter_actor_update_stage_views (ClutterActor *self,
-                                       int           phase);
-
-void clutter_actor_queue_immediate_relayout (ClutterActor *self);
-
 G_END_DECLS

 #endif /* __CLUTTER_ACTOR_PRIVATE_H__ */
--- a/clutter/clutter/clutter-actor.c
+++ b/clutter/clutter/clutter-actor.c
--- a/clutter/clutter/clutter-actor.h
+++ b/clutter/clutter/clutter-actor.h
@@ -142,6 +142,11 @@ struct _ClutterActor
 * ClutterActorClass:
 * @show: signal class handler for #ClutterActor::show; it must chain
 *   up to the parent's implementation
+ * @show_all: virtual function for containers and composite actors, to
+ *   determine which children should be shown when calling
+ *   clutter_actor_show_all() on the actor. Defaults to calling
+ *   clutter_actor_show(). This virtual function is deprecated and it
+ *   should not be overridden.
 * @hide: signal class handler for #ClutterActor::hide; it must chain
 *   up to the parent's implementation
 * @hide_all: virtual function for containers and composite actors, to
@@ -170,18 +175,12 @@ struct _ClutterActor
 * @get_preferred_height: virtual function, used when querying the minimum
 *   and natural heights of an actor for a given width; it is used by
 *   clutter_actor_get_preferred_height()
- * @allocate: virtual function, used when setting the coordinates of an
- *   actor; it is used by clutter_actor_allocate(); when overriding this
- *   function without chaining up, clutter_actor_set_allocation() must be
- *   called and children must be allocated by the implementation, when
- *   chaining up though, those things will be done by the parent's
- *   implementation.
+ * @allocate: virtual function, used when settings the coordinates of an
+ *   actor; it is used by clutter_actor_allocate(); it must chain up to
+ *   the parent's implementation, or call clutter_actor_set_allocation()
 * @apply_transform: virtual function, used when applying the transformations
 *   to an actor before painting it or when transforming coordinates or
- *   the allocation; if the transformation calculated by this function may
- *   have changed, the cached transformation must be invalidated by calling
- *   clutter_actor_invalidate_transform(); it must chain up to the parent's
- *   implementation
+ *   the allocation; it must chain up to the parent's implementation
 * @parent_set: signal class handler for the #ClutterActor::parent-set
 * @destroy: signal class handler for #ClutterActor::destroy. It must
 *   chain up to the parent's implementation
@@ -224,6 +223,7 @@ struct _ClutterActorClass

  /*< public >*/
  void (* show)                 (ClutterActor          *self);
+  void (* show_all)             (ClutterActor          *self);
  void (* hide)                 (ClutterActor          *self);
  void (* hide_all)             (ClutterActor          *self);
  void (* realize)              (ClutterActor          *self);
@@ -253,7 +253,8 @@ struct _ClutterActorClass
                                 gfloat                 *min_height_p,
                                 gfloat                 *natural_height_p);
  void (* allocate)             (ClutterActor           *self,
-                                 const ClutterActorBox  *box);
+                                 const ClutterActorBox  *box,
+                                 ClutterAllocationFlags  flags);

  /* transformations */
  void (* apply_transform)      (ClutterActor           *actor,
@@ -299,9 +300,6 @@ struct _ClutterActorClass
  gboolean (* touch_event)          (ClutterActor         *self,
                                     ClutterTouchEvent    *event);
  gboolean (* has_accessible)       (ClutterActor         *self);
-  void     (* resource_scale_changed) (ClutterActor *self);
-  float    (* calculate_resource_scale) (ClutterActor *self,
-                                         int           phase);

  /*< private >*/
  /* padding for future expansion */
@@ -417,31 +415,38 @@ void                            clutter_actor_get_preferred_size
                                                                                 gfloat                      *natural_height_p);
 CLUTTER_EXPORT
 void                            clutter_actor_allocate                          (ClutterActor                *self,
-                                                                                 const ClutterActorBox       *box);
+                                                                                 const ClutterActorBox       *box,
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_EXPORT
 void                            clutter_actor_allocate_preferred_size           (ClutterActor                *self,
-                                                                                 float                        x,
-                                                                                 float                        y);
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_EXPORT
 void                            clutter_actor_allocate_available_size           (ClutterActor                *self,
                                                                                 gfloat                       x,
                                                                                 gfloat                       y,
                                                                                 gfloat                       available_width,
-                                                                                 gfloat                       available_height);
+                                                                                 gfloat                       available_height,
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_EXPORT
 void                            clutter_actor_allocate_align_fill               (ClutterActor                *self,
                                                                                 const ClutterActorBox       *box,
                                                                                 gdouble                      x_align,
                                                                                 gdouble                      y_align,
                                                                                 gboolean                     x_fill,
-                                                                                 gboolean                     y_fill);
+                                                                                 gboolean                     y_fill,
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_EXPORT
 void                            clutter_actor_set_allocation                    (ClutterActor                *self,
-                                                                                 const ClutterActorBox       *box);
+                                                                                 const ClutterActorBox       *box,
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_EXPORT
 void                            clutter_actor_get_allocation_box                (ClutterActor                *self,
                                                                                 ClutterActorBox             *box);
 CLUTTER_EXPORT
+void                            clutter_actor_get_allocation_vertices           (ClutterActor                *self,
+                                                                                 ClutterActor                *ancestor,
+                                                                                 graphene_point3d_t          *verts);
+CLUTTER_EXPORT
 gboolean                        clutter_actor_has_allocation                    (ClutterActor                *self);
 CLUTTER_EXPORT
 void                            clutter_actor_set_size                          (ClutterActor                *self,
@@ -456,10 +461,6 @@ void                            clutter_actor_set_position
                                                                                 gfloat                       x,
                                                                                 gfloat                       y);
 CLUTTER_EXPORT
-gboolean clutter_actor_get_fixed_position (ClutterActor *self,
-                                           float        *x,
-                                           float        *y);
-CLUTTER_EXPORT
 void                            clutter_actor_get_position                      (ClutterActor                *self,
                                                                                 gfloat                      *x,
                                                                                 gfloat                      *y);
@@ -599,7 +600,8 @@ gboolean                        clutter_actor_get_paint_box
                                                                                 ClutterActorBox            *box);

 CLUTTER_EXPORT
-float                           clutter_actor_get_resource_scale                (ClutterActor *self);
+gboolean                        clutter_actor_get_resource_scale                (ClutterActor *self,
+                                                                                 gfloat       *resource_scale);

 CLUTTER_EXPORT
 gboolean                        clutter_actor_has_overlaps                      (ClutterActor               *self);
@@ -813,11 +815,6 @@ void                            clutter_actor_set_child_transform
 CLUTTER_EXPORT
 void                            clutter_actor_get_child_transform               (ClutterActor               *self,
                                                                                 ClutterMatrix              *transform);
-
-CLUTTER_EXPORT
-void                            clutter_actor_get_transformed_extents          (ClutterActor               *self,
-                                                                                graphene_rect_t            *rect);
-
 CLUTTER_EXPORT
 void                            clutter_actor_get_transformed_position          (ClutterActor               *self,
                                                                                 gfloat                     *x,
@@ -887,11 +884,6 @@ void                            clutter_actor_set_opacity_override
 CLUTTER_EXPORT
 gint                            clutter_actor_get_opacity_override              (ClutterActor               *self);

-CLUTTER_EXPORT
-void                            clutter_actor_inhibit_culling                   (ClutterActor               *actor);
-CLUTTER_EXPORT
-void                            clutter_actor_uninhibit_culling                 (ClutterActor               *actor);
-
 /**
 * ClutterActorCreateChildFunc:
 * @item: (type GObject): the item in the model
@@ -929,12 +921,6 @@ void clutter_actor_pick_box (ClutterActor          *self,
                             ClutterPickContext    *pick_context,
                             const ClutterActorBox *box);

-CLUTTER_EXPORT
-GList * clutter_actor_peek_stage_views (ClutterActor *self);
-
-CLUTTER_EXPORT
-void clutter_actor_invalidate_transform (ClutterActor *self);
-
 G_END_DECLS

 #endif /* __CLUTTER_ACTOR_H__ */
--- a/clutter/clutter/clutter-align-constraint.c
+++ b/clutter/clutter/clutter-align-constraint.c
@@ -58,7 +58,6 @@ struct _ClutterAlignConstraint
  ClutterActor *actor;
  ClutterActor *source;
  ClutterAlignAxis align_axis;
-  graphene_point_t pivot;
  gfloat factor;
 };

@@ -73,7 +72,6 @@ enum

  PROP_SOURCE,
  PROP_ALIGN_AXIS,
-  PROP_PIVOT_POINT,
  PROP_FACTOR,

  PROP_LAST
@@ -86,11 +84,13 @@ G_DEFINE_TYPE (ClutterAlignConstraint,
               CLUTTER_TYPE_CONSTRAINT);

 static void
-source_queue_relayout (ClutterActor           *actor,
-                       ClutterAlignConstraint *align)
+source_position_changed (ClutterActor           *actor,
+                         const ClutterActorBox  *allocation,
+                         ClutterAllocationFlags  flags,
+                         ClutterAlignConstraint *align)
 {
  if (align->actor != NULL)
-    _clutter_actor_queue_only_relayout (align->actor);
+    clutter_actor_queue_relayout (align->actor);
 }

 static void
@@ -135,41 +135,35 @@ clutter_align_constraint_update_allocation (ClutterConstraint *constraint,
  ClutterAlignConstraint *align = CLUTTER_ALIGN_CONSTRAINT (constraint);
  gfloat source_width, source_height;
  gfloat actor_width, actor_height;
-  gfloat offset_x_start, offset_y_start;
-  gfloat pivot_x, pivot_y;
+  gfloat source_x, source_y;

  if (align->source == NULL)
    return;

  clutter_actor_box_get_size (allocation, &actor_width, &actor_height);

+  clutter_actor_get_position (align->source, &source_x, &source_y);
  clutter_actor_get_size (align->source, &source_width, &source_height);

-  pivot_x = align->pivot.x == -1.f
-    ? align->factor
-    : align->pivot.x;
-  pivot_y = align->pivot.y == -1.f
-    ? align->factor
-    : align->pivot.y;
-
-  offset_x_start = pivot_x * -actor_width;
-  offset_y_start = pivot_y * -actor_height;
-
  switch (align->align_axis)
    {
    case CLUTTER_ALIGN_X_AXIS:
-      allocation->x1 += offset_x_start + (source_width * align->factor);
+      allocation->x1 = ((source_width - actor_width) * align->factor)
+                     + source_x;
      allocation->x2 = allocation->x1 + actor_width;
      break;

    case CLUTTER_ALIGN_Y_AXIS:
-      allocation->y1 += offset_y_start + (source_height * align->factor);
+      allocation->y1 = ((source_height - actor_height) * align->factor)
+                     + source_y;
      allocation->y2 = allocation->y1 + actor_height;
      break;

    case CLUTTER_ALIGN_BOTH:
-      allocation->x1 += offset_x_start + (source_width * align->factor);
-      allocation->y1 += offset_y_start + (source_height * align->factor);
+      allocation->x1 = ((source_width - actor_width) * align->factor)
+                     + source_x;
+      allocation->y1 = ((source_height - actor_height) * align->factor)
+                     + source_y;
      allocation->x2 = allocation->x1 + actor_width;
      allocation->y2 = allocation->y1 + actor_height;
      break;
@@ -193,7 +187,7 @@ clutter_align_constraint_dispose (GObject *gobject)
                                            G_CALLBACK (source_destroyed),
                                            align);
      g_signal_handlers_disconnect_by_func (align->source,
-                                            G_CALLBACK (source_queue_relayout),
+                                            G_CALLBACK (source_position_changed),
                                            align);
      align->source = NULL;
    }
@@ -219,10 +213,6 @@ clutter_align_constraint_set_property (GObject      *gobject,
      clutter_align_constraint_set_align_axis (align, g_value_get_enum (value));
      break;

-    case PROP_PIVOT_POINT:
-      clutter_align_constraint_set_pivot_point (align, g_value_get_boxed (value));
-      break;
-
    case PROP_FACTOR:
      clutter_align_constraint_set_factor (align, g_value_get_float (value));
      break;
@@ -251,16 +241,6 @@ clutter_align_constraint_get_property (GObject    *gobject,
      g_value_set_enum (value, align->align_axis);
      break;

-    case PROP_PIVOT_POINT:
-      {
-        graphene_point_t point;
-
-        clutter_align_constraint_get_pivot_point (align, &point);
-
-        g_value_set_boxed (value, &point);
-      }
-      break;
-
    case PROP_FACTOR:
      g_value_set_float (value, align->factor);
      break;
@@ -314,30 +294,6 @@ clutter_align_constraint_class_init (ClutterAlignConstraintClass *klass)
                       CLUTTER_ALIGN_X_AXIS,
                       CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT);

-  /**
-   * ClutterAlignConstraint:pivot-point:
-   *
-   * The pivot point used by the constraint. The pivot point is the
-   * point in the constraint actor around which the aligning is applied,
-   * with (0, 0) being the top left corner of the actor and (1, 1) the
-   * bottom right corner of the actor.
-   *
-   * For example, setting the pivot point to (0.5, 0.5) and using a factor
-   * of 1 for both axes will align the actors horizontal and vertical
-   * center point with the bottom right corner of the source actor.
-   *
-   * By default, the pivot point is set to (-1, -1), which means it's not
-   * used and the constrained actor will be aligned to always stay inside
-   * the source actor.
-   */
-  obj_props[PROP_PIVOT_POINT] =
-    g_param_spec_boxed ("pivot-point",
-                       P_("Pivot point"),
-                       P_("The pivot point"),
-                       GRAPHENE_TYPE_POINT,
-                       G_PARAM_READWRITE |
-                       G_PARAM_STATIC_STRINGS);
-
  /**
   * ClutterAlignConstraint:factor:
   *
@@ -370,8 +326,6 @@ clutter_align_constraint_init (ClutterAlignConstraint *self)
  self->actor = NULL;
  self->source = NULL;
  self->align_axis = CLUTTER_ALIGN_X_AXIS;
-  self->pivot.x = -1.f;
-  self->pivot.y = -1.f;
  self->factor = 0.0f;
 }

@@ -449,15 +403,15 @@ clutter_align_constraint_set_source (ClutterAlignConstraint *align,
                                            G_CALLBACK (source_destroyed),
                                            align);
      g_signal_handlers_disconnect_by_func (old_source,
-                                            G_CALLBACK (source_queue_relayout),
+                                            G_CALLBACK (source_position_changed),
                                            align);
    }

  align->source = source;
  if (align->source != NULL)
    {
-      g_signal_connect (align->source, "queue-relayout",
-                        G_CALLBACK (source_queue_relayout),
+      g_signal_connect (align->source, "allocation-changed",
+                        G_CALLBACK (source_position_changed),
                        align);
      g_signal_connect (align->source, "destroy",
                        G_CALLBACK (source_destroyed),
@@ -534,60 +488,6 @@ clutter_align_constraint_get_align_axis (ClutterAlignConstraint *align)
  return align->align_axis;
 }

-/**
- * clutter_align_constraint_set_pivot_point:
- * @align: a #ClutterAlignConstraint
- * @pivot_point: A #GraphenePoint
- *
- * Sets the pivot point used by the constraint, the pivot point is the
- * point in the constraint actor around which the aligning is applied,
- * with (0, 0) being the top left corner of the actor and (1, 1) the
- * bottom right corner of the actor.
- *
- * If -1 is used, the pivot point is unset and the constrained actor
- * will be aligned to always stay inside the source actor.
- */
-void
-clutter_align_constraint_set_pivot_point (ClutterAlignConstraint *align,
-                                          const graphene_point_t *pivot_point)
-{
-  g_return_if_fail (CLUTTER_IS_ALIGN_CONSTRAINT (align));
-  g_return_if_fail (pivot_point != NULL);
-  g_return_if_fail (pivot_point->x == -1.f ||
-                    (pivot_point->x >= 0.f && pivot_point->x <= 1.f));
-  g_return_if_fail (pivot_point->y == -1.f ||
-                    (pivot_point->y >= 0.f && pivot_point->y <= 1.f));
-
-  if (graphene_point_equal (&align->pivot, pivot_point))
-    return;
-
-  align->pivot = *pivot_point;
-
-  if (align->actor != NULL)
-    clutter_actor_queue_relayout (align->actor);
-
-  g_object_notify_by_pspec (G_OBJECT (align), obj_props[PROP_PIVOT_POINT]);
-}
-
-/**
- * clutter_align_constraint_get_pivot_point
- * @align: a #ClutterAlignConstraint
- * @pivot_point: (out caller-allocates): return location for a #GraphenePoint
- *
- * Gets the pivot point used by the constraint set with
- * clutter_align_constraint_set_pivot_point(). If no custom pivot
- * point is set, -1 is set.
- */
-void
-clutter_align_constraint_get_pivot_point (ClutterAlignConstraint *align,
-                                          graphene_point_t       *pivot_point)
-{
-  g_return_if_fail (CLUTTER_IS_ALIGN_CONSTRAINT (align));
-  g_return_if_fail (pivot_point != NULL);
-
-  *pivot_point = align->pivot;
-}
-
 /**
 * clutter_align_constraint_set_factor:
 * @align: a #ClutterAlignConstraint
--- a/clutter/clutter/clutter-align-constraint.h
+++ b/clutter/clutter/clutter-align-constraint.h
@@ -67,12 +67,6 @@ void               clutter_align_constraint_set_align_axis (ClutterAlignConstrai
 CLUTTER_EXPORT
 ClutterAlignAxis   clutter_align_constraint_get_align_axis (ClutterAlignConstraint *align);
 CLUTTER_EXPORT
-void               clutter_align_constraint_set_pivot_point (ClutterAlignConstraint *align,
-                                                             const graphene_point_t *pivot_point);
-CLUTTER_EXPORT
-void               clutter_align_constraint_get_pivot_point (ClutterAlignConstraint *align,
-                                                             graphene_point_t       *pivot_point);
-CLUTTER_EXPORT
 void               clutter_align_constraint_set_factor     (ClutterAlignConstraint *align,
                                                            gfloat                  factor);
 CLUTTER_EXPORT
--- a/clutter/clutter/clutter-animatable.c
+++ b/clutter/clutter/clutter-animatable.c
@@ -27,23 +27,35 @@
 * @short_description: Interface for animatable classes
 *
 * #ClutterAnimatable is an interface that allows a #GObject class
- * to control how an actor will animate a property.
+ * to control how a #ClutterAnimation will animate a property.
 *
 * Each #ClutterAnimatable should implement the
 * #ClutterAnimatableInterface.interpolate_property() virtual function of the
 * interface to compute the animation state between two values of an interval
 * depending on a progress factor, expressed as a floating point value.
 *
+ * If a #ClutterAnimatable is animated by a #ClutterAnimation
+ * instance, the #ClutterAnimation will call
+ * clutter_animatable_interpolate_property() passing the name of the
+ * currently animated property; the values interval; and the progress factor.
+ * The #ClutterAnimatable implementation should return the computed value for
+ * the animated
+ * property.
+ *
 * #ClutterAnimatable is available since Clutter 1.0
 */

 #include "clutter-build-config.h"

+#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
+
 #include "clutter-animatable.h"
 #include "clutter-interval.h"
 #include "clutter-debug.h"
 #include "clutter-private.h"

+#include "deprecated/clutter-animation.h"
+
 G_DEFINE_INTERFACE (ClutterAnimatable, clutter_animatable, G_TYPE_OBJECT);

 static void
@@ -194,25 +206,3 @@ clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
  else
    return clutter_interval_compute_value (interval, progress, value);
 }
-
-/**
- * clutter_animatable_get_actor:
- * @animatable: a #ClutterAnimatable
- *
- * Get animated actor.
- *
- * Return value: (transfer none): a #ClutterActor
- */
-ClutterActor *
-clutter_animatable_get_actor (ClutterAnimatable *animatable)
-{
-  ClutterAnimatableInterface *iface;
-
-  g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), NULL);
-
-  iface = CLUTTER_ANIMATABLE_GET_IFACE (animatable);
-
-  g_return_val_if_fail (iface->get_actor, NULL);
-
-  return iface->get_actor (animatable);
-}
--- a/clutter/clutter/clutter-animatable.h
+++ b/clutter/clutter/clutter-animatable.h
@@ -42,6 +42,8 @@ G_DECLARE_INTERFACE (ClutterAnimatable, clutter_animatable,

 /**
 * ClutterAnimatableInterface:
+ * @animate_property: virtual function for custom interpolation of a
+ *   property. This virtual function is deprecated
 * @find_property: virtual function for retrieving the #GParamSpec of
 *   an animatable property
 * @get_initial_state: virtual function for retrieving the initial
@@ -50,7 +52,9 @@ G_DECLARE_INTERFACE (ClutterAnimatable, clutter_animatable,
 *   animatable property
 * @interpolate_value: virtual function for interpolating the progress
 *   of a property
- * @get_actor: virtual function for getting associated actor
+ *
+ * Base interface for #GObject<!-- -->s that can be animated by a
+ * a #ClutterAnimation.
 *
 * Since: 1.0
 */
@@ -60,6 +64,13 @@ struct _ClutterAnimatableInterface
  GTypeInterface parent_iface;

  /*< public >*/
+  gboolean    (* animate_property)  (ClutterAnimatable *animatable,
+                                     ClutterAnimation  *animation,
+                                     const gchar       *property_name,
+                                     const GValue      *initial_value,
+                                     const GValue      *final_value,
+                                     gdouble            progress,
+                                     GValue            *value);
  GParamSpec *(* find_property)     (ClutterAnimatable *animatable,
                                     const gchar       *property_name);
  void        (* get_initial_state) (ClutterAnimatable *animatable,
@@ -73,7 +84,6 @@ struct _ClutterAnimatableInterface
                                     ClutterInterval   *interval,
                                     gdouble            progress,
                                     GValue            *value);
-  ClutterActor * (* get_actor)      (ClutterAnimatable *animatable);
 };

 CLUTTER_EXPORT
@@ -94,9 +104,6 @@ gboolean    clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
                                                  gdouble            progress,
                                                  GValue            *value);

-CLUTTER_EXPORT
-ClutterActor * clutter_animatable_get_actor      (ClutterAnimatable *animatable);
-
 G_END_DECLS

 #endif /* __CLUTTER_ANIMATABLE_H__ */
--- a/clutter/clutter/clutter-autocleanups.h
+++ b/clutter/clutter/clutter-autocleanups.h
@@ -30,7 +30,9 @@

 #ifndef __GI_SCANNER__

+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterActor, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterActorMeta, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterAlignConstraint, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBackend, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBindConstraint, g_object_unref)
@@ -41,15 +43,19 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBoxLayout, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBrightnessContrastEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterCanvas, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterChildMeta, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterClickAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterClone, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterColorizeEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterConstraint, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterContainer, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDeformEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDesaturateEffect, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDragAction, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDropAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterFixedLayout, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterFlowLayout, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterGestureAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterGridLayout, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterImage, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterInputDevice, g_object_unref)
--- a/clutter/clutter/clutter-backend-private.h
+++ b/clutter/clutter/clutter-backend-private.h
@@ -53,8 +53,6 @@ struct _ClutterBackend
  gfloat units_per_em;
  gint32 units_serial;

-  float fallback_resource_scale;
-
  ClutterStageWindow *stage_window;

  ClutterInputMethod *input_method;
@@ -93,8 +91,6 @@ struct _ClutterBackendClass

  ClutterSeat *         (* get_default_seat)   (ClutterBackend *backend);

-  gboolean              (* is_display_server)  (ClutterBackend *backend);
-
  /* signals */
  void (* resolution_changed) (ClutterBackend *backend);
  void (* font_changed)       (ClutterBackend *backend);
@@ -138,14 +134,6 @@ void                    clutter_set_allowed_drivers                     (const c
 CLUTTER_EXPORT
 ClutterStageWindow *    clutter_backend_get_stage_window                (ClutterBackend         *backend);

-CLUTTER_EXPORT
-void clutter_backend_set_fallback_resource_scale (ClutterBackend *backend,
-                                                  float           fallback_resource_scale);
-
-float clutter_backend_get_fallback_resource_scale (ClutterBackend *backend);
-
-gboolean clutter_backend_is_display_server (ClutterBackend *backend);
-
 G_END_DECLS

 #endif /* __CLUTTER_BACKEND_PRIVATE_H__ */
--- a/clutter/clutter/clutter-backend.c
+++ b/clutter/clutter/clutter-backend.c
@@ -58,6 +58,13 @@

 #include <cogl/cogl.h>

+#ifdef CLUTTER_INPUT_X11
+#include "x11/clutter-backend-x11.h"
+#endif
+#ifdef CLUTTER_WINDOWING_EGL
+#include "egl/clutter-backend-eglnative.h"
+#endif
+
 #ifdef CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
 #include <cogl/cogl-wayland-server.h>
 #include <wayland-server.h>
@@ -415,6 +422,14 @@ clutter_backend_real_get_features (ClutterBackend *backend)
      flags |= CLUTTER_FEATURE_STAGE_STATIC;
    }

+  if (cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_THROTTLE))
+    {
+      CLUTTER_NOTE (BACKEND, "Cogl supports swap buffers throttling");
+      flags |= CLUTTER_FEATURE_SWAP_THROTTLE;
+    }
+  else
+    CLUTTER_NOTE (BACKEND, "Cogl doesn't support swap buffers throttling");
+
  if (cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_BUFFERS_EVENT))
    {
      CLUTTER_NOTE (BACKEND, "Cogl supports swap buffers complete events");
@@ -424,8 +439,23 @@ clutter_backend_real_get_features (ClutterBackend *backend)
  return flags;
 }

+static const char *allowed_backends;
+
 static ClutterBackend * (* custom_backend_func) (void);

+static const struct {
+  const char *name;
+  ClutterBackend * (* create_backend) (void);
+} available_backends[] = {
+#ifdef CLUTTER_WINDOWING_X11
+  { CLUTTER_WINDOWING_X11, clutter_backend_x11_new },
+#endif
+#ifdef CLUTTER_WINDOWING_EGL
+  { CLUTTER_WINDOWING_EGL, clutter_backend_egl_native_new },
+#endif
+  { NULL, NULL },
+};
+
 void
 clutter_set_custom_backend_func (ClutterBackend *(* func) (void))
 {
@@ -435,13 +465,58 @@ clutter_set_custom_backend_func (ClutterBackend *(* func) (void))
 ClutterBackend *
 _clutter_create_backend (void)
 {
+  const char *backends_list;
  ClutterBackend *retval;
+  gboolean allow_any;
+  char **backends;
+  int i;

-  g_return_val_if_fail (custom_backend_func, NULL);
+  if (custom_backend_func)
+    {
+      retval = custom_backend_func ();

-  retval = custom_backend_func ();
-  if (!retval)
-    g_error ("Failed to create custom backend.");
+      if (!retval)
+        g_error ("Failed to create custom backend.");
+
+      return retval;
+    }
+
+  if (allowed_backends == NULL)
+    allowed_backends = "*";
+
+  allow_any = strstr (allowed_backends, "*") != NULL;
+
+  backends_list = g_getenv ("CLUTTER_BACKEND");
+  if (backends_list == NULL)
+    backends_list = allowed_backends;
+
+  backends = g_strsplit (backends_list, ",", 0);
+
+  retval = NULL;
+
+  for (i = 0; retval == NULL && backends[i] != NULL; i++)
+    {
+      const char *backend = backends[i];
+      gboolean is_any = g_str_equal (backend, "*");
+      int j;
+
+      for (j = 0; available_backends[j].name != NULL; j++)
+        {
+          if ((is_any && allow_any) ||
+              (is_any && strstr (allowed_backends, available_backends[j].name)) ||
+              g_str_equal (backend, available_backends[j].name))
+            {
+              retval = available_backends[j].create_backend ();
+              if (retval != NULL)
+                break;
+            }
+        }
+    }
+
+  g_strfreev (backends);
+
+  if (retval == NULL)
+    g_error ("No default Clutter backend found.");

  return retval;
 }
@@ -526,8 +601,6 @@ clutter_backend_init (ClutterBackend *self)
  self->units_serial = 1;

  self->dummy_onscreen = NULL;
-
-  self->fallback_resource_scale = 1.f;
 }

 void
@@ -958,22 +1031,3 @@ clutter_backend_get_default_seat (ClutterBackend *backend)

  return CLUTTER_BACKEND_GET_CLASS (backend)->get_default_seat (backend);
 }
-
-void
-clutter_backend_set_fallback_resource_scale (ClutterBackend *backend,
-                                             float           fallback_resource_scale)
-{
-  backend->fallback_resource_scale = fallback_resource_scale;
-}
-
-float
-clutter_backend_get_fallback_resource_scale (ClutterBackend *backend)
-{
-  return backend->fallback_resource_scale;
-}
-
-gboolean
-clutter_backend_is_display_server (ClutterBackend *backend)
-{
-  return CLUTTER_BACKEND_GET_CLASS (backend)->is_display_server (backend);
-}
--- a/clutter/clutter/clutter-bin-layout.c
+++ b/clutter/clutter/clutter-bin-layout.c
@@ -406,7 +406,8 @@ get_actor_align_factor (ClutterActorAlign alignment)
 static void
 clutter_bin_layout_allocate (ClutterLayoutManager   *manager,
                             ClutterContainer       *container,
-                             const ClutterActorBox  *allocation)
+                             const ClutterActorBox  *allocation,
+                             ClutterAllocationFlags  flags)
 {
  gfloat allocation_x, allocation_y;
  gfloat available_w, available_h;
@@ -514,7 +515,8 @@ clutter_bin_layout_allocate (ClutterLayoutManager   *manager,

      clutter_actor_allocate_align_fill (child, &child_alloc,
                                         x_align, y_align,
-                                         x_fill, y_fill);
+                                         x_fill, y_fill,
+                                         flags);
    }
 }

--- a/clutter/clutter/clutter-bind-constraint.c
+++ b/clutter/clutter/clutter-bind-constraint.c
@@ -38,14 +38,12 @@
 *
 * |[<!-- language="C" -->
 * // source
- * rect[0] = clutter_actor_new ();
- * clutter_actor_set_background_color (rect[0], &red_color);
+ * rect[0] = clutter_rectangle_new_with_color (&red_color);
 * clutter_actor_set_position (rect[0], x_pos, y_pos);
 * clutter_actor_set_size (rect[0], 100, 100);
 *
 * // second rectangle
- * rect[1] = clutter_actor_new ();
- * clutter_actor_set_background_color (rect[1], &green_color);
+ * rect[1] = clutter_rectangle_new_with_color (&green_color);
 * clutter_actor_set_size (rect[1], 100, 100);
 * clutter_actor_set_opacity (rect[1], 0);
 *
@@ -55,8 +53,7 @@
 * clutter_actor_add_constraint_with_name (rect[1], "green-y", constraint);
 *
 * // third rectangle
- * rect[2] = clutter_actor_new ();
- * clutter_actor_set_background_color (rect[2], &blue_color);
+ * rect[2] = clutter_rectangle_new_with_color (&blue_color);
 * clutter_actor_set_size (rect[2], 100, 100);
 * clutter_actor_set_opacity (rect[2], 0);
 *
@@ -168,9 +165,6 @@ clutter_bind_constraint_update_preferred_size (ClutterConstraint  *constraint,
        bind->coordinate == CLUTTER_BIND_ALL))
    return;

-  if (clutter_actor_contains (bind->source, actor))
-    return;
-
  switch (direction)
    {
    case CLUTTER_ORIENTATION_HORIZONTAL:
--- a/clutter/clutter/clutter-box-layout.c
+++ b/clutter/clutter/clutter-box-layout.c
--- a/clutter/clutter/clutter-box-layout.h
+++ b/clutter/clutter/clutter-box-layout.h
@@ -105,6 +105,64 @@ void                    clutter_box_layout_set_pack_start       (ClutterBoxLayou
 CLUTTER_EXPORT
 gboolean                clutter_box_layout_get_pack_start       (ClutterBoxLayout    *layout);

+CLUTTER_DEPRECATED_FOR(clutter_box_layout_set_orientation)
+void                    clutter_box_layout_set_vertical         (ClutterBoxLayout    *layout,
+                                                                 gboolean             vertical);
+CLUTTER_DEPRECATED_FOR(clutter_box_layout_get_orientation)
+gboolean                clutter_box_layout_get_vertical         (ClutterBoxLayout    *layout);
+
+CLUTTER_EXPORT
+void                    clutter_box_layout_pack                 (ClutterBoxLayout    *layout,
+                                                                 ClutterActor        *actor,
+                                                                 gboolean             expand,
+                                                                 gboolean             x_fill,
+                                                                 gboolean             y_fill,
+                                                                 ClutterBoxAlignment  x_align,
+                                                                 ClutterBoxAlignment  y_align);
+CLUTTER_DEPRECATED
+void                    clutter_box_layout_set_alignment        (ClutterBoxLayout    *layout,
+                                                                 ClutterActor        *actor,
+                                                                 ClutterBoxAlignment  x_align,
+                                                                 ClutterBoxAlignment  y_align);
+CLUTTER_DEPRECATED
+void                    clutter_box_layout_get_alignment        (ClutterBoxLayout    *layout,
+                                                                 ClutterActor        *actor,
+                                                                 ClutterBoxAlignment *x_align,
+                                                                 ClutterBoxAlignment *y_align);
+CLUTTER_DEPRECATED
+void                    clutter_box_layout_set_fill             (ClutterBoxLayout    *layout,
+                                                                 ClutterActor        *actor,
+                                                                 gboolean             x_fill,
+                                                                 gboolean             y_fill);
+CLUTTER_DEPRECATED
+void                    clutter_box_layout_get_fill             (ClutterBoxLayout    *layout,
+                                                                 ClutterActor        *actor,
+                                                                 gboolean            *x_fill,
+                                                                 gboolean            *y_fill);
+CLUTTER_DEPRECATED
+void                    clutter_box_layout_set_expand           (ClutterBoxLayout    *layout,
+                                                                 ClutterActor        *actor,
+                                                                 gboolean             expand);
+CLUTTER_DEPRECATED
+gboolean                clutter_box_layout_get_expand           (ClutterBoxLayout    *layout,
+                                                                 ClutterActor        *actor);
+
+CLUTTER_DEPRECATED
+void                    clutter_box_layout_set_use_animations   (ClutterBoxLayout    *layout,
+                                                                 gboolean             animate);
+CLUTTER_DEPRECATED
+gboolean                clutter_box_layout_get_use_animations   (ClutterBoxLayout    *layout);
+CLUTTER_DEPRECATED
+void                    clutter_box_layout_set_easing_mode      (ClutterBoxLayout    *layout,
+                                                                 gulong               mode);
+CLUTTER_DEPRECATED
+gulong                  clutter_box_layout_get_easing_mode      (ClutterBoxLayout    *layout);
+CLUTTER_DEPRECATED
+void                    clutter_box_layout_set_easing_duration  (ClutterBoxLayout    *layout,
+                                                                 guint                msecs);
+CLUTTER_DEPRECATED
+guint                   clutter_box_layout_get_easing_duration  (ClutterBoxLayout    *layout);
+
 G_END_DECLS

 #endif /* __CLUTTER_BOX_LAYOUT_H__ */
--- a/clutter/clutter/clutter-click-action.c
+++ b/clutter/clutter/clutter-click-action.c
@@ -159,8 +159,7 @@ static inline void
 click_action_set_pressed (ClutterClickAction *action,
                          gboolean            is_pressed)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;

  is_pressed = !!is_pressed;

@@ -175,8 +174,7 @@ static inline void
 click_action_set_held (ClutterClickAction *action,
                       gboolean            is_held)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;

  is_held = !!is_held;

@@ -191,8 +189,7 @@ static gboolean
 click_action_emit_long_press (gpointer data)
 {
  ClutterClickAction *action = data;
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
  ClutterActor *actor;
  gboolean result;

@@ -216,8 +213,7 @@ click_action_emit_long_press (gpointer data)
 static inline void
 click_action_query_long_press (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
  ClutterActor *actor;
  gboolean result = FALSE;
  gint timeout;
@@ -242,7 +238,6 @@ click_action_query_long_press (ClutterClickAction *action)

  if (result)
    {
-      g_clear_handle_id (&priv->long_press_id, g_source_remove);
      priv->long_press_id =
        clutter_threads_add_timeout (timeout,
                                     click_action_emit_long_press,
@@ -253,8 +248,7 @@ click_action_query_long_press (ClutterClickAction *action)
 static inline void
 click_action_cancel_long_press (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;

  if (priv->long_press_id != 0)
    {
@@ -277,8 +271,7 @@ on_event (ClutterActor       *actor,
          ClutterEvent       *event,
          ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
  gboolean has_button = TRUE;

  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (action)))
@@ -348,8 +341,7 @@ on_captured_event (ClutterActor       *stage,
                   ClutterEvent       *event,
                   ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
  ClutterActor *actor;
  ClutterModifierType modifier_state;
  gboolean has_button = TRUE;
@@ -441,8 +433,7 @@ clutter_click_action_set_actor (ClutterActorMeta *meta,
                                ClutterActor     *actor)
 {
  ClutterClickAction *action = CLUTTER_CLICK_ACTION (meta);
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;

  if (priv->event_id != 0)
    {
@@ -476,28 +467,13 @@ clutter_click_action_set_actor (ClutterActorMeta *meta,
  CLUTTER_ACTOR_META_CLASS (clutter_click_action_parent_class)->set_actor (meta, actor);
 }

-static void
-clutter_click_action_set_enabled (ClutterActorMeta *meta,
-                                  gboolean          is_enabled)
-{
-  ClutterClickAction *click_action = CLUTTER_CLICK_ACTION (meta);
-  ClutterActorMetaClass *parent_class =
-    CLUTTER_ACTOR_META_CLASS (clutter_click_action_parent_class);
-
-  if (!is_enabled)
-    clutter_click_action_release (click_action);
-
-  parent_class->set_enabled (meta, is_enabled);
-}
-
 static void
 clutter_click_action_set_property (GObject      *gobject,
                                   guint         prop_id,
                                   const GValue *value,
                                   GParamSpec   *pspec)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;

  switch (prop_id)
    {
@@ -521,8 +497,7 @@ clutter_click_action_get_property (GObject    *gobject,
                                   GValue     *value,
                                   GParamSpec *pspec)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;

  switch (prop_id)
    {
@@ -551,8 +526,7 @@ clutter_click_action_get_property (GObject    *gobject,
 static void
 clutter_click_action_dispose (GObject *gobject)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;

  g_clear_signal_handler (&priv->event_id,
                          clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (gobject)));
@@ -572,7 +546,6 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
  ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);

  meta_class->set_actor = clutter_click_action_set_actor;
-  meta_class->set_enabled = clutter_click_action_set_enabled;

  gobject_class->dispose = clutter_click_action_dispose;
  gobject_class->set_property = clutter_click_action_set_property;
@@ -710,11 +683,9 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
 static void
 clutter_click_action_init (ClutterClickAction *self)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (self);
-
-  priv->long_press_threshold = -1;
-  priv->long_press_duration = -1;
+  self->priv = clutter_click_action_get_instance_private (self);
+  self->priv->long_press_threshold = -1;
+  self->priv->long_press_duration = -1;
 }

 /**
@@ -754,7 +725,7 @@ clutter_click_action_release (ClutterClickAction *action)

  g_return_if_fail (CLUTTER_IS_CLICK_ACTION (action));

-  priv = clutter_click_action_get_instance_private (action);
+  priv = action->priv;

  if (!priv->is_held)
    return;
@@ -780,13 +751,9 @@ clutter_click_action_release (ClutterClickAction *action)
 guint
 clutter_click_action_get_button (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_CLICK_ACTION (action), 0);

-  priv = clutter_click_action_get_instance_private (action);
-
-  return priv->press_button;
+  return action->priv->press_button;
 }

 /**
@@ -802,13 +769,9 @@ clutter_click_action_get_button (ClutterClickAction *action)
 ClutterModifierType
 clutter_click_action_get_state (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_CLICK_ACTION (action), 0);

-  priv = clutter_click_action_get_instance_private (action);
-
-  return priv->modifier_state;
+  return action->priv->modifier_state;
 }

 /**
@@ -826,15 +789,11 @@ clutter_click_action_get_coords (ClutterClickAction *action,
                                 gfloat             *press_x,
                                 gfloat             *press_y)
 {
-  ClutterClickActionPrivate *priv;
-
  g_return_if_fail (CLUTTER_IS_ACTION (action));

-  priv = clutter_click_action_get_instance_private (action);
-
  if (press_x != NULL)
-    *press_x = priv->press_x;
+    *press_x = action->priv->press_x;

  if (press_y != NULL)
-    *press_y = priv->press_y;
+    *press_y = action->priv->press_y;
 }
--- a/clutter/clutter/clutter-click-action.h
+++ b/clutter/clutter/clutter-click-action.h
@@ -37,13 +37,32 @@

 G_BEGIN_DECLS

-#define CLUTTER_TYPE_CLICK_ACTION (clutter_click_action_get_type ())
+#define CLUTTER_TYPE_CLICK_ACTION               (clutter_click_action_get_type ())
+#define CLUTTER_CLICK_ACTION(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_CLICK_ACTION, ClutterClickAction))
+#define CLUTTER_IS_CLICK_ACTION(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_CLICK_ACTION))
+#define CLUTTER_CLICK_ACTION_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_CLICK_ACTION, ClutterClickActionClass))
+#define CLUTTER_IS_CLICK_ACTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_CLICK_ACTION))
+#define CLUTTER_CLICK_ACTION_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_CLICK_ACTION, ClutterClickActionClass))

-CLUTTER_EXPORT
-G_DECLARE_DERIVABLE_TYPE (ClutterClickAction, clutter_click_action,
-                          CLUTTER, CLICK_ACTION, ClutterAction);
+typedef struct _ClutterClickAction              ClutterClickAction;
+typedef struct _ClutterClickActionPrivate       ClutterClickActionPrivate;
+typedef struct _ClutterClickActionClass         ClutterClickActionClass;

-typedef struct _ClutterClickActionPrivate ClutterClickActionPrivate;
+/**
+ * ClutterClickAction:
+ *
+ * The #ClutterClickAction structure contains
+ * only private data and should be accessed using the provided API
+ *
+ * Since: 1.4
+ */
+struct _ClutterClickAction
+{
+  /*< private >*/
+  ClutterAction parent_instance;
+
+  ClutterClickActionPrivate *priv;
+};

 /**
 * ClutterClickActionClass:
@@ -78,6 +97,9 @@ struct _ClutterClickActionClass
  void (* _clutter_click_action7) (void);
 };

+CLUTTER_EXPORT
+GType clutter_click_action_get_type (void) G_GNUC_CONST;
+
 CLUTTER_EXPORT
 ClutterAction *        clutter_click_action_new        (void);

--- a/clutter/clutter/clutter-clone.c
+++ b/clutter/clutter/clutter-clone.c
@@ -52,8 +52,6 @@
 struct _ClutterClonePrivate
 {
  ClutterActor *clone_source;
-  float x_scale, y_scale;
-
  gulong source_destroy_id;
 };

@@ -124,6 +122,8 @@ static void
 clutter_clone_apply_transform (ClutterActor *self, CoglMatrix *matrix)
 {
  ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv;
+  ClutterActorBox box, source_box;
+  gfloat x_scale, y_scale;

  /* First chain up and apply all the standard ClutterActor
   * transformations... */
@@ -134,7 +134,21 @@ clutter_clone_apply_transform (ClutterActor *self, CoglMatrix *matrix)
  if (priv->clone_source == NULL)
    return;

-  cogl_matrix_scale (matrix, priv->x_scale, priv->y_scale, 1.f);
+  /* get our allocated size */
+  clutter_actor_get_allocation_box (self, &box);
+
+  /* and get the allocated size of the source */
+  clutter_actor_get_allocation_box (priv->clone_source, &source_box);
+
+  /* We need to scale what the clone-source actor paints to fill our own
+   * allocation...
+   */
+  x_scale = clutter_actor_box_get_width (&box)
+          / clutter_actor_box_get_width (&source_box);
+  y_scale = clutter_actor_box_get_height (&box)
+          / clutter_actor_box_get_height (&source_box);
+
+  cogl_matrix_scale (matrix, x_scale, y_scale, x_scale);
 }

 static void
@@ -226,16 +240,15 @@ clutter_clone_has_overlaps (ClutterActor *actor)

 static void
 clutter_clone_allocate (ClutterActor           *self,
-                        const ClutterActorBox  *box)
+                        const ClutterActorBox  *box,
+                        ClutterAllocationFlags  flags)
 {
  ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv;
  ClutterActorClass *parent_class;
-  ClutterActorBox source_box;
-  float x_scale, y_scale;

  /* chain up */
  parent_class = CLUTTER_ACTOR_CLASS (clutter_clone_parent_class);
-  parent_class->allocate (self, box);
+  parent_class->allocate (self, box, flags);

  if (priv->clone_source == NULL)
    return;
@@ -245,31 +258,7 @@ clutter_clone_allocate (ClutterActor           *self,
   */
  if (clutter_actor_get_parent (priv->clone_source) != NULL &&
      !clutter_actor_has_allocation (priv->clone_source))
-    {
-      float x = 0.f;
-      float y = 0.f;
-
-      clutter_actor_get_fixed_position (priv->clone_source, &x, &y);
-      clutter_actor_allocate_preferred_size (priv->clone_source, x, y);
-    }
-
-  clutter_actor_get_allocation_box (priv->clone_source, &source_box);
-
-  /* We need to scale what the clone-source actor paints to fill our own
-   * allocation...
-   */
-  x_scale = clutter_actor_box_get_width (box)
-          / clutter_actor_box_get_width (&source_box);
-  y_scale = clutter_actor_box_get_height (box)
-          / clutter_actor_box_get_height (&source_box);
-
-  if (!G_APPROX_VALUE (priv->x_scale, x_scale, FLT_EPSILON) ||
-      !G_APPROX_VALUE (priv->y_scale, y_scale, FLT_EPSILON))
-    {
-      priv->x_scale = x_scale;
-      priv->y_scale = y_scale;
-      clutter_actor_invalidate_transform (CLUTTER_ACTOR (self));
-    }
+    clutter_actor_allocate_preferred_size (priv->clone_source, flags);

 #if 0
  /* XXX - this is wrong: ClutterClone cannot clone unparented
@@ -284,7 +273,7 @@ clutter_clone_allocate (ClutterActor           *self,
   * paint cycle, we can safely give it as much size as it requires
   */
  if (clutter_actor_get_parent (priv->clone_source) == NULL)
-    clutter_actor_allocate_preferred_size (priv->clone_source);
+    clutter_actor_allocate_preferred_size (priv->clone_source, flags);
 #endif
 }

@@ -376,9 +365,6 @@ static void
 clutter_clone_init (ClutterClone *self)
 {
  self->priv = clutter_clone_get_instance_private (self);
-
-  self->priv->x_scale = 1.f;
-  self->priv->y_scale = 1.f;
 }

 /**
--- a/clutter/clutter/clutter-config.h.in
+++ b/clutter/clutter/clutter-config.h.in
@@ -9,13 +9,7 @@

 G_BEGIN_DECLS

-#mesondefine CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
-#mesondefine CLUTTER_WINDOWING_X11
-#mesondefine CLUTTER_INPUT_X11
-#mesondefine CLUTTER_WINDOWING_GLX
-#mesondefine CLUTTER_WINDOWING_EGL
-#mesondefine CLUTTER_INPUT_EVDEV
-#mesondefine CLUTTER_INPUT_NULL
+@CLUTTER_CONFIG_DEFINES@

 G_END_DECLS

--- a/clutter/clutter/clutter-constraint.c
+++ b/clutter/clutter/clutter-constraint.c
@@ -160,26 +160,28 @@ constraint_update_preferred_size (ClutterConstraint  *constraint,
 }

 static void
-clutter_constraint_set_enabled (ClutterActorMeta *meta,
-                                gboolean          is_enabled)
+clutter_constraint_notify (GObject    *gobject,
+                           GParamSpec *pspec)
 {
-  ClutterActorMetaClass *parent_class =
-    CLUTTER_ACTOR_META_CLASS (clutter_constraint_parent_class);
-  ClutterActor *actor;
+  if (strcmp (pspec->name, "enabled") == 0)
+    {
+      ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject);
+      ClutterActor *actor = clutter_actor_meta_get_actor (meta);

-  actor = clutter_actor_meta_get_actor (meta);
-  if (actor)
-    clutter_actor_queue_relayout (actor);
+      if (actor != NULL)
+        clutter_actor_queue_relayout (actor);
+    }

-  parent_class->set_enabled (meta, is_enabled);
+  if (G_OBJECT_CLASS (clutter_constraint_parent_class)->notify != NULL)
+    G_OBJECT_CLASS (clutter_constraint_parent_class)->notify (gobject, pspec);
 }

 static void
 clutter_constraint_class_init (ClutterConstraintClass *klass)
 {
-  ClutterActorMetaClass *actor_meta_class = CLUTTER_ACTOR_META_CLASS (klass);
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

-  actor_meta_class->set_enabled = clutter_constraint_set_enabled;
+  gobject_class->notify = clutter_constraint_notify;

  klass->update_allocation = constraint_update_allocation;
  klass->update_preferred_size = constraint_update_preferred_size;
--- a/clutter/clutter/clutter-damage-history.c
+++ b/clutter/clutter/clutter-damage-history.c
@@ -1,92 +0,0 @@
-/*
- * Copyright (C) 2007,2008,2009,2010,2011  Intel Corporation.
- * Copyright (C) 2020 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/>.
- */
-
-#include "clutter-build-config.h"
-
-#include "clutter-damage-history.h"
-
-#define DAMAGE_HISTORY_LENGTH 0x10
-
-struct _ClutterDamageHistory
-{
-  cairo_region_t *damages[DAMAGE_HISTORY_LENGTH];
-  int index;
-};
-
-ClutterDamageHistory *
-clutter_damage_history_new (void)
-{
-  ClutterDamageHistory *history;
-
-  history = g_new0 (ClutterDamageHistory, 1);
-
-  return history;
-}
-
-void
-clutter_damage_history_free (ClutterDamageHistory *history)
-{
-  int i;
-
-  for (i = 0; i < G_N_ELEMENTS (history->damages); i++)
-    g_clear_pointer (&history->damages[i], cairo_region_destroy);
-
-  g_free (history);
-}
-
-gboolean
-clutter_damage_history_is_age_valid (ClutterDamageHistory *history,
-                                     int                   age)
-{
-  if (age >= DAMAGE_HISTORY_LENGTH ||
-      age < 1)
-    return FALSE;
-
-  if (!clutter_damage_history_lookup (history, age))
-    return FALSE;
-
-  return TRUE;
-}
-
-void
-clutter_damage_history_record (ClutterDamageHistory *history,
-                               const cairo_region_t *damage)
-{
-  g_clear_pointer (&history->damages[history->index], cairo_region_destroy);
-  history->damages[history->index] = cairo_region_copy (damage);
-}
-
-static inline int
-step_damage_index (int current,
-                   int diff)
-{
-  return (current + diff) & (DAMAGE_HISTORY_LENGTH - 1);
-}
-
-void
-clutter_damage_history_step (ClutterDamageHistory *history)
-{
-  history->index = step_damage_index (history->index, 1);
-}
-
-const cairo_region_t *
-clutter_damage_history_lookup (ClutterDamageHistory *history,
-                               int                   age)
-{
-  return history->damages[step_damage_index (history->index, -age)];
-}
--- a/clutter/clutter/clutter-damage-history.h
+++ b/clutter/clutter/clutter-damage-history.h
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2007,2008,2009,2010,2011  Intel Corporation.
- * Copyright (C) 2020 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_DAMAGE_HISTORY_H
-#define CLUTTER_DAMAGE_HISTORY_H
-
-#include <cairo.h>
-#include <glib.h>
-
-typedef struct _ClutterDamageHistory ClutterDamageHistory;
-
-ClutterDamageHistory * clutter_damage_history_new (void);
-
-void clutter_damage_history_free (ClutterDamageHistory *history);
-
-gboolean clutter_damage_history_is_age_valid (ClutterDamageHistory *history,
-                                              int                   age);
-
-void clutter_damage_history_record (ClutterDamageHistory *history,
-                                    const cairo_region_t *damage);
-
-void clutter_damage_history_step (ClutterDamageHistory *history);
-
-const cairo_region_t * clutter_damage_history_lookup (ClutterDamageHistory *history,
-                                                      int                   age);
-
-#endif /* CLUTTER_DAMAGE_HISTORY_H */
--- a/clutter/clutter/clutter-deform-effect.c
+++ b/clutter/clutter/clutter-deform-effect.c
@@ -128,9 +128,10 @@ clutter_deform_effect_deform_vertex (ClutterDeformEffect *effect,
 }

 static void
-vbo_invalidate (ClutterActor        *actor,
-                GParamSpec          *pspec,
-                ClutterDeformEffect *effect)
+vbo_invalidate (ClutterActor           *actor,
+                const ClutterActorBox  *allocation,
+                ClutterAllocationFlags  flags,
+                ClutterDeformEffect    *effect)
 {
  effect->priv->is_dirty = TRUE;
 }
@@ -155,7 +156,7 @@ clutter_deform_effect_set_actor (ClutterActorMeta *meta,
   * changes
   */
  if (actor != NULL)
-    priv->allocation_id = g_signal_connect (actor, "notify::allocation",
+    priv->allocation_id = g_signal_connect (actor, "allocation-changed",
                                            G_CALLBACK (vbo_invalidate),
                                            meta);

--- a/clutter/clutter/clutter-deprecated.h
+++ b/clutter/clutter/clutter-deprecated.h
@@ -3,7 +3,16 @@

 #define __CLUTTER_DEPRECATED_H_INSIDE__

+#include "deprecated/clutter-actor.h"
+#include "deprecated/clutter-alpha.h"
+#include "deprecated/clutter-animation.h"
+#include "deprecated/clutter-box.h"
 #include "deprecated/clutter-container.h"
+#include "deprecated/clutter-group.h"
+#include "deprecated/clutter-rectangle.h"
+#include "deprecated/clutter-stage.h"
+#include "deprecated/clutter-state.h"
+#include "deprecated/clutter-timeline.h"

 #undef __CLUTTER_DEPRECATED_H_INSIDE__

--- a/clutter/clutter/clutter-drag-action.c
+++ b/clutter/clutter/clutter-drag-action.c
--- a/clutter/clutter/clutter-drag-action.h
+++ b/clutter/clutter/clutter-drag-action.h
@@ -0,0 +1,152 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2010  Intel Corporation.
+ *
+ * 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/>.
+ *
+ * Author:
+ *   Emmanuele Bassi <ebassi@linux.intel.com>
+ */
+
+#ifndef __CLUTTER_DRAG_ACTION_H__
+#define __CLUTTER_DRAG_ACTION_H__
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#include <clutter/clutter-action.h>
+#include <clutter/clutter-event.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_DRAG_ACTION                (clutter_drag_action_get_type ())
+#define CLUTTER_DRAG_ACTION(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_DRAG_ACTION, ClutterDragAction))
+#define CLUTTER_IS_DRAG_ACTION(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_DRAG_ACTION))
+#define CLUTTER_DRAG_ACTION_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_DRAG_ACTION, ClutterDragActionClass))
+#define CLUTTER_IS_DRAG_ACTION_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_DRAG_ACTION))
+#define CLUTTER_DRAG_ACTION_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_DRAG_ACTION, ClutterDragActionClass))
+
+typedef struct _ClutterDragAction               ClutterDragAction;
+typedef struct _ClutterDragActionPrivate        ClutterDragActionPrivate;
+typedef struct _ClutterDragActionClass          ClutterDragActionClass;
+
+/**
+ * ClutterDragAction:
+ *
+ * The #ClutterDragAction structure contains only
+ * private data and should be accessed using the provided API
+ *
+ * Since: 1.4
+ */
+struct _ClutterDragAction
+{
+  /*< private >*/
+  ClutterAction parent_instance;
+
+  ClutterDragActionPrivate *priv;
+};
+
+/**
+ * ClutterDragActionClass:
+ * @drag_begin: class handler of the #ClutterDragAction::drag-begin signal
+ * @drag_motion: class handler of the #ClutterDragAction::drag-motion signal
+ * @drag_end: class handler of the #ClutterDragAction::drag-end signal
+ * @drag_progress: class handler of the #ClutterDragAction::drag-progress signal
+ *
+ * The #ClutterDragActionClass structure contains
+ * only private data
+ *
+ * Since: 1.4
+ */
+struct _ClutterDragActionClass
+{
+  /*< private >*/
+  ClutterActionClass parent_class;
+
+  /*< public >*/
+  void          (* drag_begin)          (ClutterDragAction   *action,
+                                         ClutterActor        *actor,
+                                         gfloat               event_x,
+                                         gfloat               event_y,
+                                         ClutterModifierType  modifiers);
+  void          (* drag_motion)         (ClutterDragAction   *action,
+                                         ClutterActor        *actor,
+                                         gfloat               delta_x,
+                                         gfloat               delta_y);
+  void          (* drag_end)            (ClutterDragAction   *action,
+                                         ClutterActor        *actor,
+                                         gfloat               event_x,
+                                         gfloat               event_y,
+                                         ClutterModifierType  modifiers);
+  gboolean      (* drag_progress)       (ClutterDragAction   *action,
+                                         ClutterActor        *actor,
+                                         gfloat               delta_x,
+                                         gfloat               delta_y);
+
+  /*< private >*/
+  void (* _clutter_drag_action1) (void);
+  void (* _clutter_drag_action2) (void);
+  void (* _clutter_drag_action3) (void);
+  void (* _clutter_drag_action4) (void);
+};
+
+CLUTTER_EXPORT
+GType clutter_drag_action_get_type (void) G_GNUC_CONST;
+
+CLUTTER_EXPORT
+ClutterAction * clutter_drag_action_new                   (void);
+
+CLUTTER_EXPORT
+void            clutter_drag_action_set_drag_threshold (ClutterDragAction *action,
+                                                        gint               x_threshold,
+                                                        gint               y_threshold);
+CLUTTER_EXPORT
+void            clutter_drag_action_get_drag_threshold (ClutterDragAction *action,
+                                                        guint             *x_threshold,
+                                                        guint             *y_threshold);
+CLUTTER_EXPORT
+void            clutter_drag_action_set_drag_handle    (ClutterDragAction *action,
+                                                        ClutterActor      *handle);
+CLUTTER_EXPORT
+ClutterActor *  clutter_drag_action_get_drag_handle    (ClutterDragAction *action);
+CLUTTER_EXPORT
+void            clutter_drag_action_set_drag_axis      (ClutterDragAction *action,
+                                                        ClutterDragAxis    axis);
+CLUTTER_EXPORT
+ClutterDragAxis clutter_drag_action_get_drag_axis      (ClutterDragAction *action);
+
+CLUTTER_EXPORT
+void            clutter_drag_action_get_press_coords   (ClutterDragAction *action,
+                                                        gfloat            *press_x,
+                                                        gfloat            *press_y);
+CLUTTER_EXPORT
+void            clutter_drag_action_get_motion_coords  (ClutterDragAction *action,
+                                                        gfloat            *motion_x,
+                                                        gfloat            *motion_y);
+
+CLUTTER_EXPORT
+gboolean        clutter_drag_action_get_drag_area      (ClutterDragAction *action,
+                                                        graphene_rect_t   *drag_area);
+
+CLUTTER_EXPORT
+void            clutter_drag_action_set_drag_area      (ClutterDragAction     *action,
+                                                        const graphene_rect_t *drag_area);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_DRAG_ACTION_H__ */
--- a/clutter/clutter/clutter-drop-action.c
+++ b/clutter/clutter/clutter-drop-action.c
@@ -0,0 +1,527 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright © 2011  Intel Corporation.
+ *
+ * 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/>.
+ *
+ * Author:
+ *   Emmanuele Bassi <ebassi@linux.intel.com>
+ */
+
+/**
+ * SECTION:clutter-drop-action
+ * @Title: ClutterDropAction
+ * @short_description: An action for drop targets
+ *
+ * #ClutterDropAction is a #ClutterAction that allows a #ClutterActor
+ * implementation to control what happens when an actor dragged using
+ * a #ClutterDragAction crosses the target area or when a dragged actor
+ * is released (or "dropped") on the target area.
+ *
+ * A trivial use of #ClutterDropAction consists in connecting to the
+ * #ClutterDropAction::drop signal and handling the drop from there,
+ * for instance:
+ *
+ * |[<!-- language="C" -->
+ *   ClutterAction *action = clutter_drop_action ();
+ *
+ *   g_signal_connect (action, "drop", G_CALLBACK (on_drop), NULL);
+ *   clutter_actor_add_action (an_actor, action);
+ * ]|
+ *
+ * The #ClutterDropAction::can-drop can be used to control whether the
+ * #ClutterDropAction::drop signal is going to be emitted; returning %FALSE
+ * from a handler connected to the #ClutterDropAction::can-drop signal will
+ * cause the #ClutterDropAction::drop signal to be skipped when the input
+ * device button is released.
+ *
+ * It's important to note that #ClutterDropAction will only work with
+ * actors dragged using #ClutterDragAction.
+ *
+ * See [drop-action.c](https://git.gnome.org/browse/clutter/tree/examples/drop-action.c?h=clutter-1.18)
+ * for an example of how to use #ClutterDropAction.
+ *
+ * #ClutterDropAction is available since Clutter 1.8
+ */
+
+#include "clutter-build-config.h"
+
+#include "clutter-drop-action.h"
+
+#include "clutter-actor-meta-private.h"
+#include "clutter-actor-private.h"
+#include "clutter-drag-action.h"
+#include "clutter-main.h"
+#include "clutter-marshal.h"
+#include "clutter-stage-private.h"
+
+struct _ClutterDropActionPrivate
+{
+  ClutterActor *actor;
+  ClutterActor *stage;
+
+  gulong mapped_id;
+};
+
+typedef struct _DropTarget {
+  ClutterActor *stage;
+
+  gulong capture_id;
+
+  GHashTable *actions;
+
+  ClutterDropAction *last_action;
+} DropTarget;
+
+enum
+{
+  CAN_DROP,
+  OVER_IN,
+  OVER_OUT,
+  DROP,
+  DROP_CANCEL,
+
+  LAST_SIGNAL
+};
+
+static guint drop_signals[LAST_SIGNAL] = { 0, };
+
+G_DEFINE_TYPE_WITH_PRIVATE (ClutterDropAction, clutter_drop_action, CLUTTER_TYPE_ACTION)
+
+static void
+drop_target_free (gpointer _data)
+{
+  DropTarget *data = _data;
+
+  g_clear_signal_handler (&data->capture_id, data->stage);
+  g_hash_table_destroy (data->actions);
+  g_free (data);
+}
+
+static gboolean
+on_stage_capture (ClutterStage *stage,
+                  ClutterEvent *event,
+                  gpointer      user_data)
+{
+  DropTarget *data = user_data;
+  gfloat event_x, event_y;
+  ClutterActor *actor, *drag_actor;
+  ClutterDropAction *drop_action;
+  ClutterInputDevice *device;
+  gboolean was_reactive;
+
+  switch (clutter_event_type (event))
+    {
+    case CLUTTER_MOTION:
+    case CLUTTER_BUTTON_RELEASE:
+      if (clutter_event_type (event) == CLUTTER_MOTION &&
+          !(clutter_event_get_state (event) & CLUTTER_BUTTON1_MASK))
+        return CLUTTER_EVENT_PROPAGATE;
+
+      if (clutter_event_type (event) == CLUTTER_BUTTON_RELEASE &&
+          clutter_event_get_button (event) != CLUTTER_BUTTON_PRIMARY)
+        return CLUTTER_EVENT_PROPAGATE;
+
+      device = clutter_event_get_device (event);
+      drag_actor = _clutter_stage_get_pointer_drag_actor (stage, device);
+      if (drag_actor == NULL)
+        return CLUTTER_EVENT_PROPAGATE;
+      break;
+
+    case CLUTTER_TOUCH_UPDATE:
+    case CLUTTER_TOUCH_END:
+      drag_actor = _clutter_stage_get_touch_drag_actor (stage,
+                                                        clutter_event_get_event_sequence (event));
+      if (drag_actor == NULL)
+        return CLUTTER_EVENT_PROPAGATE;
+      break;
+
+    default:
+      return CLUTTER_EVENT_PROPAGATE;
+    }
+
+  clutter_event_get_coords (event, &event_x, &event_y);
+
+  /* get the actor under the cursor, excluding the dragged actor; we
+   * use reactivity because it won't cause any scene invalidation
+   */
+  was_reactive = clutter_actor_get_reactive (drag_actor);
+  clutter_actor_set_reactive (drag_actor, FALSE);
+
+  actor = clutter_stage_get_actor_at_pos (stage, CLUTTER_PICK_REACTIVE,
+                                          event_x,
+                                          event_y);
+  if (actor == NULL || actor == CLUTTER_ACTOR (stage))
+    {
+      if (data->last_action != NULL)
+        {
+          ClutterActorMeta *meta = CLUTTER_ACTOR_META (data->last_action);
+
+          g_signal_emit (data->last_action, drop_signals[OVER_OUT], 0,
+                         clutter_actor_meta_get_actor (meta));
+
+          data->last_action = NULL;
+        }
+
+      goto out;
+    }
+
+  drop_action = g_hash_table_lookup (data->actions, actor);
+
+  if (drop_action == NULL)
+    {
+      if (data->last_action != NULL)
+        {
+          ClutterActorMeta *meta = CLUTTER_ACTOR_META (data->last_action);
+
+          g_signal_emit (data->last_action, drop_signals[OVER_OUT], 0,
+                         clutter_actor_meta_get_actor (meta));
+
+          data->last_action = NULL;
+        }
+
+      goto out;
+    }
+  else
+    {
+      if (data->last_action != drop_action)
+        {
+          ClutterActorMeta *meta;
+
+          if (data->last_action != NULL)
+            {
+              meta = CLUTTER_ACTOR_META (data->last_action);
+
+              g_signal_emit (data->last_action, drop_signals[OVER_OUT], 0,
+                             clutter_actor_meta_get_actor (meta));
+            }
+
+          meta = CLUTTER_ACTOR_META (drop_action);
+
+          g_signal_emit (drop_action, drop_signals[OVER_IN], 0,
+                         clutter_actor_meta_get_actor (meta));
+        }
+
+      data->last_action = drop_action;
+    }
+
+out:
+  if (clutter_event_type (event) == CLUTTER_BUTTON_RELEASE ||
+      clutter_event_type (event) == CLUTTER_TOUCH_END)
+    {
+      if (data->last_action != NULL)
+        {
+          ClutterActorMeta *meta = CLUTTER_ACTOR_META (data->last_action);
+          gboolean can_drop = FALSE;
+
+          g_signal_emit (data->last_action, drop_signals[CAN_DROP], 0,
+                         clutter_actor_meta_get_actor (meta),
+                         event_x, event_y,
+                         &can_drop);
+
+          if (can_drop)
+            {
+              g_signal_emit (data->last_action, drop_signals[DROP], 0,
+                             clutter_actor_meta_get_actor (meta),
+                             event_x, event_y);
+            }
+	  else
+            {
+              g_signal_emit (data->last_action, drop_signals[DROP_CANCEL], 0,
+                             clutter_actor_meta_get_actor (meta),
+                             event_x, event_y);
+            }
+
+        }
+
+      data->last_action = NULL;
+    }
+
+  if (drag_actor != NULL)
+    clutter_actor_set_reactive (drag_actor, was_reactive);
+
+  return CLUTTER_EVENT_PROPAGATE;
+}
+
+static void
+drop_action_register (ClutterDropAction *self)
+{
+  ClutterDropActionPrivate *priv = self->priv;
+  DropTarget *data;
+
+  g_assert (priv->stage != NULL);
+
+  data = g_object_get_data (G_OBJECT (priv->stage), "__clutter_drop_targets");
+  if (data == NULL)
+    {
+      data = g_new0 (DropTarget, 1);
+
+      data->stage = priv->stage;
+      data->actions = g_hash_table_new (NULL, NULL);
+      data->capture_id = g_signal_connect (priv->stage, "captured-event",
+                                           G_CALLBACK (on_stage_capture),
+                                           data);
+      g_object_set_data_full (G_OBJECT (priv->stage), "__clutter_drop_targets",
+                              data,
+                              drop_target_free);
+    }
+
+  g_hash_table_replace (data->actions, priv->actor, self);
+}
+
+static void
+drop_action_unregister (ClutterDropAction *self)
+{
+  ClutterDropActionPrivate *priv = self->priv;
+  DropTarget *data = NULL;
+
+  if (priv->stage != NULL)
+    data = g_object_get_data (G_OBJECT (priv->stage), "__clutter_drop_targets");
+
+  if (data == NULL)
+    return;
+
+  g_hash_table_remove (data->actions, priv->actor);
+  if (g_hash_table_size (data->actions) == 0)
+    g_object_set_data (G_OBJECT (data->stage), "__clutter_drop_targets", NULL);
+}
+
+static void
+on_actor_mapped (ClutterActor      *actor,
+                 GParamSpec        *pspec,
+                 ClutterDropAction *self)
+{
+  if (clutter_actor_is_mapped (actor))
+    {
+      if (self->priv->stage == NULL)
+        self->priv->stage = clutter_actor_get_stage (actor);
+
+      drop_action_register (self);
+    }
+  else
+    drop_action_unregister (self);
+}
+
+static void
+clutter_drop_action_set_actor (ClutterActorMeta *meta,
+                               ClutterActor     *actor)
+{
+  ClutterDropActionPrivate *priv = CLUTTER_DROP_ACTION (meta)->priv;
+
+  if (priv->actor != NULL)
+    {
+      drop_action_unregister (CLUTTER_DROP_ACTION (meta));
+
+      g_clear_signal_handler (&priv->mapped_id, priv->actor);
+
+      priv->stage = NULL;
+      priv->actor = NULL;
+    }
+
+  priv->actor = actor;
+
+  if (priv->actor != NULL)
+    {
+      priv->stage = clutter_actor_get_stage (actor);
+      priv->mapped_id = g_signal_connect (actor, "notify::mapped",
+                                          G_CALLBACK (on_actor_mapped),
+                                          meta);
+
+      if (priv->stage != NULL)
+        drop_action_register (CLUTTER_DROP_ACTION (meta));
+    }
+
+  CLUTTER_ACTOR_META_CLASS (clutter_drop_action_parent_class)->set_actor (meta, actor);
+}
+
+static gboolean
+signal_accumulator (GSignalInvocationHint *ihint,
+                    GValue                *return_accu,
+                    const GValue          *handler_return,
+                    gpointer               user_data)
+{
+  gboolean continue_emission;
+
+  continue_emission = g_value_get_boolean (handler_return);
+  g_value_set_boolean (return_accu, continue_emission);
+
+  return continue_emission;
+}
+
+static gboolean
+clutter_drop_action_real_can_drop (ClutterDropAction *action,
+                                   ClutterActor      *actor,
+                                   gfloat             event_x,
+                                   gfloat             event_y)
+{
+  return TRUE;
+}
+
+static void
+clutter_drop_action_class_init (ClutterDropActionClass *klass)
+{
+  ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
+
+  meta_class->set_actor = clutter_drop_action_set_actor;
+
+  klass->can_drop = clutter_drop_action_real_can_drop;
+
+  /**
+   * ClutterDropAction::can-drop:
+   * @action: the #ClutterDropAction that emitted the signal
+   * @actor: the #ClutterActor attached to the @action
+   * @event_x: the X coordinate (in stage space) of the drop event
+   * @event_y: the Y coordinate (in stage space) of the drop event
+   *
+   * The ::can-drop signal is emitted when the dragged actor is dropped
+   * on @actor. The return value of the ::can-drop signal will determine
+   * whether or not the #ClutterDropAction::drop signal is going to be
+   * emitted on @action.
+   *
+   * The default implementation of #ClutterDropAction returns %TRUE for
+   * this signal.
+   *
+   * Return value: %TRUE if the drop is accepted, and %FALSE otherwise
+   *
+   * Since: 1.8
+   */
+  drop_signals[CAN_DROP] =
+    g_signal_new (I_("can-drop"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (ClutterDropActionClass, can_drop),
+                  signal_accumulator, NULL,
+                  _clutter_marshal_BOOLEAN__OBJECT_FLOAT_FLOAT,
+                  G_TYPE_BOOLEAN, 3,
+                  CLUTTER_TYPE_ACTOR,
+                  G_TYPE_FLOAT,
+                  G_TYPE_FLOAT);
+
+  /**
+   * ClutterDropAction::over-in:
+   * @action: the #ClutterDropAction that emitted the signal
+   * @actor: the #ClutterActor attached to the @action
+   *
+   * The ::over-in signal is emitted when the dragged actor crosses
+   * into @actor.
+   *
+   * Since: 1.8
+   */
+  drop_signals[OVER_IN] =
+    g_signal_new (I_("over-in"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (ClutterDropActionClass, over_in),
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 1,
+                  CLUTTER_TYPE_ACTOR);
+
+  /**
+   * ClutterDropAction::over-out:
+   * @action: the #ClutterDropAction that emitted the signal
+   * @actor: the #ClutterActor attached to the @action
+   *
+   * The ::over-out signal is emitted when the dragged actor crosses
+   * outside @actor.
+   *
+   * Since: 1.8
+   */
+  drop_signals[OVER_OUT] =
+    g_signal_new (I_("over-out"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (ClutterDropActionClass, over_out),
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 1,
+                  CLUTTER_TYPE_ACTOR);
+
+  /**
+   * ClutterDropAction::drop:
+   * @action: the #ClutterDropAction that emitted the signal
+   * @actor: the #ClutterActor attached to the @action
+   * @event_x: the X coordinate (in stage space) of the drop event
+   * @event_y: the Y coordinate (in stage space) of the drop event
+   *
+   * The ::drop signal is emitted when the dragged actor is dropped
+   * on @actor. This signal is only emitted if at least an handler of
+   * #ClutterDropAction::can-drop returns %TRUE.
+   *
+   * Since: 1.8
+   */
+  drop_signals[DROP] =
+    g_signal_new (I_("drop"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (ClutterDropActionClass, drop),
+                  NULL, NULL,
+                  _clutter_marshal_VOID__OBJECT_FLOAT_FLOAT,
+                  G_TYPE_NONE, 3,
+                  CLUTTER_TYPE_ACTOR,
+                  G_TYPE_FLOAT,
+                  G_TYPE_FLOAT);
+
+
+  /**
+   * ClutterDropAction::drop-cancel:
+   * @action: the #ClutterDropAction that emitted the signal
+   * @actor: the #ClutterActor attached to the @action
+   * @event_x: the X coordinate (in stage space) of the drop event
+   * @event_y: the Y coordinate (in stage space) of the drop event
+   *
+   * The ::drop-cancel signal is emitted when the drop is refused
+   * by an emission of the #ClutterDropAction::can-drop signal.
+   *
+   * After the ::drop-cancel signal is fired the active drag is
+   * terminated.
+   *
+   * Since: 1.12
+   */
+  drop_signals[DROP_CANCEL] =
+    g_signal_new (I_("drop-cancel"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (ClutterDropActionClass, drop),
+                  NULL, NULL,
+                  _clutter_marshal_VOID__OBJECT_FLOAT_FLOAT,
+                  G_TYPE_NONE, 3,
+                  CLUTTER_TYPE_ACTOR,
+                  G_TYPE_FLOAT,
+                  G_TYPE_FLOAT);
+}
+
+static void
+clutter_drop_action_init (ClutterDropAction *self)
+{
+  self->priv = clutter_drop_action_get_instance_private (self);
+}
+
+/**
+ * clutter_drop_action_new:
+ *
+ * Creates a new #ClutterDropAction.
+ *
+ * Use clutter_actor_add_action() to add the action to a #ClutterActor.
+ *
+ * Return value: the newly created #ClutterDropAction
+ *
+ * Since: 1.8
+ */
+ClutterAction *
+clutter_drop_action_new (void)
+{
+  return g_object_new (CLUTTER_TYPE_DROP_ACTION, NULL);
+}
--- a/clutter/clutter/clutter-drop-action.h
+++ b/clutter/clutter/clutter-drop-action.h
@@ -0,0 +1,115 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright © 2011  Intel Corporation.
+ *
+ * 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/>.
+ *
+ * Author:
+ *   Emmanuele Bassi <ebassi@linux.intel.com>
+ */
+
+#ifndef __CLUTTER_DROP_ACTION_H__
+#define __CLUTTER_DROP_ACTION_H__
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be directly included."
+#endif
+
+#include <clutter/clutter-action.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_DROP_ACTION                (clutter_drop_action_get_type ())
+#define CLUTTER_DROP_ACTION(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_DROP_ACTION, ClutterDropAction))
+#define CLUTTER_IS_DROP_ACTION(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_DROP_ACTION))
+#define CLUTTER_DROP_ACTION_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_DROP_ACTION, ClutterDropActionClass))
+#define CLUTTER_IS_DROP_ACTION_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_DROP_ACTION))
+#define CLUTTER_DROP_ACTION_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_DROP_ACTION, ClutterDropActionClass))
+
+typedef struct _ClutterDropAction               ClutterDropAction;
+typedef struct _ClutterDropActionPrivate        ClutterDropActionPrivate;
+typedef struct _ClutterDropActionClass          ClutterDropActionClass;
+
+/**
+ * ClutterDropAction:
+ *
+ * The #ClutterDropAction structure contains only
+ * private data and should be accessed using the provided API.
+ *
+ * Since: 1.8
+ */
+struct _ClutterDropAction
+{
+  /*< private >*/
+  ClutterAction parent_instance;
+
+  ClutterDropActionPrivate *priv;
+};
+
+/**
+ * ClutterDropActionClass:
+ * @can_drop: class handler for the #ClutterDropAction::can-drop signal
+ * @over_in: class handler for the #ClutterDropAction::over-in signal
+ * @over_out: class handler for the #ClutterDropAction::over-out signal
+ * @drop: class handler for the #ClutterDropAction::drop signal
+ *
+ * The #ClutterDropActionClass structure contains
+ * only private data.
+ *
+ * Since: 1.8
+ */
+struct _ClutterDropActionClass
+{
+  /*< private >*/
+  ClutterActionClass parent_class;
+
+  /*< public >*/
+  gboolean (* can_drop) (ClutterDropAction *action,
+                         ClutterActor      *actor,
+                         gfloat             event_x,
+                         gfloat             event_y);
+
+  void     (* over_in)  (ClutterDropAction *action,
+                         ClutterActor      *actor);
+  void     (* over_out) (ClutterDropAction *action,
+                         ClutterActor      *actor);
+
+  void     (* drop)     (ClutterDropAction *action,
+                         ClutterActor      *actor,
+                         gfloat             event_x,
+                         gfloat             event_y);
+
+  /*< private >*/
+  void (*_clutter_drop_action1) (void);
+  void (*_clutter_drop_action2) (void);
+  void (*_clutter_drop_action3) (void);
+  void (*_clutter_drop_action4) (void);
+  void (*_clutter_drop_action5) (void);
+  void (*_clutter_drop_action6) (void);
+  void (*_clutter_drop_action7) (void);
+  void (*_clutter_drop_action8) (void);
+};
+
+CLUTTER_EXPORT
+GType clutter_drop_action_get_type (void) G_GNUC_CONST;
+
+CLUTTER_EXPORT
+ClutterAction *         clutter_drop_action_new         (void);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_DROP_ACTION_H__ */
--- a/clutter/clutter/clutter-effect.c
+++ b/clutter/clutter/clutter-effect.c
@@ -230,26 +230,28 @@ clutter_effect_real_pick (ClutterEffect      *effect,
 }

 static void
-clutter_effect_set_enabled (ClutterActorMeta *meta,
-                            gboolean          is_enabled)
+clutter_effect_notify (GObject    *gobject,
+                       GParamSpec *pspec)
 {
-  ClutterActorMetaClass *parent_class =
-    CLUTTER_ACTOR_META_CLASS (clutter_effect_parent_class);
-  ClutterActor *actor;
+  if (strcmp (pspec->name, "enabled") == 0)
+    {
+      ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject);
+      ClutterActor *actor = clutter_actor_meta_get_actor (meta);

-  actor = clutter_actor_meta_get_actor (meta);
-  if (actor)
-    clutter_actor_queue_redraw (actor);
+      if (actor != NULL)
+        clutter_actor_queue_redraw (actor);
+    }

-  parent_class->set_enabled (meta, is_enabled);
+  if (G_OBJECT_CLASS (clutter_effect_parent_class)->notify != NULL)
+    G_OBJECT_CLASS (clutter_effect_parent_class)->notify (gobject, pspec);
 }

 static void
 clutter_effect_class_init (ClutterEffectClass *klass)
 {
-  ClutterActorMetaClass *actor_meta_class = CLUTTER_ACTOR_META_CLASS (klass);
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

-  actor_meta_class->set_enabled = clutter_effect_set_enabled;
+  gobject_class->notify = clutter_effect_notify;

  klass->pre_paint = clutter_effect_real_pre_paint;
  klass->post_paint = clutter_effect_real_post_paint;
--- a/clutter/clutter/clutter-enums.h
+++ b/clutter/clutter/clutter-enums.h
@@ -190,7 +190,7 @@ typedef enum /*< prefix=CLUTTER_REQUEST >*/
 * @CLUTTER_ANIMATION_LAST: last animation mode, used as a guard for
 *   registered global alpha functions
 *
- * The animation modes used by #ClutterAnimatable. This
+ * The animation modes used by #ClutterAlpha and #ClutterAnimation. This
 * enumeration can be expanded in later versions of Clutter.
 *
 * <figure id="easing-modes">
@@ -387,6 +387,44 @@ typedef enum
  CLUTTER_MODIFIER_MASK = 0x5c001fff
 } ClutterModifierType;

+/**
+ * ClutterKeyboardA11yFlags:
+ * @CLUTTER_A11Y_KEYBOARD_ENABLED:
+ * @CLUTTER_A11Y_TIMEOUT_ENABLED:
+ * @CLUTTER_A11Y_MOUSE_KEYS_ENABLED:
+ * @CLUTTER_A11Y_SLOW_KEYS_ENABLED:
+ * @CLUTTER_A11Y_SLOW_KEYS_BEEP_PRESS:
+ * @CLUTTER_A11Y_SLOW_KEYS_BEEP_ACCEPT:
+ * @CLUTTER_A11Y_SLOW_KEYS_BEEP_REJECT:
+ * @CLUTTER_A11Y_BOUNCE_KEYS_ENABLED:
+ * @CLUTTER_A11Y_BOUNCE_KEYS_BEEP_REJECT:
+ * @CLUTTER_A11Y_TOGGLE_KEYS_ENABLED:
+ * @CLUTTER_A11Y_STICKY_KEYS_ENABLED:
+ * @CLUTTER_A11Y_STICKY_KEYS_TWO_KEY_OFF:
+ * @CLUTTER_A11Y_STICKY_KEYS_BEEP:
+ * @CLUTTER_A11Y_FEATURE_STATE_CHANGE_BEEP:
+ *
+ * Keyboard accessibility features applied to a ClutterInputDevice keyboard.
+ *
+ */
+typedef enum
+{
+  CLUTTER_A11Y_KEYBOARD_ENABLED          = 1 << 0,
+  CLUTTER_A11Y_TIMEOUT_ENABLED           = 1 << 1,
+  CLUTTER_A11Y_MOUSE_KEYS_ENABLED        = 1 << 2,
+  CLUTTER_A11Y_SLOW_KEYS_ENABLED         = 1 << 3,
+  CLUTTER_A11Y_SLOW_KEYS_BEEP_PRESS      = 1 << 4,
+  CLUTTER_A11Y_SLOW_KEYS_BEEP_ACCEPT     = 1 << 5,
+  CLUTTER_A11Y_SLOW_KEYS_BEEP_REJECT     = 1 << 6,
+  CLUTTER_A11Y_BOUNCE_KEYS_ENABLED       = 1 << 7,
+  CLUTTER_A11Y_BOUNCE_KEYS_BEEP_REJECT   = 1 << 8,
+  CLUTTER_A11Y_TOGGLE_KEYS_ENABLED       = 1 << 9,
+  CLUTTER_A11Y_STICKY_KEYS_ENABLED       = 1 << 10,
+  CLUTTER_A11Y_STICKY_KEYS_TWO_KEY_OFF   = 1 << 11,
+  CLUTTER_A11Y_STICKY_KEYS_BEEP          = 1 << 12,
+  CLUTTER_A11Y_FEATURE_STATE_CHANGE_BEEP = 1 << 13,
+} ClutterKeyboardA11yFlags;
+
 /**
 * ClutterPointerA11yFlags:
 * @CLUTTER_A11Y_POINTER_ENABLED:
@@ -516,6 +554,32 @@ typedef enum /*< prefix=CLUTTER_OFFSCREEN_REDIRECT >*/
  CLUTTER_OFFSCREEN_REDIRECT_ON_IDLE               = 1 << 2
 } ClutterOffscreenRedirect;

+/**
+ * ClutterAllocationFlags:
+ * @CLUTTER_ALLOCATION_NONE: No flag set
+ * @CLUTTER_ABSOLUTE_ORIGIN_CHANGED: Whether the absolute origin of the
+ *   actor has changed; this implies that any ancestor of the actor has
+ *   been moved.
+ * @CLUTTER_DELEGATE_LAYOUT: Whether the allocation should be delegated
+ *   to the #ClutterLayoutManager instance stored inside the
+ *   #ClutterActor:layout-manager property of #ClutterActor. This flag
+ *   should only be used if you are subclassing #ClutterActor and
+ *   overriding the #ClutterActorClass.allocate() virtual function, but
+ *   you wish to use the default implementation of the virtual function
+ *   inside #ClutterActor. Added in Clutter 1.10.
+ *
+ * Flags passed to the #ClutterActorClass.allocate() virtual function
+ * and to the clutter_actor_allocate() function.
+ *
+ * Since: 1.0
+ */
+typedef enum
+{
+  CLUTTER_ALLOCATION_NONE         = 0,
+  CLUTTER_ABSOLUTE_ORIGIN_CHANGED = 1 << 1,
+  CLUTTER_DELEGATE_LAYOUT         = 1 << 2
+} ClutterAllocationFlags;
+
 /**
 * ClutterAlignAxis:
 * @CLUTTER_ALIGN_X_AXIS: Maintain the alignment on the X axis
@@ -819,6 +883,7 @@ typedef enum /*< flags prefix=CLUTTER_EVENT >*/
 * @CLUTTER_STAGE_STATE: Stage state change event
 * @CLUTTER_DESTROY_NOTIFY: Destroy notification event
 * @CLUTTER_CLIENT_MESSAGE: Client message event
+ * @CLUTTER_DELETE: Stage delete event
 * @CLUTTER_TOUCH_BEGIN: A new touch event sequence has started;
 *   event added in 1.10
 * @CLUTTER_TOUCH_UPDATE: A touch event sequence has been updated;
@@ -856,6 +921,7 @@ typedef enum /*< prefix=CLUTTER >*/
  CLUTTER_STAGE_STATE,
  CLUTTER_DESTROY_NOTIFY,
  CLUTTER_CLIENT_MESSAGE,
+  CLUTTER_DELETE,
  CLUTTER_TOUCH_BEGIN,
  CLUTTER_TOUCH_UPDATE,
  CLUTTER_TOUCH_END,
@@ -868,8 +934,6 @@ typedef enum /*< prefix=CLUTTER >*/
  CLUTTER_PAD_BUTTON_RELEASE,
  CLUTTER_PAD_STRIP,
  CLUTTER_PAD_RING,
-  CLUTTER_DEVICE_ADDED,
-  CLUTTER_DEVICE_REMOVED,

  CLUTTER_EVENT_LAST            /* helper */
 } ClutterEventType;
@@ -913,6 +977,7 @@ typedef enum

 /**
 * ClutterFeatureFlags:
+ * @CLUTTER_FEATURE_SWAP_THROTTLE: Set if backend throttles buffer swaps.
 * @CLUTTER_FEATURE_STAGE_STATIC: Set if stage size if fixed (i.e framebuffer)
 * @CLUTTER_FEATURE_STAGE_CURSOR: Set if stage has a graphical cursor.
 * @CLUTTER_FEATURE_SHADERS_GLSL: Set if the backend supports GLSL shaders.
@@ -927,6 +992,7 @@ typedef enum
 */
 typedef enum
 {
+  CLUTTER_FEATURE_SWAP_THROTTLE          = (1 << 3),
  CLUTTER_FEATURE_STAGE_STATIC           = (1 << 6),
  CLUTTER_FEATURE_STAGE_CURSOR           = (1 << 8),
  CLUTTER_FEATURE_SHADERS_GLSL           = (1 << 9),
@@ -1277,6 +1343,8 @@ typedef enum
 *   painting the stages
 * @CLUTTER_REPAINT_FLAGS_POST_PAINT: Run the repaint function after
 *   painting the stages
+ * @CLUTTER_REPAINT_FLAGS_QUEUE_REDRAW_ON_ADD: Ensure that a new frame
+ *   is queued after adding the repaint function
 *
 * Flags to pass to clutter_threads_add_repaint_func_full().
 *
@@ -1286,6 +1354,7 @@ typedef enum
 {
  CLUTTER_REPAINT_FLAGS_PRE_PAINT = 1 << 0,
  CLUTTER_REPAINT_FLAGS_POST_PAINT = 1 << 1,
+  CLUTTER_REPAINT_FLAGS_QUEUE_REDRAW_ON_ADD = 1 << 2
 } ClutterRepaintFlags;

 /**
@@ -1594,6 +1663,12 @@ typedef enum
  CLUTTER_INPUT_DEVICE_PAD_SOURCE_FINGER,
 } ClutterInputDevicePadSource;

+typedef enum
+{
+  CLUTTER_INPUT_DEVICE_MAPPING_ABSOLUTE,
+  CLUTTER_INPUT_DEVICE_MAPPING_RELATIVE,
+} ClutterInputDeviceMapping;
+
 typedef enum
 {
  CLUTTER_INPUT_CONTENT_HINT_COMPLETION          = 1 << 0,
--- a/clutter/clutter/clutter-event.c
+++ b/clutter/clutter/clutter-event.c
@@ -407,6 +407,7 @@ clutter_event_get_position (const ClutterEvent *event,
    case CLUTTER_STAGE_STATE:
    case CLUTTER_DESTROY_NOTIFY:
    case CLUTTER_CLIENT_MESSAGE:
+    case CLUTTER_DELETE:
    case CLUTTER_EVENT_LAST:
    case CLUTTER_PROXIMITY_IN:
    case CLUTTER_PROXIMITY_OUT:
@@ -414,8 +415,6 @@ clutter_event_get_position (const ClutterEvent *event,
    case CLUTTER_PAD_BUTTON_RELEASE:
    case CLUTTER_PAD_STRIP:
    case CLUTTER_PAD_RING:
-    case CLUTTER_DEVICE_ADDED:
-    case CLUTTER_DEVICE_REMOVED:
      graphene_point_init (position, 0.f, 0.f);
      break;

@@ -482,6 +481,7 @@ clutter_event_set_coords (ClutterEvent *event,
    case CLUTTER_STAGE_STATE:
    case CLUTTER_DESTROY_NOTIFY:
    case CLUTTER_CLIENT_MESSAGE:
+    case CLUTTER_DELETE:
    case CLUTTER_EVENT_LAST:
    case CLUTTER_PROXIMITY_IN:
    case CLUTTER_PROXIMITY_OUT:
@@ -489,8 +489,6 @@ clutter_event_set_coords (ClutterEvent *event,
    case CLUTTER_PAD_BUTTON_RELEASE:
    case CLUTTER_PAD_STRIP:
    case CLUTTER_PAD_RING:
-    case CLUTTER_DEVICE_ADDED:
-    case CLUTTER_DEVICE_REMOVED:
      break;

    case CLUTTER_ENTER:
@@ -1107,6 +1105,7 @@ clutter_event_set_device (ClutterEvent       *event,
    case CLUTTER_STAGE_STATE:
    case CLUTTER_DESTROY_NOTIFY:
    case CLUTTER_CLIENT_MESSAGE:
+    case CLUTTER_DELETE:
    case CLUTTER_EVENT_LAST:
      break;

@@ -1162,11 +1161,6 @@ clutter_event_set_device (ClutterEvent       *event,
    case CLUTTER_PAD_RING:
      event->pad_ring.device = device;
      break;
-
-    case CLUTTER_DEVICE_ADDED:
-    case CLUTTER_DEVICE_REMOVED:
-      event->device.device = device;
-      break;
    }
 }

@@ -1208,6 +1202,7 @@ clutter_event_get_device (const ClutterEvent *event)
    case CLUTTER_STAGE_STATE:
    case CLUTTER_DESTROY_NOTIFY:
    case CLUTTER_CLIENT_MESSAGE:
+    case CLUTTER_DELETE:
    case CLUTTER_EVENT_LAST:
      break;

@@ -1263,11 +1258,6 @@ clutter_event_get_device (const ClutterEvent *event)
    case CLUTTER_PAD_RING:
      device = event->pad_ring.device;
      break;
-
-    case CLUTTER_DEVICE_ADDED:
-    case CLUTTER_DEVICE_REMOVED:
-      device = event->device.device;
-      break;
    }

  return device;
@@ -1421,8 +1411,6 @@ clutter_event_copy (const ClutterEvent *event)
                                          sizeof (gdouble) * n_axes);
      break;

-    case CLUTTER_DEVICE_ADDED:
-    case CLUTTER_DEVICE_REMOVED:
    default:
      break;
    }
@@ -1477,9 +1465,6 @@ clutter_event_free (ClutterEvent *event)
        case CLUTTER_TOUCH_CANCEL:
          g_free (event->touch.axes);
          break;
-        case CLUTTER_DEVICE_ADDED:
-        case CLUTTER_DEVICE_REMOVED:
-          break;

        default:
          break;
@@ -1504,17 +1489,40 @@ ClutterEvent *
 clutter_event_get (void)
 {
  ClutterMainContext *context = _clutter_context_get_default ();
-  ClutterEvent *event;

-  event = g_async_queue_try_pop (context->events_queue);
+  if (context->events_queue == NULL)
+    return NULL;

-  return event;
+  if (g_queue_is_empty (context->events_queue))
+    return NULL;
+
+  return g_queue_pop_tail (context->events_queue);
 }

-static gboolean
-spin_context (gpointer data)
+/**
+ * clutter_event_peek:
+ * 
+ * Returns a pointer to the first event from the event queue but 
+ * does not remove it. 
+ *
+ * Return value: (transfer none): A #ClutterEvent or NULL if queue empty.
+ *
+ * Since: 0.4
+ */
+ClutterEvent *
+clutter_event_peek (void)
 {
-  return G_SOURCE_REMOVE;
+  ClutterMainContext *context = _clutter_context_get_default ();
+
+  g_return_val_if_fail (context != NULL, NULL);
+  
+  if (context->events_queue == NULL)
+    return NULL;
+
+  if (g_queue_is_empty (context->events_queue))
+    return NULL;
+
+  return g_queue_peek_tail (context->events_queue);
 }

 void
@@ -1522,9 +1530,21 @@ _clutter_event_push (const ClutterEvent *event,
                     gboolean            do_copy)
 {
  ClutterMainContext *context = _clutter_context_get_default ();
+  ClutterInputDevice *device;

  g_assert (context != NULL);

+  if (context->events_queue == NULL)
+    context->events_queue = g_queue_new ();
+
+  /* disabled devices don't propagate events */
+  device = clutter_event_get_device (event);
+  if (device != NULL)
+    {
+      if (!clutter_input_device_get_enabled (device))
+        return;
+    }
+
  if (do_copy)
    {
      ClutterEvent *copy;
@@ -1533,8 +1553,7 @@ _clutter_event_push (const ClutterEvent *event,
      event = copy;
    }

-  g_async_queue_push (context->events_queue, (gpointer) event);
-  g_idle_add (spin_context, NULL);
+  g_queue_push_head (context->events_queue, (gpointer) event);
 }

 /**
@@ -1571,7 +1590,10 @@ clutter_events_pending (void)

  g_return_val_if_fail (context != NULL, FALSE);

-  return g_async_queue_length (context->events_queue) > 0;
+  if (context->events_queue == NULL)
+    return FALSE;
+
+  return g_queue_is_empty (context->events_queue) == FALSE;
 }

 /**
@@ -1703,6 +1725,7 @@ clutter_event_get_axes (const ClutterEvent *event,
    case CLUTTER_STAGE_STATE:
    case CLUTTER_DESTROY_NOTIFY:
    case CLUTTER_CLIENT_MESSAGE:
+    case CLUTTER_DELETE:
    case CLUTTER_ENTER:
    case CLUTTER_LEAVE:
    case CLUTTER_KEY_PRESS:
@@ -1710,8 +1733,6 @@ clutter_event_get_axes (const ClutterEvent *event,
    case CLUTTER_EVENT_LAST:
    case CLUTTER_PROXIMITY_IN:
    case CLUTTER_PROXIMITY_OUT:
-    case CLUTTER_DEVICE_ADDED:
-    case CLUTTER_DEVICE_REMOVED:
      break;

    case CLUTTER_SCROLL:
--- a/clutter/clutter/clutter-event.h
+++ b/clutter/clutter/clutter-event.h
@@ -121,7 +121,6 @@ typedef struct _ClutterProximityEvent   ClutterProximityEvent;
 typedef struct _ClutterPadButtonEvent   ClutterPadButtonEvent;
 typedef struct _ClutterPadStripEvent    ClutterPadStripEvent;
 typedef struct _ClutterPadRingEvent     ClutterPadRingEvent;
-typedef struct _ClutterDeviceEvent      ClutterDeviceEvent;

 /**
 * ClutterAnyEvent:
@@ -545,17 +544,6 @@ struct _ClutterPadRingEvent
  guint32 mode;
 };

-struct _ClutterDeviceEvent
-{
-  ClutterEventType type;
-  guint32 time;
-  ClutterEventFlags flags;
-  ClutterStage *stage;
-  ClutterActor *source;
-
-  ClutterInputDevice *device;
-};
-
 /**
 * ClutterEvent:
 *
@@ -582,7 +570,6 @@ union _ClutterEvent
  ClutterPadButtonEvent pad_button;
  ClutterPadStripEvent pad_strip;
  ClutterPadRingEvent pad_ring;
-  ClutterDeviceEvent device;
 };

 /**
@@ -614,6 +601,8 @@ gboolean                clutter_events_pending                  (void);
 CLUTTER_EXPORT
 ClutterEvent *          clutter_event_get                       (void);
 CLUTTER_EXPORT
+ClutterEvent *          clutter_event_peek                      (void);
+CLUTTER_EXPORT
 void                    clutter_event_put                       (const ClutterEvent     *event);

 CLUTTER_EXPORT
--- a/clutter/clutter/clutter-fixed-layout.c
+++ b/clutter/clutter/clutter-fixed-layout.c
@@ -131,7 +131,8 @@ clutter_fixed_layout_get_preferred_height (ClutterLayoutManager *manager,
 static void
 clutter_fixed_layout_allocate (ClutterLayoutManager   *manager,
                               ClutterContainer       *container,
-                               const ClutterActorBox  *allocation)
+                               const ClutterActorBox  *allocation,
+                               ClutterAllocationFlags  flags)
 {
  ClutterActor *child;

@@ -139,11 +140,7 @@ clutter_fixed_layout_allocate (ClutterLayoutManager   *manager,
       child != NULL;
       child = clutter_actor_get_next_sibling (child))
    {
-      float x = 0.f;
-      float y = 0.f;
-
-      clutter_actor_get_fixed_position (child, &x, &y);
-      clutter_actor_allocate_preferred_size (child, x, y);
+      clutter_actor_allocate_preferred_size (child, flags);
    }
 }

--- a/clutter/clutter/clutter-flow-layout.c
+++ b/clutter/clutter/clutter-flow-layout.c
@@ -566,7 +566,8 @@ clutter_flow_layout_get_preferred_height (ClutterLayoutManager *manager,
 static void
 clutter_flow_layout_allocate (ClutterLayoutManager   *manager,
                              ClutterContainer       *container,
-                              const ClutterActorBox  *allocation)
+                              const ClutterActorBox  *allocation,
+                              ClutterAllocationFlags  flags)
 {
  ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (manager)->priv;
  ClutterActor *actor, *child;
@@ -728,7 +729,7 @@ clutter_flow_layout_allocate (ClutterLayoutManager   *manager,
      child_alloc.y1 = ceil (item_y);
      child_alloc.x2 = ceil (child_alloc.x1 + item_width);
      child_alloc.y2 = ceil (child_alloc.y1 + item_height);
-      clutter_actor_allocate (child, &child_alloc);
+      clutter_actor_allocate (child, &child_alloc, flags);

      if (priv->orientation == CLUTTER_FLOW_HORIZONTAL)
        item_x = new_x;
--- a/clutter/clutter/clutter-frame-clock.c
+++ b/clutter/clutter/clutter-frame-clock.c
@@ -1,550 +0,0 @@
-/*
- * 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/>.
- */
-
-#include "clutter-build-config.h"
-
-#include "clutter/clutter-frame-clock.h"
-
-#include "clutter/clutter-main.h"
-#include "clutter/clutter-private.h"
-#include "clutter/clutter-timeline-private.h"
-#include "cogl/cogl-trace.h"
-
-enum
-{
-  DESTROY,
-
-  N_SIGNALS
-};
-
-static guint signals[N_SIGNALS];
-
-/* Wait 2ms after vblank before starting to draw next frame */
-#define SYNC_DELAY_US ms2us (2)
-
-typedef struct _ClutterFrameListener
-{
-  const ClutterFrameListenerIface *iface;
-  gpointer user_data;
-} ClutterFrameListener;
-
-typedef struct _ClutterClockSource
-{
-  GSource source;
-
-  ClutterFrameClock *frame_clock;
-} ClutterClockSource;
-
-typedef enum _ClutterFrameClockState
-{
-  CLUTTER_FRAME_CLOCK_STATE_INIT,
-  CLUTTER_FRAME_CLOCK_STATE_IDLE,
-  CLUTTER_FRAME_CLOCK_STATE_SCHEDULED,
-  CLUTTER_FRAME_CLOCK_STATE_DISPATCHING,
-  CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED,
-} ClutterFrameClockState;
-
-struct _ClutterFrameClock
-{
-  GObject parent;
-
-  float refresh_rate;
-  ClutterFrameListener listener;
-
-  GSource *source;
-
-  int64_t frame_count;
-
-  ClutterFrameClockState state;
-  int64_t last_presentation_time_us;
-
-  gboolean is_next_presentation_time_valid;
-  int64_t next_presentation_time_us;
-
-  gboolean pending_reschedule;
-  gboolean pending_reschedule_now;
-
-  int inhibit_count;
-
-  GList *timelines;
-};
-
-G_DEFINE_TYPE (ClutterFrameClock, clutter_frame_clock,
-               G_TYPE_OBJECT)
-
-float
-clutter_frame_clock_get_refresh_rate (ClutterFrameClock *frame_clock)
-{
-  return frame_clock->refresh_rate;
-}
-
-void
-clutter_frame_clock_add_timeline (ClutterFrameClock *frame_clock,
-                                  ClutterTimeline   *timeline)
-{
-  gboolean is_first;
-
-  if (g_list_find (frame_clock->timelines, timeline))
-    return;
-
-  is_first = !frame_clock->timelines;
-
-  frame_clock->timelines = g_list_prepend (frame_clock->timelines, timeline);
-
-  if (is_first)
-    clutter_frame_clock_schedule_update (frame_clock);
-}
-
-void
-clutter_frame_clock_remove_timeline (ClutterFrameClock *frame_clock,
-                                     ClutterTimeline   *timeline)
-{
-  frame_clock->timelines = g_list_remove (frame_clock->timelines, timeline);
-}
-
-static void
-advance_timelines (ClutterFrameClock *frame_clock,
-                   int64_t            time_us)
-{
-  GList *timelines;
-  GList *l;
-
-  /* we protect ourselves from timelines being removed during
-   * the advancement by other timelines by copying the list of
-   * timelines, taking a reference on them, iterating over the
-   * copied list and then releasing the reference.
-   *
-   * we cannot simply take a reference on the timelines and still
-   * use the list held by the master clock because the do_tick()
-   * might result in the creation of a new timeline, which gets
-   * added at the end of the list with no reference increase and
-   * thus gets disposed at the end of the iteration.
-   *
-   * this implies that a newly added timeline will not be advanced
-   * by this clock iteration, which is perfectly fine since we're
-   * in its first cycle.
-   *
-   * we also cannot steal the frame clock timelines list because
-   * a timeline might be removed as the direct result of do_tick()
-   * and remove_timeline() would not find the timeline, failing
-   * and leaving a dangling pointer behind.
-   */
-
-  timelines = g_list_copy (frame_clock->timelines);
-  g_list_foreach (timelines, (GFunc) g_object_ref, NULL);
-
-  for (l = timelines; l; l = l->next)
-    {
-      ClutterTimeline *timeline = l->data;
-
-      _clutter_timeline_do_tick (timeline, time_us / 1000);
-    }
-
-  g_list_free_full (timelines, g_object_unref);
-}
-
-static void
-maybe_reschedule_update (ClutterFrameClock *frame_clock)
-{
-  if (frame_clock->pending_reschedule ||
-      frame_clock->timelines)
-    {
-      frame_clock->pending_reschedule = FALSE;
-
-      if (frame_clock->pending_reschedule_now)
-        {
-          frame_clock->pending_reschedule_now = FALSE;
-          clutter_frame_clock_schedule_update_now (frame_clock);
-        }
-      else
-        {
-          clutter_frame_clock_schedule_update (frame_clock);
-        }
-    }
-}
-
-void
-clutter_frame_clock_notify_presented (ClutterFrameClock *frame_clock,
-                                      ClutterFrameInfo  *frame_info)
-{
-  int64_t presentation_time_us = frame_info->presentation_time;
-
-  if (presentation_time_us > frame_clock->last_presentation_time_us ||
-      ((presentation_time_us - frame_clock->last_presentation_time_us) >
-       INT64_MAX / 2))
-    {
-      frame_clock->last_presentation_time_us = presentation_time_us;
-    }
-  else
-    {
-      g_warning_once ("Bogus presentation time %" G_GINT64_FORMAT
-                      " travelled back in time, using current time.",
-                      presentation_time_us);
-      frame_clock->last_presentation_time_us = g_get_monotonic_time ();
-    }
-
-  switch (frame_clock->state)
-    {
-    case CLUTTER_FRAME_CLOCK_STATE_INIT:
-    case CLUTTER_FRAME_CLOCK_STATE_IDLE:
-    case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
-      g_warn_if_reached ();
-      break;
-    case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
-    case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
-      frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_IDLE;
-      maybe_reschedule_update (frame_clock);
-      break;
-    }
-}
-
-static void
-calculate_next_update_time_us (ClutterFrameClock *frame_clock,
-                               int64_t           *out_next_update_time_us,
-                               int64_t           *out_next_presentation_time_us)
-{
-  int64_t last_presentation_time_us;
-  int64_t now_us;
-  float refresh_rate;
-  int64_t refresh_interval_us;
-  int64_t min_render_time_allowed_us;
-  int64_t max_render_time_allowed_us;
-  int64_t last_next_presentation_time_us;
-  int64_t time_since_last_next_presentation_time_us;
-  int64_t next_presentation_time_us;
-  int64_t next_update_time_us;
-
-  now_us = g_get_monotonic_time ();
-
-  refresh_rate = frame_clock->refresh_rate;
-  refresh_interval_us = (int64_t) (0.5 + G_USEC_PER_SEC / refresh_rate);
-
-  min_render_time_allowed_us = refresh_interval_us / 2;
-  max_render_time_allowed_us = refresh_interval_us - SYNC_DELAY_US;
-
-  if (min_render_time_allowed_us > max_render_time_allowed_us)
-    min_render_time_allowed_us = max_render_time_allowed_us;
-
-  last_presentation_time_us = frame_clock->last_presentation_time_us;
-  next_presentation_time_us = last_presentation_time_us + refresh_interval_us;
-
-  /* Skip ahead to get close to the actual next presentation time. */
-  if (next_presentation_time_us < now_us)
-    {
-      int64_t logical_clock_offset_us;
-      int64_t logical_clock_phase_us;
-      int64_t hw_clock_offset_us;
-
-      logical_clock_offset_us = now_us % refresh_interval_us;
-      logical_clock_phase_us = now_us - logical_clock_offset_us;
-      hw_clock_offset_us = last_presentation_time_us % refresh_interval_us;
-
-      next_presentation_time_us = logical_clock_phase_us + hw_clock_offset_us;
-    }
-
-  /* Skip one interval if we got an early presented event. */
-  last_next_presentation_time_us = frame_clock->next_presentation_time_us;
-  time_since_last_next_presentation_time_us =
-      next_presentation_time_us - last_next_presentation_time_us;
-  if (frame_clock->is_next_presentation_time_valid &&
-      time_since_last_next_presentation_time_us < (refresh_interval_us / 2))
-    {
-      next_presentation_time_us =
-        frame_clock->next_presentation_time_us + refresh_interval_us;
-    }
-
-  while (next_presentation_time_us < now_us + min_render_time_allowed_us)
-    next_presentation_time_us += refresh_interval_us;
-
-  next_update_time_us = next_presentation_time_us - max_render_time_allowed_us;
-
-  *out_next_update_time_us = next_update_time_us;
-  *out_next_presentation_time_us = next_presentation_time_us;
-}
-
-void
-clutter_frame_clock_inhibit (ClutterFrameClock *frame_clock)
-{
-  frame_clock->inhibit_count++;
-
-  if (frame_clock->inhibit_count == 1)
-    {
-      switch (frame_clock->state)
-        {
-        case CLUTTER_FRAME_CLOCK_STATE_INIT:
-        case CLUTTER_FRAME_CLOCK_STATE_IDLE:
-          break;
-        case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
-          frame_clock->pending_reschedule = TRUE;
-          frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_IDLE;
-          break;
-        case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
-        case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
-          break;
-        }
-
-      g_source_set_ready_time (frame_clock->source, -1);
-    }
-}
-
-void
-clutter_frame_clock_uninhibit (ClutterFrameClock *frame_clock)
-{
-  g_return_if_fail (frame_clock->inhibit_count > 0);
-
-  frame_clock->inhibit_count--;
-
-  if (frame_clock->inhibit_count == 0)
-    maybe_reschedule_update (frame_clock);
-}
-
-void
-clutter_frame_clock_schedule_update_now (ClutterFrameClock *frame_clock)
-{
-  int64_t next_update_time_us = -1;
-
-  if (frame_clock->inhibit_count > 0)
-    {
-      frame_clock->pending_reschedule = TRUE;
-      frame_clock->pending_reschedule_now = TRUE;
-      return;
-    }
-
-  switch (frame_clock->state)
-    {
-    case CLUTTER_FRAME_CLOCK_STATE_INIT:
-    case CLUTTER_FRAME_CLOCK_STATE_IDLE:
-      next_update_time_us = g_get_monotonic_time ();
-      break;
-    case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
-      return;
-    case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
-    case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
-      frame_clock->pending_reschedule = TRUE;
-      frame_clock->pending_reschedule_now = TRUE;
-      return;
-    }
-
-  g_warn_if_fail (next_update_time_us != -1);
-
-  g_source_set_ready_time (frame_clock->source, next_update_time_us);
-  frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_SCHEDULED;
-  frame_clock->is_next_presentation_time_valid = FALSE;
-}
-
-void
-clutter_frame_clock_schedule_update (ClutterFrameClock *frame_clock)
-{
-  int64_t next_update_time_us = -1;
-
-  if (frame_clock->inhibit_count > 0)
-    {
-      frame_clock->pending_reschedule = TRUE;
-      return;
-    }
-
-  switch (frame_clock->state)
-    {
-    case CLUTTER_FRAME_CLOCK_STATE_INIT:
-      next_update_time_us = g_get_monotonic_time ();
-      break;
-    case CLUTTER_FRAME_CLOCK_STATE_IDLE:
-      calculate_next_update_time_us (frame_clock,
-                                     &next_update_time_us,
-                                     &frame_clock->next_presentation_time_us);
-      frame_clock->is_next_presentation_time_valid = TRUE;
-      break;
-    case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
-      return;
-    case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
-    case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
-      frame_clock->pending_reschedule = TRUE;
-      return;
-    }
-
-  g_warn_if_fail (next_update_time_us != -1);
-
-  g_source_set_ready_time (frame_clock->source, next_update_time_us);
-  frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_SCHEDULED;
-}
-
-static void
-clutter_frame_clock_dispatch (ClutterFrameClock *frame_clock,
-                              int64_t            time_us)
-{
-  int64_t frame_count;
-  ClutterFrameResult result;
-
-  COGL_TRACE_BEGIN_SCOPED (ClutterFrameCLockDispatch, "Frame Clock (dispatch)");
-
-  g_source_set_ready_time (frame_clock->source, -1);
-
-  frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_DISPATCHING;
-
-  frame_count = frame_clock->frame_count++;
-
-  COGL_TRACE_BEGIN (ClutterFrameClockEvents, "Frame Clock (before frame)");
-  if (frame_clock->listener.iface->before_frame)
-    {
-      frame_clock->listener.iface->before_frame (frame_clock,
-                                                 frame_count,
-                                                 frame_clock->listener.user_data);
-    }
-  COGL_TRACE_END (ClutterFrameClockEvents);
-
-  COGL_TRACE_BEGIN (ClutterFrameClockTimelines, "Frame Clock (timelines)");
-  advance_timelines (frame_clock, time_us);
-  COGL_TRACE_END (ClutterFrameClockTimelines);
-
-  COGL_TRACE_BEGIN (ClutterFrameClockFrame, "Frame Clock (frame)");
-  result = frame_clock->listener.iface->frame (frame_clock,
-                                               frame_count,
-                                               time_us,
-                                               frame_clock->listener.user_data);
-  COGL_TRACE_END (ClutterFrameClockFrame);
-
-  switch (frame_clock->state)
-    {
-    case CLUTTER_FRAME_CLOCK_STATE_INIT:
-    case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
-      g_warn_if_reached ();
-      break;
-    case CLUTTER_FRAME_CLOCK_STATE_IDLE:
-    case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
-      break;
-    case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
-      switch (result)
-        {
-        case CLUTTER_FRAME_RESULT_PENDING_PRESENTED:
-          frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED;
-          break;
-        case CLUTTER_FRAME_RESULT_IDLE:
-          frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_IDLE;
-          maybe_reschedule_update (frame_clock);
-          break;
-        }
-      break;
-    }
-}
-
-static gboolean
-frame_clock_source_dispatch (GSource     *source,
-                             GSourceFunc  callback,
-                             gpointer     user_data)
-{
-  ClutterClockSource *clock_source = (ClutterClockSource *) source;
-  ClutterFrameClock *frame_clock = clock_source->frame_clock;
-  int64_t dispatch_time_us;
-
-  dispatch_time_us = g_source_get_time (source);
-  clutter_frame_clock_dispatch (frame_clock, dispatch_time_us);
-
-  return G_SOURCE_CONTINUE;
-}
-
-static GSourceFuncs frame_clock_source_funcs = {
-  NULL,
-  NULL,
-  frame_clock_source_dispatch,
-  NULL
-};
-
-static void
-init_frame_clock_source (ClutterFrameClock *frame_clock)
-{
-  GSource *source;
-  ClutterClockSource *clock_source;
-  g_autofree char *name = NULL;
-
-  source = g_source_new (&frame_clock_source_funcs, sizeof (ClutterClockSource));
-  clock_source = (ClutterClockSource *) source;
-
-  name = g_strdup_printf ("Clutter frame clock (%p)", frame_clock);
-  g_source_set_name (source, name);
-  g_source_set_priority (source, CLUTTER_PRIORITY_REDRAW);
-  g_source_set_can_recurse (source, FALSE);
-  clock_source->frame_clock = frame_clock;
-
-  frame_clock->source = source;
-  g_source_attach (source, NULL);
-}
-
-ClutterFrameClock *
-clutter_frame_clock_new (float                            refresh_rate,
-                         const ClutterFrameListenerIface *iface,
-                         gpointer                         user_data)
-{
-  ClutterFrameClock *frame_clock;
-
-  g_assert_cmpfloat (refresh_rate, >, 0.0);
-
-  frame_clock = g_object_new (CLUTTER_TYPE_FRAME_CLOCK, NULL);
-
-  frame_clock->listener.iface = iface;
-  frame_clock->listener.user_data = user_data;
-
-  init_frame_clock_source (frame_clock);
-
-  frame_clock->refresh_rate = refresh_rate;
-
-  return frame_clock;
-}
-
-void
-clutter_frame_clock_destroy (ClutterFrameClock *frame_clock)
-{
-  g_object_run_dispose (G_OBJECT (frame_clock));
-  g_object_unref (frame_clock);
-}
-
-static void
-clutter_frame_clock_dispose (GObject *object)
-{
-  ClutterFrameClock *frame_clock = CLUTTER_FRAME_CLOCK (object);
-
-  if (frame_clock->source)
-    {
-      g_signal_emit (frame_clock, signals[DESTROY], 0);
-      g_source_destroy (frame_clock->source);
-      g_clear_pointer (&frame_clock->source, g_source_unref);
-    }
-
-  G_OBJECT_CLASS (clutter_frame_clock_parent_class)->dispose (object);
-}
-
-static void
-clutter_frame_clock_init (ClutterFrameClock *frame_clock)
-{
-  frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_INIT;
-}
-
-static void
-clutter_frame_clock_class_init (ClutterFrameClockClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->dispose = clutter_frame_clock_dispose;
-
-  signals[DESTROY] =
-    g_signal_new (I_("destroy"),
-                  G_TYPE_FROM_CLASS (object_class),
-                  G_SIGNAL_RUN_LAST,
-                  0,
-                  NULL, NULL, NULL,
-                  G_TYPE_NONE,
-                  0);
-}
--- a/clutter/clutter/clutter-frame-clock.h
+++ b/clutter/clutter/clutter-frame-clock.h
@@ -1,87 +0,0 @@
-/*
- * 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_FRAME_CLOCK_H
-#define CLUTTER_FRAME_CLOCK_H
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#include <glib.h>
-#include <glib-object.h>
-#include <stdint.h>
-
-#include "clutter/clutter-types.h"
-
-typedef enum _ClutterFrameResult
-{
-  CLUTTER_FRAME_RESULT_PENDING_PRESENTED,
-  CLUTTER_FRAME_RESULT_IDLE,
-} ClutterFrameResult;
-
-#define CLUTTER_TYPE_FRAME_CLOCK (clutter_frame_clock_get_type ())
-CLUTTER_EXPORT
-G_DECLARE_FINAL_TYPE (ClutterFrameClock, clutter_frame_clock,
-                      CLUTTER, FRAME_CLOCK,
-                      GObject)
-
-typedef struct _ClutterFrameListenerIface
-{
-  void (* before_frame) (ClutterFrameClock *frame_clock,
-                         int64_t            frame_count,
-                         gpointer           user_data);
-  ClutterFrameResult (* frame) (ClutterFrameClock *frame_clock,
-                                int64_t            frame_count,
-                                int64_t            time_us,
-                                gpointer           user_data);
-} ClutterFrameListenerIface;
-
-CLUTTER_EXPORT
-ClutterFrameClock * clutter_frame_clock_new (float                            refresh_rate,
-                                             const ClutterFrameListenerIface *iface,
-                                             gpointer                         user_data);
-
-CLUTTER_EXPORT
-void clutter_frame_clock_destroy (ClutterFrameClock *frame_clock);
-
-CLUTTER_EXPORT
-void clutter_frame_clock_notify_presented (ClutterFrameClock *frame_clock,
-                                           ClutterFrameInfo  *frame_info);
-
-CLUTTER_EXPORT
-void clutter_frame_clock_schedule_update (ClutterFrameClock *frame_clock);
-
-CLUTTER_EXPORT
-void clutter_frame_clock_schedule_update_now (ClutterFrameClock *frame_clock);
-
-CLUTTER_EXPORT
-void clutter_frame_clock_inhibit (ClutterFrameClock *frame_clock);
-
-CLUTTER_EXPORT
-void clutter_frame_clock_uninhibit (ClutterFrameClock *frame_clock);
-
-void clutter_frame_clock_add_timeline (ClutterFrameClock *frame_clock,
-                                       ClutterTimeline   *timeline);
-
-void clutter_frame_clock_remove_timeline (ClutterFrameClock *frame_clock,
-                                          ClutterTimeline   *timeline);
-
-CLUTTER_EXPORT
-float clutter_frame_clock_get_refresh_rate (ClutterFrameClock *frame_clock);
-
-#endif /* CLUTTER_FRAME_CLOCK_H */
--- a/clutter/clutter/clutter-gesture-action.c
+++ b/clutter/clutter/clutter-gesture-action.c
@@ -157,8 +157,7 @@ G_DEFINE_TYPE_WITH_PRIVATE (ClutterGestureAction, clutter_gesture_action, CLUTTE
 static GesturePoint *
 gesture_register_point (ClutterGestureAction *action, ClutterEvent *event)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (action);
+  ClutterGestureActionPrivate *priv = action->priv;
  GesturePoint *point = NULL;

  if (priv->points->len >= MAX_GESTURE_POINTS)
@@ -191,8 +190,7 @@ gesture_find_point (ClutterGestureAction *action,
                    ClutterEvent *event,
                    gint *position)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (action);
+  ClutterGestureActionPrivate *priv = action->priv;
  GesturePoint *point = NULL;
  ClutterEventType type = clutter_event_type (event);
  ClutterInputDevice *device = clutter_event_get_device (event);
@@ -222,10 +220,9 @@ gesture_find_point (ClutterGestureAction *action,
 static void
 gesture_unregister_point (ClutterGestureAction *action, gint position)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (action);
+  ClutterGestureActionPrivate *priv = action->priv;

-  if (priv->points->len == 0)
+  if (action->priv->points->len == 0)
    return;

  g_array_remove_index (priv->points, position);
@@ -306,8 +303,7 @@ gesture_point_unset (GesturePoint *point)
 static void
 cancel_gesture (ClutterGestureAction *action)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (action);
+  ClutterGestureActionPrivate *priv = action->priv;
  ClutterActor *actor;

  priv->in_gesture = FALSE;
@@ -317,15 +313,14 @@ cancel_gesture (ClutterGestureAction *action)
  actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (action));
  g_signal_emit (action, gesture_signals[GESTURE_CANCEL], 0, actor);

-  g_array_set_size (priv->points, 0);
+  g_array_set_size (action->priv->points, 0);
 }

 static gboolean
 begin_gesture (ClutterGestureAction *action,
               ClutterActor         *actor)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (action);
+  ClutterGestureActionPrivate *priv = action->priv;
  gboolean return_value;

  priv->in_gesture = TRUE;
@@ -358,8 +353,7 @@ stage_captured_event_cb (ClutterActor         *stage,
                         ClutterEvent         *event,
                         ClutterGestureAction *action)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (action);
+  ClutterGestureActionPrivate *priv = action->priv;
  ClutterActor *actor;
  gint position;
  float threshold_x, threshold_y;
@@ -494,8 +488,7 @@ actor_captured_event_cb (ClutterActor *actor,
                         ClutterEvent *event,
                         ClutterGestureAction *action)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (action);
+  ClutterGestureActionPrivate *priv = action->priv;
  GesturePoint *point G_GNUC_UNUSED;

  if ((clutter_event_type (event) != CLUTTER_BUTTON_PRESS) &&
@@ -529,8 +522,7 @@ static void
 clutter_gesture_action_set_actor (ClutterActorMeta *meta,
                                  ClutterActor     *actor)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (CLUTTER_GESTURE_ACTION (meta));
+  ClutterGestureActionPrivate *priv = CLUTTER_GESTURE_ACTION (meta)->priv;
  ClutterActorMetaClass *meta_class =
    CLUTTER_ACTOR_META_CLASS (clutter_gesture_action_parent_class);

@@ -564,22 +556,6 @@ clutter_gesture_action_set_actor (ClutterActorMeta *meta,
  meta_class->set_actor (meta, actor);
 }

-static void
-clutter_gesture_action_set_enabled (ClutterActorMeta *meta,
-                                    gboolean          is_enabled)
-{
-  ClutterActorMetaClass *meta_class =
-    CLUTTER_ACTOR_META_CLASS (clutter_gesture_action_parent_class);
-  ClutterGestureAction *gesture_action = CLUTTER_GESTURE_ACTION (meta);
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (gesture_action);
-
-  if (!is_enabled && priv->in_gesture)
-    cancel_gesture (gesture_action);
-
-  meta_class->set_enabled (meta, is_enabled);
-}
-
 static gboolean
 default_event_handler (ClutterGestureAction *action,
                       ClutterActor *actor)
@@ -594,8 +570,6 @@ clutter_gesture_action_set_property (GObject      *gobject,
                                     GParamSpec   *pspec)
 {
  ClutterGestureAction *self = CLUTTER_GESTURE_ACTION (gobject);
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (self);

  switch (prop_id)
    {
@@ -608,15 +582,11 @@ clutter_gesture_action_set_property (GObject      *gobject,
      break;

    case PROP_THRESHOLD_TRIGGER_DISTANCE_X:
-      clutter_gesture_action_set_threshold_trigger_distance (self,
-                                                             g_value_get_float (value),
-                                                             priv->distance_y);
+      clutter_gesture_action_set_threshold_trigger_distance (self, g_value_get_float (value), self->priv->distance_y);
      break;

    case PROP_THRESHOLD_TRIGGER_DISTANCE_Y:
-      clutter_gesture_action_set_threshold_trigger_distance (self,
-                                                             priv->distance_x,
-                                                             g_value_get_float (value));
+      clutter_gesture_action_set_threshold_trigger_distance (self, self->priv->distance_x, g_value_get_float (value));
      break;

    default:
@@ -631,29 +601,28 @@ clutter_gesture_action_get_property (GObject    *gobject,
                                     GValue     *value,
                                     GParamSpec *pspec)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (CLUTTER_GESTURE_ACTION (gobject));
+  ClutterGestureAction *self = CLUTTER_GESTURE_ACTION (gobject);

  switch (prop_id)
    {
    case PROP_N_TOUCH_POINTS:
-      g_value_set_int (value, priv->requested_nb_points);
+      g_value_set_int (value, self->priv->requested_nb_points);
      break;

    case PROP_THRESHOLD_TRIGGER_EDGE:
-      g_value_set_enum (value, priv->edge);
+      g_value_set_enum (value, self->priv->edge);
      break;

    case PROP_THRESHOLD_TRIGGER_DISTANCE_X:
-      if (priv->distance_x > 0.0)
-        g_value_set_float (value, priv->distance_x);
+      if (self->priv->distance_x > 0.0)
+        g_value_set_float (value, self->priv->distance_x);
      else
        g_value_set_float (value, gesture_get_default_threshold ());
      break;

    case PROP_THRESHOLD_TRIGGER_DISTANCE_Y:
-      if (priv->distance_y > 0.0)
-        g_value_set_float (value, priv->distance_y);
+      if (self->priv->distance_y > 0.0)
+        g_value_set_float (value, self->priv->distance_y);
      else
        g_value_set_float (value, gesture_get_default_threshold ());
      break;
@@ -667,8 +636,7 @@ clutter_gesture_action_get_property (GObject    *gobject,
 static void
 clutter_gesture_action_finalize (GObject *gobject)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (CLUTTER_GESTURE_ACTION (gobject));
+  ClutterGestureActionPrivate *priv = CLUTTER_GESTURE_ACTION (gobject)->priv;

  g_array_unref (priv->points);

@@ -686,7 +654,6 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
  gobject_class->get_property = clutter_gesture_action_get_property;

  meta_class->set_actor = clutter_gesture_action_set_actor;
-  meta_class->set_enabled = clutter_gesture_action_set_enabled;

  klass->gesture_begin = default_event_handler;
  klass->gesture_progress = default_event_handler;
@@ -860,14 +827,13 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
 static void
 clutter_gesture_action_init (ClutterGestureAction *self)
 {
-  ClutterGestureActionPrivate *priv =
-    clutter_gesture_action_get_instance_private (self);
+  self->priv = clutter_gesture_action_get_instance_private (self);

-  priv->points = g_array_sized_new (FALSE, TRUE, sizeof (GesturePoint), 3);
-  g_array_set_clear_func (priv->points, (GDestroyNotify) gesture_point_unset);
+  self->priv->points = g_array_sized_new (FALSE, TRUE, sizeof (GesturePoint), 3);
+  g_array_set_clear_func (self->priv->points, (GDestroyNotify) gesture_point_unset);

-  priv->requested_nb_points = 1;
-  priv->edge = CLUTTER_GESTURE_TRIGGER_EDGE_NONE;
+  self->priv->requested_nb_points = 1;
+  self->priv->edge = CLUTTER_GESTURE_TRIGGER_EDGE_NONE;
 }

 /**
@@ -906,21 +872,16 @@ clutter_gesture_action_get_press_coords (ClutterGestureAction *action,
                                         gfloat               *press_x,
                                         gfloat               *press_y)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_if_fail (CLUTTER_IS_GESTURE_ACTION (action));
-
-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_if_fail (priv->points->len > point);
+  g_return_if_fail (action->priv->points->len > point);

  if (press_x)
-    *press_x = g_array_index (priv->points,
+    *press_x = g_array_index (action->priv->points,
                              GesturePoint,
                              point).press_x;

  if (press_y)
-    *press_y = g_array_index (priv->points,
+    *press_y = g_array_index (action->priv->points,
                              GesturePoint,
                              point).press_y;
 }
@@ -946,21 +907,16 @@ clutter_gesture_action_get_motion_coords (ClutterGestureAction *action,
                                          gfloat               *motion_x,
                                          gfloat               *motion_y)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_if_fail (CLUTTER_IS_GESTURE_ACTION (action));
-
-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_if_fail (priv->points->len > point);
+  g_return_if_fail (action->priv->points->len > point);

  if (motion_x)
-    *motion_x = g_array_index (priv->points,
+    *motion_x = g_array_index (action->priv->points,
                               GesturePoint,
                               point).last_motion_x;

  if (motion_y)
-    *motion_y = g_array_index (priv->points,
+    *motion_y = g_array_index (action->priv->points,
                               GesturePoint,
                               point).last_motion_y;
 }
@@ -988,19 +944,15 @@ clutter_gesture_action_get_motion_delta (ClutterGestureAction *action,
                                         gfloat               *delta_x,
                                         gfloat               *delta_y)
 {
-  ClutterGestureActionPrivate *priv;
  gfloat d_x, d_y;

  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), 0);
+  g_return_val_if_fail (action->priv->points->len > point, 0);

-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_val_if_fail (priv->points->len > point, 0);
-
-  d_x = g_array_index (priv->points,
+  d_x = g_array_index (action->priv->points,
                       GesturePoint,
                       point).last_delta_x;
-  d_y = g_array_index (priv->points,
+  d_y = g_array_index (action->priv->points,
                       GesturePoint,
                       point).last_delta_y;

@@ -1034,21 +986,16 @@ clutter_gesture_action_get_release_coords (ClutterGestureAction *action,
                                           gfloat               *release_x,
                                           gfloat               *release_y)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_if_fail (CLUTTER_IS_GESTURE_ACTION (action));
-
-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_if_fail (priv->points->len > point);
+  g_return_if_fail (action->priv->points->len > point);

  if (release_x)
-    *release_x = g_array_index (priv->points,
+    *release_x = g_array_index (action->priv->points,
                                GesturePoint,
                                point).release_x;

  if (release_y)
-    *release_y = g_array_index (priv->points,
+    *release_y = g_array_index (action->priv->points,
                                GesturePoint,
                                point).release_y;
 }
@@ -1074,20 +1021,16 @@ clutter_gesture_action_get_velocity (ClutterGestureAction *action,
                                     gfloat               *velocity_x,
                                     gfloat               *velocity_y)
 {
-  ClutterGestureActionPrivate *priv;
  gfloat d_x, d_y, distance, velocity;
  gint64 d_t;

  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), 0);
-
-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_val_if_fail (priv->points->len > point, 0);
+  g_return_val_if_fail (action->priv->points->len > point, 0);

  distance = clutter_gesture_action_get_motion_delta (action, point,
                                                      &d_x, &d_y);

-  d_t = g_array_index (priv->points,
+  d_t = g_array_index (action->priv->points,
                       GesturePoint,
                       point).last_delta_time;

@@ -1114,13 +1057,9 @@ clutter_gesture_action_get_velocity (ClutterGestureAction *action,
 gint
 clutter_gesture_action_get_n_touch_points (ClutterGestureAction *action)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), 0);

-  priv = clutter_gesture_action_get_instance_private (action);
-
-  return priv->requested_nb_points;
+  return action->priv->requested_nb_points;
 }

 /**
@@ -1141,7 +1080,7 @@ clutter_gesture_action_set_n_touch_points (ClutterGestureAction *action,
  g_return_if_fail (CLUTTER_IS_GESTURE_ACTION (action));
  g_return_if_fail (nb_points >= 1);

-  priv = clutter_gesture_action_get_instance_private (action);
+  priv = action->priv;

  if (priv->requested_nb_points == nb_points)
    return;
@@ -1195,13 +1134,9 @@ clutter_gesture_action_set_n_touch_points (ClutterGestureAction *action,
 guint
 clutter_gesture_action_get_n_current_points (ClutterGestureAction *action)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), 0);

-  priv = clutter_gesture_action_get_instance_private (action);
-
-  return priv->points->len;
+  return action->priv->points->len;
 }

 /**
@@ -1219,15 +1154,10 @@ ClutterEventSequence *
 clutter_gesture_action_get_sequence (ClutterGestureAction *action,
                                     guint                 point)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), NULL);
+  g_return_val_if_fail (action->priv->points->len > point, NULL);

-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_val_if_fail (priv->points->len > point, NULL);
-
-  return g_array_index (priv->points, GesturePoint, point).sequence;
+  return g_array_index (action->priv->points, GesturePoint, point).sequence;
 }

 /**
@@ -1246,15 +1176,10 @@ ClutterInputDevice *
 clutter_gesture_action_get_device (ClutterGestureAction *action,
                                   guint                 point)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), NULL);
+  g_return_val_if_fail (action->priv->points->len > point, NULL);

-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_val_if_fail (priv->points->len > point, NULL);
-
-  return g_array_index (priv->points, GesturePoint, point).device;
+  return g_array_index (action->priv->points, GesturePoint, point).device;
 }

 /**
@@ -1274,15 +1199,11 @@ clutter_gesture_action_get_last_event (ClutterGestureAction *action,
                                       guint                 point)
 {
  GesturePoint *gesture_point;
-  ClutterGestureActionPrivate *priv;

  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), NULL);
+  g_return_val_if_fail (action->priv->points->len > point, NULL);

-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_val_if_fail (priv->points->len > point, NULL);
-
-  gesture_point = &g_array_index (priv->points, GesturePoint, point);
+  gesture_point = &g_array_index (action->priv->points, GesturePoint, point);

  return gesture_point->last_event;
 }
@@ -1319,16 +1240,12 @@ void
 clutter_gesture_action_set_threshold_trigger_edge (ClutterGestureAction      *action,
                                                   ClutterGestureTriggerEdge  edge)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_if_fail (CLUTTER_IS_GESTURE_ACTION (action));

-  priv = clutter_gesture_action_get_instance_private (action);
-
-  if (priv->edge == edge)
+  if (action->priv->edge == edge)
    return;

-  priv->edge = edge;
+  action->priv->edge = edge;

  g_object_notify_by_pspec (G_OBJECT (action), gesture_props[PROP_THRESHOLD_TRIGGER_EDGE]);
 }
@@ -1347,14 +1264,10 @@ clutter_gesture_action_set_threshold_trigger_edge (ClutterGestureAction      *ac
 ClutterGestureTriggerEdge
 clutter_gesture_action_get_threshold_trigger_edge (ClutterGestureAction *action)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action),
                        CLUTTER_GESTURE_TRIGGER_EDGE_NONE);

-  priv = clutter_gesture_action_get_instance_private (action);
-
-  return priv->edge;
+  return action->priv->edge;
 }

 /**
@@ -1394,21 +1307,17 @@ clutter_gesture_action_set_threshold_trigger_distance (ClutterGestureAction
                                                       float                      x,
                                                       float                      y)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_if_fail (CLUTTER_IS_GESTURE_ACTION (action));

-  priv = clutter_gesture_action_get_instance_private (action);
-
-  if (fabsf (x - priv->distance_x) > FLOAT_EPSILON)
+  if (fabsf (x - action->priv->distance_x) > FLOAT_EPSILON)
    {
-      priv->distance_x = x;
+      action->priv->distance_x = x;
      g_object_notify_by_pspec (G_OBJECT (action), gesture_props[PROP_THRESHOLD_TRIGGER_DISTANCE_X]);
    }

-  if (fabsf (y - priv->distance_y) > FLOAT_EPSILON)
+  if (fabsf (y - action->priv->distance_y) > FLOAT_EPSILON)
    {
-      priv->distance_y = y;
+      action->priv->distance_y = y;
      g_object_notify_by_pspec (G_OBJECT (action), gesture_props[PROP_THRESHOLD_TRIGGER_DISTANCE_Y]);
    }
 }
@@ -1429,23 +1338,19 @@ clutter_gesture_action_get_threshold_trigger_distance (ClutterGestureAction *act
                                                       float                *x,
                                                       float                *y)
 {
-  ClutterGestureActionPrivate *priv;
-
  g_return_if_fail (CLUTTER_IS_GESTURE_ACTION (action));

-  priv = clutter_gesture_action_get_instance_private (action);
-
  if (x != NULL)
    {
-      if (priv->distance_x > 0.0)
-        *x = priv->distance_x;
+      if (action->priv->distance_x > 0.0)
+        *x = action->priv->distance_x;
      else
        *x = gesture_get_default_threshold ();
    }
  if (y != NULL)
    {
-      if (priv->distance_y > 0.0)
-        *y = priv->distance_y;
+      if (action->priv->distance_y > 0.0)
+        *y = action->priv->distance_y;
      else
        *y = gesture_get_default_threshold ();
    }
--- a/clutter/clutter/clutter-gesture-action.h
+++ b/clutter/clutter/clutter-gesture-action.h
@@ -34,13 +34,32 @@

 G_BEGIN_DECLS

-#define CLUTTER_TYPE_GESTURE_ACTION (clutter_gesture_action_get_type ())
+#define CLUTTER_TYPE_GESTURE_ACTION               (clutter_gesture_action_get_type ())
+#define CLUTTER_GESTURE_ACTION(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_GESTURE_ACTION, ClutterGestureAction))
+#define CLUTTER_IS_GESTURE_ACTION(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_GESTURE_ACTION))
+#define CLUTTER_GESTURE_ACTION_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_GESTURE_ACTION, ClutterGestureActionClass))
+#define CLUTTER_IS_GESTURE_ACTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_GESTURE_ACTION))
+#define CLUTTER_GESTURE_ACTION_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_GESTURE_ACTION, ClutterGestureActionClass))

-CLUTTER_EXPORT
-G_DECLARE_DERIVABLE_TYPE (ClutterGestureAction, clutter_gesture_action,
-                          CLUTTER, GESTURE_ACTION, ClutterAction);
+typedef struct _ClutterGestureAction              ClutterGestureAction;
+typedef struct _ClutterGestureActionPrivate       ClutterGestureActionPrivate;
+typedef struct _ClutterGestureActionClass         ClutterGestureActionClass;

-typedef struct _ClutterGestureActionPrivate ClutterGestureActionPrivate;
+/**
+ * ClutterGestureAction:
+ *
+ * The #ClutterGestureAction structure contains
+ * only private data and should be accessed using the provided API
+ *
+ * Since: 1.8
+ */
+struct _ClutterGestureAction
+{
+  /*< private >*/
+  ClutterAction parent_instance;
+
+  ClutterGestureActionPrivate *priv;
+};

 /**
 * ClutterGestureActionClass:
@@ -82,6 +101,9 @@ struct _ClutterGestureActionClass
  void (* _clutter_gesture_action6) (void);
 };

+CLUTTER_EXPORT
+GType clutter_gesture_action_get_type (void) G_GNUC_CONST;
+
 CLUTTER_EXPORT
 ClutterAction *        clutter_gesture_action_new                      (void);

--- a/clutter/clutter/clutter-grid-layout.c
+++ b/clutter/clutter/clutter-grid-layout.c
@@ -1391,7 +1391,8 @@ allocate_child (ClutterGridRequest *request,
 static void
 clutter_grid_layout_allocate (ClutterLayoutManager   *layout,
                              ClutterContainer       *container,
-                              const ClutterActorBox  *allocation)
+                              const ClutterActorBox  *allocation,
+                              ClutterAllocationFlags  flags)
 {
  ClutterGridLayout *self = CLUTTER_GRID_LAYOUT (layout);
  ClutterOrientation orientation;
@@ -1452,7 +1453,7 @@ clutter_grid_layout_allocate (ClutterLayoutManager   *layout,
      child_allocation.x2 = child_allocation.x1 + width;
      child_allocation.y2 = child_allocation.y1 + height;

-      clutter_actor_allocate (child, &child_allocation);
+      clutter_actor_allocate (child, &child_allocation, flags);
    }
 }

--- a/clutter/clutter/clutter-group.h
+++ b/clutter/clutter/clutter-group.h
@@ -0,0 +1,96 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Matthew Allum  <mallum@openedhand.com>
+ *
+ * Copyright (C) 2006 OpenedHand
+ *
+ * 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_GROUP_H__
+#define __CLUTTER_GROUP_H__
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#include <glib-object.h>
+#include <clutter/clutter-types.h>
+#include <clutter/clutter-actor.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_GROUP              (clutter_group_get_type ())
+#define CLUTTER_GROUP(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_GROUP, ClutterGroup))
+#define CLUTTER_GROUP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_GROUP, ClutterGroupClass))
+#define CLUTTER_IS_GROUP(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_GROUP))
+#define CLUTTER_IS_GROUP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_GROUP))
+#define CLUTTER_GROUP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_GROUP, ClutterGroupClass))
+
+/* XXX - ClutterGroup is to be considered fully deprecated; the only
+ * reason we keep this header is because ClutterStage inherits from
+ * ClutterGroup, and thus we need to have a structure definition for
+ * the Stage object to expand.
+ */
+
+typedef struct _ClutterGroup            ClutterGroup;
+typedef struct _ClutterGroupClass       ClutterGroupClass;
+typedef struct _ClutterGroupPrivate     ClutterGroupPrivate;
+
+/**
+ * ClutterGroup:
+ *
+ * The #ClutterGroup structure contains only private data
+ * and should be accessed using the provided API
+ *
+ * Since: 0.2
+ */
+struct _ClutterGroup
+{
+  /*< private >*/
+  ClutterActor parent_instance;
+
+  ClutterGroupPrivate *priv;
+};
+
+/**
+ * ClutterGroupClass:
+ *
+ * The #ClutterGroupClass structure contains only private data
+ *
+ * Since: 0.2
+ */
+struct _ClutterGroupClass
+{
+  /*< private >*/
+  ClutterActorClass parent_class;
+
+  /* padding for future expansion */
+  void (*_clutter_reserved1) (void);
+  void (*_clutter_reserved2) (void);
+  void (*_clutter_reserved3) (void);
+  void (*_clutter_reserved4) (void);
+  void (*_clutter_reserved5) (void);
+  void (*_clutter_reserved6) (void);
+};
+
+CLUTTER_EXPORT
+GType clutter_group_get_type (void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* __CLUTTER_GROUP_H__ */
--- a/clutter/clutter/clutter-input-device-private.h
+++ b/clutter/clutter/clutter-input-device-private.h
@@ -61,6 +61,15 @@ typedef struct _ClutterScrollInfo
  guint last_value_valid : 1;
 } ClutterScrollInfo;

+typedef struct _ClutterTouchInfo
+{
+  ClutterEventSequence *sequence;
+  ClutterActor *actor;
+
+  float current_x;
+  float current_y;
+} ClutterTouchInfo;
+
 typedef struct _ClutterPtrA11yData
 {
  int n_btn_pressed;
@@ -111,18 +120,25 @@ struct _ClutterInputDevice
  /* the current click count */
  int click_count;

+  /* the stage the device is on */
+  ClutterStage *stage;
+
  /* the current state */
+  float current_x;
+  float current_y;
+  uint32_t current_time;
  int current_button_number;
  ClutterModifierType current_state;

-  /* the current touch points targets */
-  GHashTable *touch_sequence_actors;
+  /* the current touch points states */
+  GHashTable *touch_sequences_info;

  /* the previous state, used for click count generation */
  int previous_x;
  int previous_y;
  uint32_t previous_time;
  int previous_button_number;
+  ClutterModifierType previous_state;

  GArray *axes;

@@ -141,6 +157,8 @@ struct _ClutterInputDevice
  int n_strips;
  int n_mode_groups;

+  ClutterInputDeviceMapping mapping_mode;
+
  guint has_cursor : 1;
  guint is_enabled : 1;

@@ -162,11 +180,33 @@ CLUTTER_EXPORT
 void clutter_input_device_update_from_tool (ClutterInputDevice     *device,
                                            ClutterInputDeviceTool *tool);
 CLUTTER_EXPORT
+ClutterStage * _clutter_input_device_get_stage (ClutterInputDevice *device);
+CLUTTER_EXPORT
+void _clutter_input_device_set_stage (ClutterInputDevice *device,
+                                      ClutterStage       *stage);
+CLUTTER_EXPORT
+void _clutter_input_device_set_coords (ClutterInputDevice   *device,
+                                       ClutterEventSequence *sequence,
+                                       gfloat                x,
+                                       gfloat                y,
+                                       ClutterStage         *stage);
+CLUTTER_EXPORT
+void _clutter_input_device_set_state (ClutterInputDevice  *device,
+                                      ClutterModifierType  state);
+CLUTTER_EXPORT
+void _clutter_input_device_set_time (ClutterInputDevice *device,
+                                     guint32             time_);
+void _clutter_input_device_set_actor (ClutterInputDevice   *device,
+                                      ClutterEventSequence *sequence,
+                                      ClutterActor         *actor,
+                                      gboolean              emit_crossing);
+CLUTTER_EXPORT
 ClutterActor * clutter_input_device_update (ClutterInputDevice   *device,
-                                            ClutterEventSequence *sequence,
-                                            ClutterStage         *stage,
-                                            gboolean              emit_crossing,
-                                            ClutterEvent         *for_event);
+					    ClutterEventSequence *sequence,
+					    gboolean              emit_crossing);
+CLUTTER_EXPORT
+void _clutter_input_device_add_event_sequence (ClutterInputDevice *device,
+                                               ClutterEvent       *event);
 CLUTTER_EXPORT
 void _clutter_input_device_remove_event_sequence (ClutterInputDevice *device,
                                                  ClutterEvent       *event);
@@ -174,12 +214,6 @@ CLUTTER_EXPORT
 void _clutter_input_device_set_n_keys (ClutterInputDevice *device,
                                       guint               n_keys);
 CLUTTER_EXPORT
-void clutter_input_device_set_key     (ClutterInputDevice  *device,
-                                       guint                index_,
-                                       guint                keyval,
-                                       ClutterModifierType  modifiers);
-
-CLUTTER_EXPORT
 gboolean _clutter_input_device_translate_axis (ClutterInputDevice *device,
                                               guint               index_,
                                               gdouble             value,
@@ -218,9 +252,4 @@ ClutterInputDeviceTool *
                                     guint64                     serial,
                                     ClutterInputDeviceToolType  type);

-CLUTTER_EXPORT
-gboolean clutter_input_device_keycode_to_evdev (ClutterInputDevice *device,
-                                                guint               hardware_keycode,
-                                                guint              *evdev_keycode);
-
 #endif /* CLUTTER_INPUT_DEVICE_PRIVATE_H */
--- a/clutter/clutter/clutter-input-device.c
+++ b/clutter/clutter/clutter-input-device.c
@@ -61,6 +61,7 @@ enum
  PROP_DEVICE_MODE,

  PROP_HAS_CURSOR,
+  PROP_ENABLED,

  PROP_N_AXES,

@@ -71,10 +72,12 @@ enum
  PROP_N_RINGS,
  PROP_N_MODE_GROUPS,
  PROP_DEVICE_NODE,
+  PROP_MAPPING_MODE,

  PROP_LAST
 };

+static void _clutter_input_device_free_touch_info (gpointer data);
 static void on_cursor_actor_destroy (ClutterActor       *actor,
                                     ClutterInputDevice *device);
 static void on_cursor_actor_reactive_changed (ClutterActor       *actor,
@@ -111,7 +114,7 @@ clutter_input_device_dispose (GObject *gobject)
  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);
-  g_clear_pointer (&device->touch_sequence_actors, g_hash_table_unref);
+  g_clear_pointer (&device->touch_sequences_info, g_hash_table_unref);

  if (device->cursor_actor)
    {
@@ -188,6 +191,10 @@ clutter_input_device_set_property (GObject      *gobject,
      self->has_cursor = g_value_get_boolean (value);
      break;

+    case PROP_ENABLED:
+      clutter_input_device_set_enabled (self, g_value_get_boolean (value));
+      break;
+
    case PROP_VENDOR_ID:
      self->vendor_id = g_value_dup_string (value);
      break;
@@ -212,6 +219,10 @@ clutter_input_device_set_property (GObject      *gobject,
      self->node_path = g_value_dup_string (value);
      break;

+    case PROP_MAPPING_MODE:
+      self->mapping_mode = g_value_get_enum (value);
+      break;
+
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
      break;
@@ -260,6 +271,10 @@ clutter_input_device_get_property (GObject    *gobject,
      g_value_set_uint (value, clutter_input_device_get_n_axes (self));
      break;

+    case PROP_ENABLED:
+      g_value_set_boolean (value, self->is_enabled);
+      break;
+
    case PROP_VENDOR_ID:
      g_value_set_string (value, self->vendor_id);
      break;
@@ -284,6 +299,10 @@ clutter_input_device_get_property (GObject    *gobject,
      g_value_set_string (value, self->node_path);
      break;

+    case PROP_MAPPING_MODE:
+      g_value_set_enum (value, self->mapping_mode);
+      break;
+
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
      break;
@@ -383,6 +402,25 @@ clutter_input_device_class_init (ClutterInputDeviceClass *klass)
                          FALSE,
                          CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);

+  /**
+   * ClutterInputDevice:enabled:
+   *
+   * Whether the device is enabled.
+   *
+   * A device with the #ClutterInputDevice:device-mode property set
+   * to %CLUTTER_INPUT_MODE_MASTER cannot be disabled.
+   *
+   * A device must be enabled in order to receive events from it.
+   *
+   * Since: 1.6
+   */
+  obj_props[PROP_ENABLED] =
+    g_param_spec_boolean ("enabled",
+                          P_("Enabled"),
+                          P_("Whether the device is enabled"),
+                          FALSE,
+                          CLUTTER_PARAM_READWRITE);
+
  /**
   * ClutterInputDevice:n-axes:
   *
@@ -468,6 +506,14 @@ clutter_input_device_class_init (ClutterInputDeviceClass *klass)
                         NULL,
                         CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);

+  obj_props[PROP_MAPPING_MODE] =
+    g_param_spec_enum ("mapping-mode",
+                       P_("Device mapping mode"),
+                       P_("Device mapping mode"),
+                       CLUTTER_TYPE_INPUT_DEVICE_MAPPING,
+                       CLUTTER_INPUT_DEVICE_MAPPING_ABSOLUTE,
+                       CLUTTER_PARAM_READWRITE);
+
  gobject_class->dispose = clutter_input_device_dispose;
  gobject_class->set_property = clutter_input_device_set_property;
  gobject_class->get_property = clutter_input_device_get_property;
@@ -482,15 +528,91 @@ clutter_input_device_init (ClutterInputDevice *self)

  self->click_count = 0;

-  self->previous_time = CLUTTER_CURRENT_TIME;
-  self->previous_x = -1;
-  self->previous_y = -1;
+  self->current_time = self->previous_time = CLUTTER_CURRENT_TIME;
+  self->current_x = self->previous_x = -1;
+  self->current_y = self->previous_y = -1;
  self->current_button_number = self->previous_button_number = -1;
+  self->current_state = self->previous_state = 0;

-  self->touch_sequence_actors = g_hash_table_new (NULL, NULL);
+  self->touch_sequences_info =
+    g_hash_table_new_full (NULL, NULL,
+                           NULL, _clutter_input_device_free_touch_info);
  self->inv_touch_sequence_actors = g_hash_table_new (NULL, NULL);
 }

+static ClutterTouchInfo *
+_clutter_input_device_ensure_touch_info (ClutterInputDevice *device,
+                                         ClutterEventSequence *sequence,
+                                         ClutterStage *stage)
+{
+  ClutterTouchInfo *info;
+
+  info = g_hash_table_lookup (device->touch_sequences_info, sequence);
+
+  if (info == NULL)
+    {
+      info = g_slice_new0 (ClutterTouchInfo);
+      info->sequence = sequence;
+      g_hash_table_insert (device->touch_sequences_info, sequence, info);
+
+      if (g_hash_table_size (device->touch_sequences_info) == 1)
+        _clutter_input_device_set_stage (device, stage);
+    }
+
+  return info;
+}
+
+/*< private >
+ * clutter_input_device_set_coords:
+ * @device: a #ClutterInputDevice
+ * @sequence: a #ClutterEventSequence or NULL
+ * @x: X coordinate of the device
+ * @y: Y coordinate of the device
+ *
+ * Stores the last known coordinates of the device
+ */
+void
+_clutter_input_device_set_coords (ClutterInputDevice   *device,
+                                  ClutterEventSequence *sequence,
+                                  gfloat                x,
+                                  gfloat                y,
+                                  ClutterStage         *stage)
+{
+  g_return_if_fail (CLUTTER_IS_INPUT_DEVICE (device));
+
+  if (sequence == NULL)
+    {
+      if (device->current_x != x)
+        device->current_x = x;
+
+      if (device->current_y != y)
+        device->current_y = y;
+    }
+  else
+    {
+      ClutterTouchInfo *info;
+      info = _clutter_input_device_ensure_touch_info (device, sequence, stage);
+      info->current_x = x;
+      info->current_y = y;
+    }
+}
+
+/*< private >
+ * clutter_input_device_set_state:
+ * @device: a #ClutterInputDevice
+ * @state: a bitmask of modifiers
+ *
+ * Stores the last known modifiers state of the device
+ */
+void
+_clutter_input_device_set_state (ClutterInputDevice  *device,
+                                 ClutterModifierType  state)
+{
+  g_return_if_fail (CLUTTER_IS_INPUT_DEVICE (device));
+
+  device->current_state = state;
+}
+
 /**
 * clutter_input_device_get_modifier_state:
 * @device: a #ClutterInputDevice
@@ -505,17 +627,83 @@ clutter_input_device_init (ClutterInputDevice *self)
 ClutterModifierType
 clutter_input_device_get_modifier_state (ClutterInputDevice *device)
 {
-  uint32_t modifiers;
-  ClutterSeat *seat;
-
  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), 0);

-  seat = clutter_input_device_get_seat (device);
+  return device->current_state;
+}

-  if (!clutter_seat_query_state (seat, device, NULL, NULL, &modifiers))
-    return 0;
+/*< private >
+ * clutter_input_device_set_time:
+ * @device: a #ClutterInputDevice
+ * @time_: the time
+ *
+ * Stores the last known event time of the device
+ */
+void
+_clutter_input_device_set_time (ClutterInputDevice *device,
+                                guint32             time_)
+{
+  g_return_if_fail (CLUTTER_IS_INPUT_DEVICE (device));

-  return modifiers;
+  if (device->current_time != time_)
+    device->current_time = time_;
+}
+
+/*< private >
+ * clutter_input_device_set_stage:
+ * @device: a #ClutterInputDevice
+ * @stage: a #ClutterStage or %NULL
+ *
+ * Stores the stage under the device
+ */
+void
+_clutter_input_device_set_stage (ClutterInputDevice *device,
+                                 ClutterStage       *stage)
+{
+  if (device->stage == stage)
+    return;
+
+  device->stage = stage;
+
+  /* we leave the ->cursor_actor in place in order to check
+   * if we left the stage without crossing it again; this way
+   * we can emit a leave event on the cursor actor right before
+   * we emit the leave event on the stage.
+   */
+}
+
+/*< private >
+ * clutter_input_device_get_stage:
+ * @device: a #ClutterInputDevice
+ *
+ * Retrieves the stage currently associated with @device.
+ *
+ * Return value: The stage currently associated with @device.
+ */
+ClutterStage *
+_clutter_input_device_get_stage (ClutterInputDevice *device)
+{
+  return device->stage;
+}
+
+static void
+_clutter_input_device_free_touch_info (gpointer data)
+{
+  g_slice_free (ClutterTouchInfo, data);
+}
+
+static ClutterActor *
+_clutter_input_device_get_actor (ClutterInputDevice   *device,
+                                 ClutterEventSequence *sequence)
+{
+  ClutterTouchInfo *info;
+
+  if (sequence == NULL)
+    return device->cursor_actor;
+
+  info = g_hash_table_lookup (device->touch_sequences_info, sequence);
+
+  return info->actor;
 }

 static void
@@ -529,8 +717,12 @@ _clutter_input_device_associate_actor (ClutterInputDevice   *device,
    {
      GList *sequences =
        g_hash_table_lookup (device->inv_touch_sequence_actors, actor);
+      ClutterTouchInfo *info;
+      ClutterStage *stage = CLUTTER_STAGE (clutter_actor_get_stage (actor));
+
+      info = _clutter_input_device_ensure_touch_info (device, sequence, stage);
+      info->actor = actor;

-      g_hash_table_insert (device->touch_sequence_actors, sequence, actor);
      g_hash_table_insert (device->inv_touch_sequence_actors,
                           actor, g_list_prepend (sequences, sequence));
    }
@@ -558,7 +750,13 @@ _clutter_input_device_unassociate_actor (ClutterInputDevice   *device,
                             actor);

      for (l = sequences; l != NULL; l = l->next)
-        g_hash_table_remove (device->touch_sequence_actors, l->data);
+        {
+          ClutterTouchInfo *info =
+            g_hash_table_lookup (device->touch_sequences_info, l->data);
+
+          if (info)
+            info->actor = NULL;
+        }

      g_list_free (sequences);
      g_hash_table_remove (device->inv_touch_sequence_actors, actor);
@@ -611,31 +809,17 @@ on_cursor_actor_reactive_changed (ClutterActor       *actor,
 *   - set to %TRUE the :has-pointer property of the new pointer
 *     actor
 */
-static void
+void
 _clutter_input_device_set_actor (ClutterInputDevice   *device,
                                 ClutterEventSequence *sequence,
                                 ClutterActor         *actor,
-                                 gboolean              emit_crossing,
-                                 graphene_point_t      coords,
-                                 uint32_t              time_)
+                                 gboolean              emit_crossing)
 {
-  ClutterActor *old_actor = clutter_input_device_get_actor (device, sequence);
-  ClutterStage *stage = NULL;
+  ClutterActor *old_actor = _clutter_input_device_get_actor (device, sequence);

  if (old_actor == actor)
    return;

-  if (emit_crossing)
-    {
-      if (actor)
-        stage = CLUTTER_STAGE (clutter_actor_get_stage (actor));
-      else if (old_actor)
-        stage = CLUTTER_STAGE (clutter_actor_get_stage (old_actor));
-
-      if (!stage)
-        return;
-    }
-
  if (old_actor != NULL)
    {
      ClutterActor *tmp_old_actor;
@@ -645,12 +829,12 @@ _clutter_input_device_set_actor (ClutterInputDevice   *device,
          ClutterEvent *event;

          event = clutter_event_new (CLUTTER_LEAVE);
-          event->crossing.time = time_;
+          event->crossing.time = device->current_time;
          event->crossing.flags = 0;
-          event->crossing.stage = stage;
+          event->crossing.stage = device->stage;
          event->crossing.source = old_actor;
-          event->crossing.x = coords.x;
-          event->crossing.y = coords.y;
+          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);
@@ -666,7 +850,7 @@ _clutter_input_device_set_actor (ClutterInputDevice   *device,
        }

      /* processing the event might have destroyed the actor */
-      tmp_old_actor = clutter_input_device_get_actor (device, sequence);
+      tmp_old_actor = _clutter_input_device_get_actor (device, sequence);
      _clutter_input_device_unassociate_actor (device,
                                               old_actor,
                                               tmp_old_actor == NULL);
@@ -682,11 +866,11 @@ _clutter_input_device_set_actor (ClutterInputDevice   *device,
          ClutterEvent *event;

          event = clutter_event_new (CLUTTER_ENTER);
-          event->crossing.time = time_;
+          event->crossing.time = device->current_time;
          event->crossing.flags = 0;
-          event->crossing.stage = stage;
-          event->crossing.x = coords.x;
-          event->crossing.y = coords.y;
+          event->crossing.stage = device->stage;
+          event->crossing.x = device->current_x;
+          event->crossing.y = device->current_y;
          event->crossing.source = actor;
          event->crossing.related = old_actor;
          event->crossing.sequence = sequence;
@@ -737,6 +921,56 @@ clutter_input_device_get_device_id (ClutterInputDevice *device)
  return device->id;
 }

+/**
+ * clutter_input_device_set_enabled:
+ * @device: a #ClutterInputDevice
+ * @enabled: %TRUE to enable the @device
+ *
+ * Enables or disables a #ClutterInputDevice.
+ *
+ * Only devices with a #ClutterInputDevice:device-mode property set
+ * to %CLUTTER_INPUT_MODE_SLAVE or %CLUTTER_INPUT_MODE_FLOATING can
+ * be disabled.
+ *
+ * Since: 1.6
+ */
+void
+clutter_input_device_set_enabled (ClutterInputDevice *device,
+                                  gboolean            enabled)
+{
+  g_return_if_fail (CLUTTER_IS_INPUT_DEVICE (device));
+
+  enabled = !!enabled;
+
+  if (!enabled && device->device_mode == CLUTTER_INPUT_MODE_MASTER)
+    return;
+
+  if (device->is_enabled == enabled)
+    return;
+
+  device->is_enabled = enabled;
+
+  g_object_notify_by_pspec (G_OBJECT (device), obj_props[PROP_ENABLED]);
+}
+
+/**
+ * clutter_input_device_get_enabled:
+ * @device: a #ClutterInputDevice
+ *
+ * Retrieves whether @device is enabled.
+ *
+ * Return value: %TRUE if the device is enabled
+ *
+ * Since: 1.6
+ */
+gboolean
+clutter_input_device_get_enabled (ClutterInputDevice *device)
+{
+  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), FALSE);
+
+  return device->is_enabled;
+}
+
 /**
 * clutter_input_device_get_coords:
 * @device: a #ClutterInputDevice
@@ -758,14 +992,27 @@ clutter_input_device_get_coords (ClutterInputDevice   *device,
                                 ClutterEventSequence *sequence,
                                 graphene_point_t     *point)
 {
-  ClutterSeat *seat;
-
  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), FALSE);
  g_return_val_if_fail (point != NULL, FALSE);

-  seat = clutter_input_device_get_seat (device);
+  if (sequence == NULL)
+    {
+      point->x = device->current_x;
+      point->y = device->current_y;
+    }
+  else
+    {
+      ClutterTouchInfo *info =
+        g_hash_table_lookup (device->touch_sequences_info, sequence);

-  return clutter_seat_query_state (seat, device, sequence, point, NULL);
+      if (info == NULL)
+        return FALSE;
+
+      point->x = info->current_x;
+      point->y = info->current_y;
+    }
+
+  return TRUE;
 }

 /*
@@ -785,31 +1032,29 @@ clutter_input_device_get_coords (ClutterInputDevice   *device,
 ClutterActor *
 clutter_input_device_update (ClutterInputDevice   *device,
                             ClutterEventSequence *sequence,
-                             ClutterStage         *stage,
-                             gboolean              emit_crossing,
-                             ClutterEvent         *for_event)
+                             gboolean              emit_crossing)
 {
+  ClutterStage *stage;
  ClutterActor *new_cursor_actor;
  ClutterActor *old_cursor_actor;
  graphene_point_t point = GRAPHENE_POINT_INIT (-1.0f, -1.0f);
  ClutterInputDeviceType device_type = device->device_type;
-  uint32_t time_;

  g_assert (device_type != CLUTTER_KEYBOARD_DEVICE &&
            device_type != CLUTTER_PAD_DEVICE);

-  if (for_event)
+  stage = device->stage;
+  if (G_UNLIKELY (stage == NULL))
    {
-      clutter_event_get_coords (for_event, &point.x, &point.y);
-      time_ = clutter_event_get_time (for_event);
-    }
-  else
-    {
-      clutter_input_device_get_coords (device, sequence, &point);
-      time_ = CLUTTER_CURRENT_TIME;
+      CLUTTER_NOTE (EVENT, "No stage defined for device %d '%s'",
+                    clutter_input_device_get_device_id (device),
+                    clutter_input_device_get_device_name (device));
+      return NULL;
    }

-  old_cursor_actor = clutter_input_device_get_actor (device, sequence);
+  clutter_input_device_get_coords (device, sequence, &point);
+
+  old_cursor_actor = _clutter_input_device_get_actor (device, sequence);
  new_cursor_actor =
    _clutter_stage_do_pick (stage, point.x, point.y, CLUTTER_PICK_REACTIVE);

@@ -834,34 +1079,47 @@ clutter_input_device_update (ClutterInputDevice   *device,

  _clutter_input_device_set_actor (device, sequence,
                                   new_cursor_actor,
-                                   emit_crossing,
-                                   point, time_);
+                                   emit_crossing);

  return new_cursor_actor;
 }

 /**
- * clutter_input_device_get_actor:
- * @device: a #ClutterInputDevice
- * @sequence: (allow-none): an optional #ClutterEventSequence
+ * clutter_input_device_get_pointer_actor:
+ * @device: a #ClutterInputDevice of type %CLUTTER_POINTER_DEVICE
 *
- * Retrieves the #ClutterActor underneath the pointer or touchpoint
- * of @device and @sequence.
+ * Retrieves the #ClutterActor underneath the pointer of @device
 *
 * Return value: (transfer none): a pointer to the #ClutterActor or %NULL
 *
 * Since: 1.2
 */
 ClutterActor *
-clutter_input_device_get_actor (ClutterInputDevice   *device,
-                                ClutterEventSequence *sequence)
+clutter_input_device_get_pointer_actor (ClutterInputDevice *device)
 {
  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), NULL);
+  g_return_val_if_fail (device->device_type == CLUTTER_POINTER_DEVICE, NULL);

-  if (sequence == NULL)
-    return device->cursor_actor;
+  return device->cursor_actor;
+}

-  return g_hash_table_lookup (device->touch_sequence_actors, sequence);
+/**
+ * clutter_input_device_get_pointer_stage:
+ * @device: a #ClutterInputDevice of type %CLUTTER_POINTER_DEVICE
+ *
+ * Retrieves the #ClutterStage underneath the pointer of @device
+ *
+ * Return value: (transfer none): a pointer to the #ClutterStage or %NULL
+ *
+ * Since: 1.2
+ */
+ClutterStage *
+clutter_input_device_get_pointer_stage (ClutterInputDevice *device)
+{
+  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), NULL);
+  g_return_val_if_fail (device->device_type == CLUTTER_POINTER_DEVICE, NULL);
+
+  return device->stage;
 }

 /**
@@ -922,6 +1180,95 @@ clutter_input_device_get_device_mode (ClutterInputDevice *device)
  return device->device_mode;
 }

+/**
+ * clutter_input_device_update_from_event:
+ * @device: a #ClutterInputDevice
+ * @event: a #ClutterEvent
+ * @update_stage: whether to update the #ClutterStage of the @device
+ *   using the stage of the event
+ *
+ * Forcibly updates the state of the @device using a #ClutterEvent
+ *
+ * This function should never be used by applications: it is meant
+ * for integration with embedding toolkits, like clutter-gtk
+ *
+ * Embedding toolkits that disable the event collection inside Clutter
+ * need to use this function to update the state of input devices depending
+ * on a #ClutterEvent that they are going to submit to the event handling code
+ * in Clutter though clutter_do_event(). Since the input devices hold the state
+ * that is going to be used to fill in fields like the #ClutterButtonEvent
+ * click count, or to emit synthesized events like %CLUTTER_ENTER and
+ * %CLUTTER_LEAVE, it is necessary for embedding toolkits to also be
+ * responsible of updating the input device state.
+ *
+ * For instance, this might be the code to translate an embedding toolkit
+ * native motion notification into a Clutter #ClutterMotionEvent and ask
+ * Clutter to process it:
+ *
+ * |[
+ *   ClutterEvent c_event;
+ *
+ *   translate_native_event_to_clutter (native_event, &c_event);
+ *
+ *   clutter_do_event (&c_event);
+ * ]|
+ *
+ * Before letting clutter_do_event() process the event, it is necessary to call
+ * clutter_input_device_update_from_event():
+ *
+ * |[
+ *   ClutterEvent c_event;
+ *   ClutterDeviceManager *manager;
+ *   ClutterInputDevice *device;
+ *
+ *   translate_native_event_to_clutter (native_event, &c_event);
+ *
+ *   // get the seat
+ *   seat = clutter_backend_get_deafult_seat (clutter_get_default_backend ());
+ *
+ *   // use the default Core Pointer that Clutter backends register by default
+ *   device = clutter_seat_get_pointer (seat);
+ *
+ *   // update the state of the input device
+ *   clutter_input_device_update_from_event (device, &c_event, FALSE);
+ *
+ *   clutter_do_event (&c_event);
+ * ]|
+ *
+ * The @update_stage boolean argument should be used when the input device
+ * enters and leaves a #ClutterStage; it will use the #ClutterStage field
+ * of the passed @event to update the stage associated to the input device.
+ *
+ * Since: 1.2
+ */
+void
+clutter_input_device_update_from_event (ClutterInputDevice *device,
+                                        ClutterEvent       *event,
+                                        gboolean            update_stage)
+{
+  ClutterModifierType event_state;
+  ClutterEventSequence *sequence;
+  ClutterStage *event_stage;
+  gfloat event_x, event_y;
+  guint32 event_time;
+
+  g_return_if_fail (CLUTTER_IS_INPUT_DEVICE (device));
+  g_return_if_fail (event != NULL);
+
+  event_state = clutter_event_get_state (event);
+  event_time = clutter_event_get_time (event);
+  event_stage = clutter_event_get_stage (event);
+  sequence = clutter_event_get_event_sequence (event);
+  clutter_event_get_coords (event, &event_x, &event_y);
+
+  _clutter_input_device_set_coords (device, sequence, event_x, event_y, event_stage);
+  _clutter_input_device_set_state (device, event_state);
+  _clutter_input_device_set_time (device, event_time);
+
+  if (update_stage)
+    _clutter_input_device_set_stage (device, event_stage);
+}
+
 /*< private >
 * clutter_input_device_reset_axes:
 * @device: a #ClutterInputDevice
@@ -1302,6 +1649,31 @@ _clutter_input_device_remove_slave (ClutterInputDevice *master,
    master->slaves = g_list_remove (master->slaves, slave);
 }

+/*< private >
+ * clutter_input_device_add_sequence:
+ * @device: a #ClutterInputDevice
+ * @sequence: a #ClutterEventSequence
+ *
+ * Start tracking informations related to a touch point (position,
+ * actor underneath the touch point).
+ */
+void
+_clutter_input_device_add_event_sequence (ClutterInputDevice *device,
+                                          ClutterEvent       *event)
+{
+  ClutterEventSequence *sequence = clutter_event_get_event_sequence (event);
+  ClutterStage *stage;
+
+  if (sequence == NULL)
+    return;
+
+  stage = clutter_event_get_stage (event);
+  if (stage == NULL)
+    return;
+
+  _clutter_input_device_ensure_touch_info (device, sequence, stage);
+}
+
 /*< private >
 * clutter_input_device_remove_sequence:
 * @device: a #ClutterInputDevice
@@ -1314,25 +1686,25 @@ _clutter_input_device_remove_event_sequence (ClutterInputDevice *device,
                                             ClutterEvent       *event)
 {
  ClutterEventSequence *sequence = clutter_event_get_event_sequence (event);
-  ClutterActor *actor =
-    g_hash_table_lookup (device->touch_sequence_actors, sequence);
+  ClutterTouchInfo *info =
+    g_hash_table_lookup (device->touch_sequences_info, sequence);

-  if (actor != NULL)
+  if (info == NULL)
+    return;
+
+  if (info->actor != NULL)
    {
      GList *sequences =
-        g_hash_table_lookup (device->inv_touch_sequence_actors, actor);
-      graphene_point_t point;
+        g_hash_table_lookup (device->inv_touch_sequence_actors, info->actor);

      sequences = g_list_remove (sequences, sequence);

      g_hash_table_replace (device->inv_touch_sequence_actors,
-                            actor, sequences);
-      clutter_event_get_coords (event, &point.x, &point.y);
-      _clutter_input_device_set_actor (device, sequence, NULL, TRUE, point,
-                                       clutter_event_get_time (event));
+                            info->actor, sequences);
+      _clutter_input_device_set_actor (device, sequence, NULL, TRUE);
    }

-  g_hash_table_remove (device->touch_sequence_actors, sequence);
+  g_hash_table_remove (device->touch_sequences_info, sequence);
 }

 /**
@@ -2022,6 +2394,43 @@ clutter_input_device_get_device_node (ClutterInputDevice *device)
  return device->node_path;
 }

+ClutterInputDeviceMapping
+clutter_input_device_get_mapping_mode (ClutterInputDevice *device)
+{
+  ClutterInputDeviceType device_type;
+
+  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device),
+                        CLUTTER_INPUT_DEVICE_MAPPING_ABSOLUTE);
+
+  device_type = clutter_input_device_get_device_type (device);
+  g_return_val_if_fail (device_type == CLUTTER_TABLET_DEVICE ||
+                        device_type == CLUTTER_PEN_DEVICE ||
+                        device_type == CLUTTER_ERASER_DEVICE,
+                        CLUTTER_INPUT_DEVICE_MAPPING_ABSOLUTE);
+
+  return device->mapping_mode;
+}
+
+void
+clutter_input_device_set_mapping_mode (ClutterInputDevice        *device,
+                                       ClutterInputDeviceMapping  mapping)
+{
+  ClutterInputDeviceType device_type;
+
+  g_return_if_fail (CLUTTER_IS_INPUT_DEVICE (device));
+
+  device_type = clutter_input_device_get_device_type (device);
+  g_return_if_fail (device_type == CLUTTER_TABLET_DEVICE ||
+                    device_type == CLUTTER_PEN_DEVICE ||
+                    device_type == CLUTTER_ERASER_DEVICE);
+
+  if (device->mapping_mode == mapping)
+    return;
+
+  device->mapping_mode = mapping;
+  g_object_notify (G_OBJECT (device), "mapping-mode");
+}
+
 gboolean
 clutter_input_device_is_grouped (ClutterInputDevice *device,
                                 ClutterInputDevice *other_device)
--- a/clutter/clutter/clutter-input-device.h
+++ b/clutter/clutter/clutter-input-device.h
@@ -92,14 +92,20 @@ gboolean                clutter_input_device_get_coords        (ClutterInputDevi
 CLUTTER_EXPORT
 ClutterModifierType     clutter_input_device_get_modifier_state (ClutterInputDevice  *device);
 CLUTTER_EXPORT
-ClutterActor *          clutter_input_device_get_actor (ClutterInputDevice   *device,
-                                                        ClutterEventSequence *sequence);
+ClutterActor *          clutter_input_device_get_pointer_actor  (ClutterInputDevice  *device);
+CLUTTER_EXPORT
+ClutterStage *          clutter_input_device_get_pointer_stage  (ClutterInputDevice  *device);
 CLUTTER_EXPORT
 const gchar *           clutter_input_device_get_device_name    (ClutterInputDevice  *device);
 CLUTTER_EXPORT
 ClutterInputMode        clutter_input_device_get_device_mode    (ClutterInputDevice  *device);
 CLUTTER_EXPORT
 gboolean                clutter_input_device_get_has_cursor     (ClutterInputDevice  *device);
+CLUTTER_EXPORT
+void                    clutter_input_device_set_enabled        (ClutterInputDevice  *device,
+                                                                 gboolean             enabled);
+CLUTTER_EXPORT
+gboolean                clutter_input_device_get_enabled        (ClutterInputDevice  *device);

 CLUTTER_EXPORT
 guint                   clutter_input_device_get_n_axes         (ClutterInputDevice  *device);
@@ -115,6 +121,11 @@ gboolean                clutter_input_device_get_axis_value     (ClutterInputDev
 CLUTTER_EXPORT
 guint                   clutter_input_device_get_n_keys         (ClutterInputDevice  *device);
 CLUTTER_EXPORT
+void                    clutter_input_device_set_key            (ClutterInputDevice  *device,
+                                                                 guint                index_,
+                                                                 guint                keyval,
+                                                                 ClutterModifierType  modifiers);
+CLUTTER_EXPORT
 gboolean                clutter_input_device_get_key            (ClutterInputDevice  *device,
                                                                 guint                index_,
                                                                 guint               *keyval,
@@ -125,6 +136,11 @@ ClutterInputDevice *    clutter_input_device_get_associated_device (ClutterInput
 CLUTTER_EXPORT
 GList *                 clutter_input_device_get_slave_devices  (ClutterInputDevice  *device);

+CLUTTER_EXPORT
+void                    clutter_input_device_update_from_event  (ClutterInputDevice  *device,
+                                                                 ClutterEvent        *event,
+                                                                 gboolean             update_stage);
+
 CLUTTER_EXPORT
 void                    clutter_input_device_grab               (ClutterInputDevice  *device,
                                                                 ClutterActor        *actor);
@@ -144,6 +160,11 @@ CLUTTER_EXPORT
 ClutterActor *          clutter_input_device_sequence_get_grabbed_actor (ClutterInputDevice   *device,
                                                                         ClutterEventSequence *sequence);

+CLUTTER_EXPORT
+gboolean                clutter_input_device_keycode_to_evdev   (ClutterInputDevice *device,
+                                                                 guint               hardware_keycode,
+                                                                 guint              *evdev_keycode);
+
 CLUTTER_EXPORT
 const gchar *           clutter_input_device_get_vendor_id      (ClutterInputDevice *device);
 CLUTTER_EXPORT
@@ -171,6 +192,12 @@ gint                    clutter_input_device_get_mode_switch_button_group (Clutt
 CLUTTER_EXPORT
 const gchar *           clutter_input_device_get_device_node    (ClutterInputDevice *device);

+CLUTTER_EXPORT
+ClutterInputDeviceMapping clutter_input_device_get_mapping_mode (ClutterInputDevice *device);
+
+CLUTTER_EXPORT
+void                      clutter_input_device_set_mapping_mode (ClutterInputDevice        *device,
+                                                                 ClutterInputDeviceMapping  mapping);
 CLUTTER_EXPORT
 gboolean                  clutter_input_device_is_grouped       (ClutterInputDevice *device,
                                                                 ClutterInputDevice *other_device);
--- a/clutter/clutter/clutter-input-focus-private.h
+++ b/clutter/clutter/clutter-input-focus-private.h
@@ -29,7 +29,7 @@ void clutter_input_focus_focus_out (ClutterInputFocus  *focus);
 void clutter_input_focus_commit (ClutterInputFocus *focus,
                                 const gchar       *text);
 void clutter_input_focus_delete_surrounding (ClutterInputFocus *focus,
-                                             int                offset,
+                                             guint              offset,
                                             guint              len);
 void clutter_input_focus_request_surrounding (ClutterInputFocus *focus);

--- a/clutter/clutter/clutter-input-focus.c
+++ b/clutter/clutter/clutter-input-focus.c
@@ -217,7 +217,7 @@ clutter_input_focus_commit (ClutterInputFocus *focus,

 void
 clutter_input_focus_delete_surrounding (ClutterInputFocus *focus,
-                                        int                offset,
+                                        guint              offset,
                                        guint              len)
 {
  g_return_if_fail (CLUTTER_IS_INPUT_FOCUS (focus));
--- a/clutter/clutter/clutter-input-focus.h
+++ b/clutter/clutter/clutter-input-focus.h
@@ -41,7 +41,7 @@ struct _ClutterInputFocusClass

  void (* request_surrounding) (ClutterInputFocus *focus);
  void (* delete_surrounding)  (ClutterInputFocus *focus,
-                                int                offset,
+                                guint              offset,
                                guint              len);
  void (* commit_text) (ClutterInputFocus *focus,
                        const gchar       *text);
--- a/clutter/clutter/clutter-input-method.c
+++ b/clutter/clutter/clutter-input-method.c
@@ -168,7 +168,7 @@ clutter_input_method_class_init (ClutterInputMethodClass *klass)
                  G_TYPE_FROM_CLASS (object_class),
                  G_SIGNAL_RUN_LAST,
                  0, NULL, NULL, NULL,
-                  G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_UINT);
+                  G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);
  signals[REQUEST_SURROUNDING] =
    g_signal_new ("request-surrounding",
                  G_TYPE_FROM_CLASS (object_class),
@@ -292,7 +292,7 @@ clutter_input_method_commit (ClutterInputMethod *im,

 void
 clutter_input_method_delete_surrounding (ClutterInputMethod *im,
-                                         int                 offset,
+                                         guint               offset,
                                         guint               len)
 {
  ClutterInputMethodPrivate *priv;
@@ -454,7 +454,6 @@ clutter_input_method_forward_key (ClutterInputMethod *im,
  ClutterInputMethodPrivate *priv;
  ClutterInputDevice *keyboard;
  ClutterSeat *seat;
-  ClutterStageManager *stage_manager;
  ClutterStage *stage;
  ClutterEvent *event;

@@ -465,9 +464,10 @@ clutter_input_method_forward_key (ClutterInputMethod *im,
    return;

  seat = clutter_backend_get_default_seat (clutter_get_default_backend ());
-  stage_manager = clutter_stage_manager_get_default ();
-  stage = clutter_stage_manager_get_default_stage (stage_manager);
  keyboard = clutter_seat_get_keyboard (seat);
+  stage = _clutter_input_device_get_stage (keyboard);
+  if (stage == NULL)
+    return;

  event = clutter_event_new (press ? CLUTTER_KEY_PRESS : CLUTTER_KEY_RELEASE);
  event->key.time = time_;
--- a/clutter/clutter/clutter-input-method.h
+++ b/clutter/clutter/clutter-input-method.h
@@ -68,7 +68,7 @@ void clutter_input_method_commit (ClutterInputMethod *im,
                                  const gchar        *text);
 CLUTTER_EXPORT
 void clutter_input_method_delete_surrounding (ClutterInputMethod *im,
-                                              int                 offset,
+                                              guint               offset,
                                              guint               len);
 CLUTTER_EXPORT
 void clutter_input_method_request_surrounding (ClutterInputMethod *im);
--- a/clutter/clutter/clutter-interval.c
+++ b/clutter/clutter/clutter-interval.c
@@ -37,6 +37,9 @@
 * any object taking a reference on a #ClutterInterval instance should
 * also take ownership of the interval by using g_object_ref_sink().
 *
+ * #ClutterInterval is used by #ClutterAnimation to define the
+ * interval of values that an implicit animation should tween over.
+ *
 * #ClutterInterval can be subclassed to override the validation
 * and value computation.
 *
--- a/clutter/clutter/clutter-layout-manager.c
+++ b/clutter/clutter/clutter-layout-manager.c
@@ -32,7 +32,8 @@
 * it has been paired, and it controls the allocation of its children.
 *
 * Any composite or container #ClutterActor subclass can delegate the
- * layouting of its children to a #ClutterLayoutManager.
+ * layouting of its children to a #ClutterLayoutManager. Clutter provides
+ * a generic container using #ClutterLayoutManager called #ClutterBox.
 *
 * Clutter provides some simple #ClutterLayoutManager sub-classes, like
 * #ClutterFlowLayout and #ClutterBinLayout.
@@ -96,7 +97,7 @@
 *
 * |[
 * {
- *   "type" : "ClutterActor",
+ *   "type" : "ClutterBox",
 *   "layout-manager" : { "type" : "ClutterGridLayout" },
 *   "children" : [
 *     {
@@ -135,6 +136,7 @@

 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "deprecated/clutter-container.h"
+#include "deprecated/clutter-alpha.h"

 #include "clutter-debug.h"
 #include "clutter-layout-manager.h"
@@ -162,6 +164,7 @@ G_DEFINE_ABSTRACT_TYPE (ClutterLayoutManager,
                        G_TYPE_INITIALLY_UNOWNED)

 static GQuark quark_layout_meta  = 0;
+static GQuark quark_layout_alpha = 0;

 static guint manager_signals[LAST_SIGNAL] = { 0, };

@@ -252,7 +255,8 @@ layout_manager_real_get_preferred_height (ClutterLayoutManager *manager,
 static void
 layout_manager_real_allocate (ClutterLayoutManager   *manager,
                              ClutterContainer       *container,
-                              const ClutterActorBox  *allocation)
+                              const ClutterActorBox  *allocation,
+                              ClutterAllocationFlags  flags)
 {
  LAYOUT_MANAGER_WARN_NOT_IMPLEMENTED (manager, "allocate");
 }
@@ -297,12 +301,96 @@ layout_manager_real_get_child_meta_type (ClutterLayoutManager *manager)
  return G_TYPE_INVALID;
 }

+/* XXX:2.0 - Remove */
+static ClutterAlpha *
+layout_manager_real_begin_animation (ClutterLayoutManager *manager,
+                                     guint                 duration,
+                                     gulong                mode)
+{
+  ClutterTimeline *timeline;
+  ClutterAlpha *alpha;
+
+  alpha = g_object_get_qdata (G_OBJECT (manager), quark_layout_alpha);
+  if (alpha != NULL)
+    {
+      clutter_alpha_set_mode (alpha, mode);
+
+      timeline = clutter_alpha_get_timeline (alpha);
+      clutter_timeline_set_duration (timeline, duration);
+      clutter_timeline_rewind (timeline);
+
+      return alpha;
+    };
+
+  timeline = clutter_timeline_new (duration);
+
+  alpha = clutter_alpha_new_full (timeline, mode);
+
+  /* let the alpha take ownership of the timeline */
+  g_object_unref (timeline);
+
+  g_signal_connect_swapped (timeline, "new-frame",
+                            G_CALLBACK (clutter_layout_manager_layout_changed),
+                            manager);
+
+  g_object_set_qdata_full (G_OBJECT (manager),
+                           quark_layout_alpha, alpha,
+                           (GDestroyNotify) g_object_unref);
+
+  clutter_timeline_start (timeline);
+
+  return alpha;
+}
+
+/* XXX:2.0 - Remove */
+static gdouble
+layout_manager_real_get_animation_progress (ClutterLayoutManager *manager)
+{
+  ClutterAlpha *alpha;
+
+  alpha = g_object_get_qdata (G_OBJECT (manager), quark_layout_alpha);
+  if (alpha == NULL)
+    return 1.0;
+
+  return clutter_alpha_get_alpha (alpha);
+}
+
+/* XXX:2.0 - Remove */
+static void
+layout_manager_real_end_animation (ClutterLayoutManager *manager)
+{
+  ClutterTimeline *timeline;
+  ClutterAlpha *alpha;
+
+  alpha = g_object_get_qdata (G_OBJECT (manager), quark_layout_alpha);
+  if (alpha == NULL)
+    return;
+
+  timeline = clutter_alpha_get_timeline (alpha);
+  g_assert (timeline != NULL);
+
+  if (clutter_timeline_is_playing (timeline))
+    clutter_timeline_stop (timeline);
+
+  g_signal_handlers_disconnect_by_func (timeline,
+                                        G_CALLBACK (clutter_layout_manager_layout_changed),
+                                        manager);
+
+  g_object_set_qdata (G_OBJECT (manager), quark_layout_alpha, NULL);
+
+  clutter_layout_manager_layout_changed (manager);
+}
+
 static void
 clutter_layout_manager_class_init (ClutterLayoutManagerClass *klass)
 {
  quark_layout_meta =
    g_quark_from_static_string ("clutter-layout-manager-child-meta");

+  /* XXX:2.0 - Remove */
+  quark_layout_alpha =
+    g_quark_from_static_string ("clutter-layout-manager-alpha");
+
  klass->get_preferred_width = layout_manager_real_get_preferred_width;
  klass->get_preferred_height = layout_manager_real_get_preferred_height;
  klass->allocate = layout_manager_real_allocate;
@@ -310,6 +398,9 @@ clutter_layout_manager_class_init (ClutterLayoutManagerClass *klass)
  klass->get_child_meta_type = layout_manager_real_get_child_meta_type;

  /* XXX:2.0 - Remove */
+  klass->begin_animation = layout_manager_real_begin_animation;
+  klass->get_animation_progress = layout_manager_real_get_animation_progress;
+  klass->end_animation = layout_manager_real_end_animation;
  klass->set_container = layout_manager_real_set_container;

  /**
@@ -432,6 +523,7 @@ clutter_layout_manager_get_preferred_height (ClutterLayoutManager *manager,
 * @container: the #ClutterContainer using @manager
 * @allocation: the #ClutterActorBox containing the allocated area
 *   of @container
+ * @flags: the allocation flags
 *
 * Allocates the children of @container given an area
 *
@@ -442,7 +534,8 @@ clutter_layout_manager_get_preferred_height (ClutterLayoutManager *manager,
 void
 clutter_layout_manager_allocate (ClutterLayoutManager   *manager,
                                 ClutterContainer       *container,
-                                 const ClutterActorBox  *allocation)
+                                 const ClutterActorBox  *allocation,
+                                 ClutterAllocationFlags  flags)
 {
  ClutterLayoutManagerClass *klass;

@@ -451,7 +544,7 @@ clutter_layout_manager_allocate (ClutterLayoutManager   *manager,
  g_return_if_fail (allocation != NULL);

  klass = CLUTTER_LAYOUT_MANAGER_GET_CLASS (manager);
-  klass->allocate (manager, container, allocation);
+  klass->allocate (manager, container, allocation, flags);
 }

 /**
--- a/clutter/clutter/clutter-layout-manager.h
+++ b/clutter/clutter/clutter-layout-manager.h
@@ -115,7 +115,8 @@ struct _ClutterLayoutManagerClass
                                                 gfloat                 *nat_height_p);
  void               (* allocate)               (ClutterLayoutManager   *manager,
                                                 ClutterContainer       *container,
-                                                 const ClutterActorBox  *allocation);
+                                                 const ClutterActorBox  *allocation,
+                                                 ClutterAllocationFlags  flags);

  void               (* set_container)          (ClutterLayoutManager   *manager,
                                                 ClutterContainer       *container);
@@ -125,6 +126,15 @@ struct _ClutterLayoutManagerClass
                                                 ClutterContainer       *container,
                                                 ClutterActor           *actor);

+  /* deprecated */
+  ClutterAlpha *     (* begin_animation)        (ClutterLayoutManager   *manager,
+                                                 guint                   duration,
+                                                 gulong                  mode);
+  /* deprecated */
+  gdouble            (* get_animation_progress) (ClutterLayoutManager   *manager);
+  /* deprecated */
+  void               (* end_animation)          (ClutterLayoutManager   *manager);
+
  void               (* layout_changed)         (ClutterLayoutManager   *manager);

  /*< private >*/
@@ -157,7 +167,8 @@ void               clutter_layout_manager_get_preferred_height  (ClutterLayoutMa
 CLUTTER_EXPORT
 void               clutter_layout_manager_allocate              (ClutterLayoutManager   *manager,
                                                                 ClutterContainer       *container,
-                                                                 const ClutterActorBox  *allocation);
+                                                                 const ClutterActorBox  *allocation,
+                                                                 ClutterAllocationFlags  flags);

 CLUTTER_EXPORT
 void               clutter_layout_manager_set_container         (ClutterLayoutManager   *manager,
--- a/clutter/clutter/clutter-main.c
+++ b/clutter/clutter/clutter-main.c
@@ -61,13 +61,19 @@
 #include "clutter-input-pointer-a11y-private.h"
 #include "clutter-graphene.h"
 #include "clutter-main.h"
+#include "clutter-master-clock.h"
 #include "clutter-mutter.h"
-#include "clutter-paint-node-private.h"
 #include "clutter-private.h"
 #include "clutter-settings-private.h"
 #include "clutter-stage-manager.h"
 #include "clutter-stage-private.h"
-#include "clutter-backend-private.h"
+
+#ifdef CLUTTER_WINDOWING_X11
+#include "x11/clutter-backend-x11.h"
+#endif
+#ifdef CLUTTER_WINDOWING_EGL
+#include "egl/clutter-backend-eglnative.h"
+#endif

 #include <cogl/cogl.h>
 #include <cogl-pango/cogl-pango.h>
@@ -76,12 +82,17 @@

 /* main context */
 static ClutterMainContext *ClutterCntx       = NULL;
+G_LOCK_DEFINE_STATIC (ClutterCntx);
+
+/* main lock and locking/unlocking functions */
+static GMutex clutter_threads_mutex;

 /* command line options */
 static gboolean clutter_is_initialized       = FALSE;
 static gboolean clutter_show_fps             = FALSE;
 static gboolean clutter_fatal_warnings       = FALSE;
 static gboolean clutter_disable_mipmap_text  = FALSE;
+static gboolean clutter_use_fuzzy_picking    = FALSE;
 static gboolean clutter_enable_accessibility = TRUE;
 static gboolean clutter_sync_to_vblank       = TRUE;

@@ -89,6 +100,9 @@ static guint clutter_default_fps             = 60;

 static ClutterTextDirection clutter_text_direction = CLUTTER_TEXT_DIRECTION_LTR;

+static guint clutter_main_loop_level         = 0;
+static GSList *main_loops                    = NULL;
+
 /* debug flags */
 guint clutter_debug_flags       = 0;
 guint clutter_paint_debug_flags = 0;
@@ -130,6 +144,12 @@ static const GDebugKey clutter_paint_debug_keys[] = {
  { "damage-region", CLUTTER_DEBUG_PAINT_DAMAGE_REGION },
 };

+static inline void
+clutter_threads_init_default (void)
+{
+  g_mutex_init (&clutter_threads_mutex);
+}
+
 #define ENVIRONMENT_GROUP       "Environment"
 #define DEBUG_GROUP             "Debug"

@@ -175,6 +195,16 @@ clutter_config_read_from_key_file (GKeyFile *keyfile)
  else
    clutter_disable_mipmap_text = bool_value;

+  bool_value =
+    g_key_file_get_boolean (keyfile, ENVIRONMENT_GROUP,
+                            "UseFuzzyPicking",
+                            &key_error);
+
+  if (key_error != NULL)
+    g_clear_error (&key_error);
+  else
+    clutter_use_fuzzy_picking = bool_value;
+
  bool_value =
    g_key_file_get_boolean (keyfile, ENVIRONMENT_GROUP,
                            "EnableAccessibility",
@@ -429,15 +459,93 @@ clutter_get_text_direction (void)
  return dir;
 }

+/**
+ * clutter_main_quit:
+ *
+ * Terminates the Clutter mainloop.
+ */
+void
+clutter_main_quit (void)
+{
+  if (main_loops == NULL)
+    {
+      g_critical ("Calling clutter_main_quit() without calling clutter_main() "
+                  "is not allowed. If you are using another main loop, use the "
+                  "appropriate API to terminate it.");
+      return;
+    }
+
+  CLUTTER_NOTE (MISC, "Terminating main loop level %d", clutter_main_loop_level);
+
+  g_main_loop_quit (main_loops->data);
+}
+
+/**
+ * clutter_main_level:
+ *
+ * Retrieves the depth of the Clutter mainloop.
+ *
+ * Return value: The level of the mainloop.
+ */
+gint
+clutter_main_level (void)
+{
+  return clutter_main_loop_level;
+}
+
+/**
+ * clutter_main:
+ *
+ * Starts the Clutter mainloop.
+ */
+void
+clutter_main (void)
+{
+  GMainLoop *loop;
+
+  if (!_clutter_context_is_initialized ())
+    {
+      g_warning ("Called clutter_main() but Clutter wasn't initialised. "
+		 "You must call clutter_init() first.");
+      return;
+    }
+
+  clutter_main_loop_level++;
+
+  CLUTTER_NOTE (MISC, "Entering main loop level %d", clutter_main_loop_level);
+
+  loop = g_main_loop_new (NULL, TRUE);
+  main_loops = g_slist_prepend (main_loops, loop);
+
+  if (g_main_loop_is_running (main_loops->data))
+    {
+      _clutter_threads_release_lock ();
+      g_main_loop_run (loop);
+      _clutter_threads_acquire_lock ();
+    }
+
+  main_loops = g_slist_remove (main_loops, loop);
+
+  g_main_loop_unref (loop);
+
+  CLUTTER_NOTE (MISC, "Leaving main loop level %d", clutter_main_loop_level);
+
+  clutter_main_loop_level--;
+}
+
 gboolean
 _clutter_threads_dispatch (gpointer data)
 {
  ClutterThreadsDispatch *dispatch = data;
  gboolean ret = FALSE;

+  _clutter_threads_acquire_lock ();
+
  if (!g_source_is_destroyed (g_main_current_source ()))
    ret = dispatch->func (dispatch->data);

+  _clutter_threads_release_lock ();
+
  return ret;
 }

@@ -662,6 +770,40 @@ clutter_threads_add_timeout (guint       interval,
                                           NULL);
 }

+void
+_clutter_threads_acquire_lock (void)
+{
+  g_mutex_lock (&clutter_threads_mutex);
+}
+
+void
+_clutter_threads_release_lock (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);
+}
+
+void
+_clutter_context_lock (void)
+{
+  G_LOCK (ClutterCntx);
+}
+
+void
+_clutter_context_unlock (void)
+{
+  G_UNLOCK (ClutterCntx);
+}
+
 gboolean
 _clutter_context_is_initialized (void)
 {
@@ -671,8 +813,8 @@ _clutter_context_is_initialized (void)
  return ClutterCntx->is_initialized;
 }

-ClutterMainContext *
-_clutter_context_get_default (void)
+static ClutterMainContext *
+clutter_context_get_default_unlocked (void)
 {
  if (G_UNLIKELY (ClutterCntx == NULL))
    {
@@ -697,14 +839,26 @@ _clutter_context_get_default (void)
      ctx->settings = clutter_settings_get_default ();
      _clutter_settings_set_backend (ctx->settings, ctx->backend);

-      ctx->events_queue = g_async_queue_new ();
-
      ctx->last_repaint_id = 1;
    }

  return ClutterCntx;
 }

+ClutterMainContext *
+_clutter_context_get_default (void)
+{
+  ClutterMainContext *retval;
+
+  _clutter_context_lock ();
+
+  retval = clutter_context_get_default_unlocked ();
+
+  _clutter_context_unlock ();
+
+  return retval;
+}
+
 static gboolean
 clutter_arg_direction_cb (const char *key,
                          const char *value,
@@ -816,9 +970,6 @@ clutter_init_real (GError **error)
  if (clutter_enable_accessibility)
    cally_accessibility_init ();

-  /* Initialize types required for paint nodes */
-  _clutter_paint_node_init_types ();
-
  return CLUTTER_INIT_SUCCESS;
 }

@@ -835,6 +986,9 @@ static GOptionEntry clutter_args[] = {
  { "clutter-disable-mipmapped-text", 0, 0, G_OPTION_ARG_NONE,
    &clutter_disable_mipmap_text,
    N_("Disable mipmapping on text"), NULL },
+  { "clutter-use-fuzzy-picking", 0, 0, G_OPTION_ARG_NONE,
+    &clutter_use_fuzzy_picking,
+    N_("Use 'fuzzy' picking"), NULL },
 #ifdef CLUTTER_ENABLE_DEBUG
  { "clutter-debug", 0, 0, G_OPTION_ARG_CALLBACK, clutter_arg_debug_cb,
    N_("Clutter debugging flags to set"), "FLAGS" },
@@ -916,6 +1070,10 @@ pre_parse_hook (GOptionContext  *context,
  if (env_string)
    clutter_disable_mipmap_text = TRUE;

+  env_string = g_getenv ("CLUTTER_FUZZY_PICK");
+  if (env_string)
+    clutter_use_fuzzy_picking = TRUE;
+
  return _clutter_backend_pre_parse (backend, error);
 }

@@ -1574,11 +1732,6 @@ _clutter_process_event_details (ClutterActor        *stage,
                                ClutterEvent        *event)
 {
  ClutterInputDevice *device = clutter_event_get_device (event);
-  ClutterMainContext *clutter_context;
-  ClutterBackend *backend;
-
-  clutter_context = _clutter_context_get_default ();
-  backend = clutter_context->backend;

  switch (event->type)
    {
@@ -1623,9 +1776,7 @@ _clutter_process_event_details (ClutterActor        *stage,

            emit_crossing_event (event, device);

-            actor = clutter_input_device_update (device, NULL,
-                                                 CLUTTER_STAGE (stage), FALSE,
-                                                 event);
+            actor = clutter_input_device_update (device, NULL, FALSE);
            if (actor != stage)
              {
                ClutterEvent *crossing;
@@ -1666,6 +1817,7 @@ _clutter_process_event_details (ClutterActor        *stage,
        break;

      case CLUTTER_DESTROY_NOTIFY:
+      case CLUTTER_DELETE:
        event->any.source = stage;

        if (_clutter_event_process_filters (event))
@@ -1676,7 +1828,8 @@ _clutter_process_event_details (ClutterActor        *stage,
        break;

      case CLUTTER_MOTION:
-        if (clutter_backend_is_display_server (backend) &&
+#ifdef CLUTTER_WINDOWING_X11
+        if (!clutter_check_windowing_backend (CLUTTER_WINDOWING_X11) &&
            !(event->any.flags & CLUTTER_EVENT_FLAG_SYNTHETIC))
          {
            if (_clutter_is_input_pointer_a11y_enabled (device))
@@ -1687,6 +1840,7 @@ _clutter_process_event_details (ClutterActor        *stage,
                _clutter_input_pointer_a11y_on_motion_event (device, 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)
@@ -1717,7 +1871,8 @@ _clutter_process_event_details (ClutterActor        *stage,
        G_GNUC_FALLTHROUGH;
      case CLUTTER_BUTTON_PRESS:
      case CLUTTER_BUTTON_RELEASE:
-        if (clutter_backend_is_display_server (backend))
+#ifdef CLUTTER_WINDOWING_X11
+        if (!clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))
          {
            if (_clutter_is_input_pointer_a11y_enabled (device) && (event->type != CLUTTER_MOTION))
              {
@@ -1726,6 +1881,7 @@ _clutter_process_event_details (ClutterActor        *stage,
                                                             event->type == CLUTTER_BUTTON_PRESS);
              }
          }
+#endif /* CLUTTER_WINDOWING_X11 */
      case CLUTTER_SCROLL:
      case CLUTTER_TOUCHPAD_PINCH:
      case CLUTTER_TOUCHPAD_SWIPE:
@@ -1774,9 +1930,21 @@ _clutter_process_event_details (ClutterActor        *stage,
                  break;
                }

-              actor = clutter_input_device_update (device, NULL,
-                                                   CLUTTER_STAGE (stage),
-                                                   TRUE, event);
+              /* if the backend provides a device then we should
+               * already have everything we need to update it and
+               * get the actor underneath
+               */
+              if (device != NULL)
+                actor = clutter_input_device_update (device, NULL, TRUE);
+              else
+                {
+                  CLUTTER_NOTE (EVENT, "No device found: picking");
+
+                  actor = _clutter_stage_do_pick (CLUTTER_STAGE (stage),
+                                                  x, y,
+                                                  CLUTTER_PICK_REACTIVE);
+                }
+
              if (actor == NULL)
                break;

@@ -1852,6 +2020,9 @@ _clutter_process_event_details (ClutterActor        *stage,
          sequence =
            clutter_event_get_event_sequence (event);

+          if (event->type == CLUTTER_TOUCH_BEGIN)
+            _clutter_input_device_add_event_sequence (device, event);
+
          clutter_event_get_coords (event, &x, &y);

          /* Only do a pick to find the source if source is not already set
@@ -1874,16 +2045,23 @@ _clutter_process_event_details (ClutterActor        *stage,

                  emit_touch_event (event, device);

-                  if (event->type == CLUTTER_TOUCH_END ||
-                      event->type == CLUTTER_TOUCH_CANCEL)
+                  if (event->type == CLUTTER_TOUCH_END)
                    _clutter_input_device_remove_event_sequence (device, event);

                  break;
                }

-              actor = clutter_input_device_update (device, sequence,
-                                                   CLUTTER_STAGE (stage),
-                                                   TRUE, event);
+              if (device != NULL)
+                actor = clutter_input_device_update (device, sequence, TRUE);
+              else
+                {
+                  CLUTTER_NOTE (EVENT, "No device found: picking");
+
+                  actor = _clutter_stage_do_pick (CLUTTER_STAGE (stage),
+                                                  x, y,
+                                                  CLUTTER_PICK_REACTIVE);
+                }
+
              if (actor == NULL)
                break;

@@ -1902,8 +2080,7 @@ _clutter_process_event_details (ClutterActor        *stage,

          emit_touch_event (event, device);

-          if (event->type == CLUTTER_TOUCH_END ||
-              event->type == CLUTTER_TOUCH_CANCEL)
+          if (event->type == CLUTTER_TOUCH_END)
            _clutter_input_device_remove_event_sequence (device, event);

          break;
@@ -1935,11 +2112,6 @@ _clutter_process_event_details (ClutterActor        *stage,
      case CLUTTER_CLIENT_MESSAGE:
        break;

-      case CLUTTER_DEVICE_ADDED:
-      case CLUTTER_DEVICE_REMOVED:
-        _clutter_event_process_filters (event);
-        break;
-
      case CLUTTER_EVENT_LAST:
        break;
    }
@@ -1978,6 +2150,27 @@ _clutter_process_event (ClutterEvent *event)
  context->current_event = g_slist_delete_link (context->current_event, context->current_event);
 }

+/**
+ * clutter_get_actor_by_gid:
+ * @id_: a #ClutterActor unique id.
+ *
+ * Retrieves the #ClutterActor with @id_.
+ *
+ * Return value: (transfer none): the actor with the passed id or %NULL.
+ *   The returned actor does not have its reference count increased.
+ *
+ * Since: 0.6
+ *
+ * Deprecated: 1.8: The id is deprecated, and this function always returns
+ *   %NULL. Use the proper scene graph API in #ClutterActor to find a child
+ *   of the stage.
+ */
+ClutterActor *
+clutter_get_actor_by_gid (guint32 id_)
+{
+  return NULL;
+}
+
 void
 clutter_base_init (void)
 {
@@ -1992,6 +2185,9 @@ clutter_base_init (void)
      g_type_init ();
 #endif

+      /* initialise the Big Clutter Lock™ if necessary */
+      clutter_threads_init_default ();
+
      clutter_graphene_init ();
    }
 }
@@ -2059,7 +2255,9 @@ clutter_threads_remove_repaint_func (guint handle_id)

  g_return_if_fail (handle_id > 0);

-  context = _clutter_context_get_default ();
+  _clutter_context_lock ();
+
+  context = clutter_context_get_default_unlocked ();
  l = context->repaint_funcs;
  while (l != NULL)
    {
@@ -2082,6 +2280,8 @@ clutter_threads_remove_repaint_func (guint handle_id)

      l = l->next;
    }
+
+  _clutter_context_unlock ();
 }

 /**
@@ -2180,13 +2380,16 @@ clutter_threads_add_repaint_func_full (ClutterRepaintFlags flags,

  g_return_val_if_fail (func != NULL, 0);

-  context = _clutter_context_get_default ();
+  _clutter_context_lock ();
+
+  context = clutter_context_get_default_unlocked ();

  repaint_func = g_slice_new (ClutterRepaintFunction);

  repaint_func->id = context->last_repaint_id++;

-  repaint_func->flags = flags;
+  /* mask out QUEUE_REDRAW_ON_ADD, since we're going to consume it */
+  repaint_func->flags = flags & ~CLUTTER_REPAINT_FLAGS_QUEUE_REDRAW_ON_ADD;
  repaint_func->func = func;
  repaint_func->data = data;
  repaint_func->notify = notify;
@@ -2194,6 +2397,15 @@ clutter_threads_add_repaint_func_full (ClutterRepaintFlags flags,
  context->repaint_funcs = g_list_prepend (context->repaint_funcs,
                                           repaint_func);

+  _clutter_context_unlock ();
+
+  if ((flags & CLUTTER_REPAINT_FLAGS_QUEUE_REDRAW_ON_ADD) != 0)
+    {
+      ClutterMasterClock *master_clock = _clutter_master_clock_get_default ();
+
+      _clutter_master_clock_ensure_next_iteration (master_clock);
+    }
+
  return repaint_func->id;
 }

@@ -2288,16 +2500,39 @@ void
 _clutter_clear_events_queue (void)
 {
  ClutterMainContext *context = _clutter_context_get_default ();
-  ClutterEvent *event;

-  /* Lock the queue for as long as it lives */
-  g_async_queue_lock (context->events_queue);
+  if (context->events_queue != NULL)
+    {
+      g_queue_foreach (context->events_queue,
+                       (GFunc) clutter_event_free,
+                       NULL);
+      g_queue_free (context->events_queue);
+      context->events_queue = NULL;
+    }
+}

-  while ((event = g_async_queue_try_pop_unlocked (context->events_queue)))
-    clutter_event_free (event);
+void
+_clutter_clear_events_queue_for_stage (ClutterStage *stage)
+{
+  ClutterMainContext *context = _clutter_context_get_default ();
+  GList *l, *next;

-  g_async_queue_unref (context->events_queue);
-  context->events_queue = NULL;
+  if (context->events_queue == NULL)
+    return;
+
+  /* Remove any pending events for this stage from the event queue */
+  for (l = context->events_queue->head; l; l = next)
+    {
+      ClutterEvent *event = l->data;
+
+      next = l->next;
+
+      if (event->any.stage == stage)
+        {
+          g_queue_delete_link (context->events_queue, l);
+          clutter_event_free (event);
+        }
+    }
 }

 ClutterPickMode
@@ -2308,6 +2543,58 @@ _clutter_context_get_pick_mode (void)
  return context->pick_mode;
 }

+/**
+ * clutter_check_windowing_backend:
+ * @backend_type: the name of the backend to check
+ *
+ * Checks the run-time name of the Clutter windowing system backend, using
+ * the symbolic macros like %CLUTTER_WINDOWING_X11.
+ *
+ * This function should be used in conjuction with the compile-time macros
+ * inside applications and libraries that are using the platform-specific
+ * windowing system API, to ensure that they are running on the correct
+ * windowing system; for instance:
+ *
+ * |[
+ * #ifdef CLUTTER_WINDOWING_X11
+ *   if (clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))
+ *     {
+ *       // it is safe to use the clutter_x11_* API
+ *     }
+ *   else
+ * #endif
+ *     g_error ("Unknown Clutter backend.");
+ * ]|
+ *
+ * Return value: %TRUE if the current Clutter windowing system backend is
+ *   the one checked, and %FALSE otherwise
+ *
+ * Since: 1.10
+ */
+gboolean
+clutter_check_windowing_backend (const char *backend_type)
+{
+  ClutterMainContext *context = _clutter_context_get_default ();
+
+  g_return_val_if_fail (backend_type != NULL, FALSE);
+
+  backend_type = g_intern_string (backend_type);
+
+#ifdef CLUTTER_WINDOWING_EGL
+  if (backend_type == I_(CLUTTER_WINDOWING_EGL) &&
+      CLUTTER_IS_BACKEND_EGL_NATIVE (context->backend))
+    return TRUE;
+  else
+#endif
+#ifdef CLUTTER_WINDOWING_X11
+  if (backend_type == I_(CLUTTER_WINDOWING_X11) &&
+      CLUTTER_IS_BACKEND_X11 (context->backend))
+    return TRUE;
+  else
+#endif
+  return FALSE;
+}
+
 /**
 * clutter_add_debug_flags: (skip)
 *
--- a/clutter/clutter/clutter-main.h
+++ b/clutter/clutter/clutter-main.h
@@ -136,6 +136,14 @@ GOptionGroup *          clutter_get_option_group                (void);
 CLUTTER_EXPORT
 GOptionGroup *          clutter_get_option_group_without_init   (void);

+/* Mainloop */
+CLUTTER_EXPORT
+void                    clutter_main                            (void);
+CLUTTER_EXPORT
+void                    clutter_main_quit                       (void);
+CLUTTER_EXPORT
+gint                    clutter_main_level                      (void);
+
 CLUTTER_EXPORT
 void                    clutter_do_event                        (ClutterEvent *event);

@@ -186,6 +194,9 @@ ClutterTextDirection    clutter_get_default_text_direction      (void);
 CLUTTER_EXPORT
 guint                   clutter_get_default_frame_rate          (void);

+CLUTTER_EXPORT
+gboolean                clutter_check_windowing_backend         (const char *backend_type);
+
 CLUTTER_EXPORT
 void                    clutter_add_debug_flags                 (ClutterDebugFlag     debug_flags,
                                                                 ClutterDrawDebugFlag draw_flags,
--- a/clutter/clutter/clutter-master-clock-default.c
+++ b/clutter/clutter/clutter-master-clock-default.c
@@ -0,0 +1,612 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By: Emmanuele Bassi <ebassi@linux.intel.com>
+ *
+ * Copyright (C) 2009  Intel Corporation.
+ *
+ * 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/>.
+ */
+
+/*
+ * SECTION:clutter-master-clock-default
+ * @short_description: The default master clock for all animations
+ *
+ * The #ClutterMasterClockDefault class is the default implementation
+ * of #ClutterMasterClock.
+ */
+
+#include "clutter-build-config.h"
+
+#include "clutter-master-clock.h"
+#include "clutter-master-clock-default.h"
+#include "clutter-debug.h"
+#include "clutter-private.h"
+#include "clutter-stage-manager-private.h"
+#include "clutter-stage-private.h"
+
+#ifdef CLUTTER_ENABLE_DEBUG
+#define clutter_warn_if_over_budget(master_clock,start_time,section)    G_STMT_START  { \
+  gint64 __delta = g_get_monotonic_time () - start_time;                                \
+  gint64 __budget = master_clock->remaining_budget;                                     \
+  if (__budget > 0 && __delta >= __budget) {                                            \
+    _clutter_diagnostic_message ("%s took %" G_GINT64_FORMAT " microseconds "           \
+                                 "more than the remaining budget of %" G_GINT64_FORMAT  \
+                                 " microseconds",                                       \
+                                 section, __delta - __budget, __budget);                \
+  }                                                                     } G_STMT_END
+#else
+#define clutter_warn_if_over_budget(master_clock,start_time,section)
+#endif
+
+typedef struct _ClutterClockSource              ClutterClockSource;
+
+struct _ClutterMasterClockDefault
+{
+  GObject parent_instance;
+
+  /* the list of timelines handled by the clock */
+  GSList *timelines;
+
+  /* the current state of the clock, in usecs */
+  gint64 cur_tick;
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  gint64 frame_budget;
+  gint64 remaining_budget;
+#endif
+
+  /* an idle source, used by the Master Clock to queue
+   * a redraw on the stage and drive the animations
+   */
+  GSource *source;
+
+  guint ensure_next_iteration : 1;
+
+  guint paused : 1;
+};
+
+struct _ClutterClockSource
+{
+  GSource source;
+
+  ClutterMasterClockDefault *master_clock;
+};
+
+static gboolean clutter_clock_prepare  (GSource     *source,
+                                        gint        *timeout);
+static gboolean clutter_clock_check    (GSource     *source);
+static gboolean clutter_clock_dispatch (GSource     *source,
+                                        GSourceFunc  callback,
+                                        gpointer     user_data);
+
+static GSourceFuncs clock_funcs = {
+  clutter_clock_prepare,
+  clutter_clock_check,
+  clutter_clock_dispatch,
+  NULL
+};
+
+static void
+clutter_master_clock_iface_init (ClutterMasterClockInterface *iface);
+
+#define clutter_master_clock_default_get_type   _clutter_master_clock_default_get_type
+
+G_DEFINE_TYPE_WITH_CODE (ClutterMasterClockDefault,
+                         clutter_master_clock_default,
+                         G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_MASTER_CLOCK,
+                                                clutter_master_clock_iface_init));
+
+/*
+ * master_clock_is_running:
+ * @master_clock: a #ClutterMasterClock
+ *
+ * Checks if we should currently be advancing timelines or redrawing
+ * stages.
+ *
+ * Return value: %TRUE if the #ClutterMasterClock has at least
+ *   one running timeline
+ */
+static gboolean
+master_clock_is_running (ClutterMasterClockDefault *master_clock)
+{
+  ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+  const GSList *stages, *l;
+
+  stages = clutter_stage_manager_peek_stages (stage_manager);
+
+  if (master_clock->paused)
+    return FALSE;
+
+  if (master_clock->timelines)
+    return TRUE;
+
+  for (l = stages; l; l = l->next)
+    {
+      if (clutter_actor_is_mapped (l->data) &&
+          (_clutter_stage_has_queued_events (l->data) ||
+           _clutter_stage_needs_update (l->data)))
+        return TRUE;
+    }
+
+  if (master_clock->ensure_next_iteration)
+    {
+      master_clock->ensure_next_iteration = FALSE;
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gint
+master_clock_get_swap_wait_time (ClutterMasterClockDefault *master_clock)
+{
+  ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+  const GSList *stages, *l;
+  gint64 min_update_time = -1;
+
+  stages = clutter_stage_manager_peek_stages (stage_manager);
+
+  for (l = stages; l != NULL; l = l->next)
+    {
+      gint64 update_time = _clutter_stage_get_update_time (l->data);
+      if (min_update_time == -1 ||
+          (update_time != -1 && update_time < min_update_time))
+        min_update_time = update_time;
+    }
+
+  if (min_update_time == -1)
+    {
+      return -1;
+    }
+  else
+    {
+      gint64 now = g_source_get_time (master_clock->source);
+      if (min_update_time < now)
+        {
+          return 0;
+        }
+      else
+        {
+          gint64 delay_us = min_update_time - now;
+          return (delay_us + 999) / 1000;
+        }
+    }
+}
+
+static void
+master_clock_schedule_stage_updates (ClutterMasterClockDefault *master_clock)
+{
+  ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+  const GSList *stages, *l;
+
+  stages = clutter_stage_manager_peek_stages (stage_manager);
+
+  for (l = stages; l != NULL; l = l->next)
+    _clutter_stage_schedule_update (l->data);
+}
+
+static GSList *
+master_clock_list_ready_stages (ClutterMasterClockDefault *master_clock)
+{
+  ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+  const GSList *stages, *l;
+  GSList *result;
+
+  stages = clutter_stage_manager_peek_stages (stage_manager);
+
+  result = NULL;
+  for (l = stages; l != NULL; l = l->next)
+    {
+      gint64 update_time = _clutter_stage_get_update_time (l->data);
+      /* We carefully avoid to update stages that aren't mapped, because
+       * they have nothing to render and this could cause a deadlock with
+       * some of the SwapBuffers implementations (in particular
+       * GLX_INTEL_swap_event is not emitted if nothing was rendered).
+       *
+       * Also, if a stage has a swap-buffers pending we don't want to draw
+       * to it in case the driver may block the CPU while it waits for the
+       * next backbuffer to become available.
+       *
+       * TODO: We should be able to identify if we are running triple or N
+       * buffered and in these cases we can still draw if there is 1 swap
+       * pending so we can hopefully always be ready to swap for the next
+       * vblank and really match the vsync frequency.
+       */
+      if (clutter_actor_is_mapped (l->data) &&
+          update_time != -1 && update_time <= master_clock->cur_tick)
+        result = g_slist_prepend (result, g_object_ref (l->data));
+    }
+
+  return g_slist_reverse (result);
+}
+
+static void
+master_clock_reschedule_stage_updates (ClutterMasterClockDefault *master_clock,
+                                       GSList                    *stages)
+{
+  const GSList *l;
+
+  for (l = stages; l != NULL; l = l->next)
+    {
+      /* Clear the old update time */
+      _clutter_stage_clear_update_time (l->data);
+
+      /* And if there is still work to be done, schedule a new one */
+      if (master_clock->timelines ||
+          _clutter_stage_has_queued_events (l->data) ||
+          _clutter_stage_needs_update (l->data))
+        _clutter_stage_schedule_update (l->data);
+    }
+}
+
+/*
+ * master_clock_next_frame_delay:
+ * @master_clock: a #ClutterMasterClock
+ *
+ * Computes the number of delay before we need to draw the next frame.
+ *
+ * Return value: -1 if there is no next frame pending, otherwise the
+ *  number of millseconds before the we need to draw the next frame
+ */
+static gint
+master_clock_next_frame_delay (ClutterMasterClockDefault *master_clock)
+{
+  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.. */
+  return master_clock_get_swap_wait_time (master_clock);
+}
+
+static void
+master_clock_process_events (ClutterMasterClockDefault *master_clock,
+                             GSList                    *stages)
+{
+  GSList *l;
+#ifdef CLUTTER_ENABLE_DEBUG
+  gint64 start = g_get_monotonic_time ();
+#endif
+
+  /* Process queued events */
+  for (l = stages; l != NULL; l = l->next)
+    _clutter_stage_process_queued_events (l->data);
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  if (_clutter_diagnostic_enabled ())
+    clutter_warn_if_over_budget (master_clock, start, "Event processing");
+
+  master_clock->remaining_budget -= (g_get_monotonic_time () - start);
+#endif
+}
+
+/*
+ * master_clock_advance_timelines:
+ * @master_clock: a #ClutterMasterClock
+ *
+ * Advances all the timelines held by the master clock. This function
+ * should be called before calling _clutter_stage_do_update() to
+ * make sure that all the timelines are advanced and the scene is updated.
+ */
+static void
+master_clock_advance_timelines (ClutterMasterClockDefault *master_clock)
+{
+  GSList *timelines, *l;
+#ifdef CLUTTER_ENABLE_DEBUG
+  gint64 start = g_get_monotonic_time ();
+#endif
+
+  /* we protect ourselves from timelines being removed during
+   * the advancement by other timelines by copying the list of
+   * timelines, taking a reference on them, iterating over the
+   * copied list and then releasing the reference.
+   *
+   * we cannot simply take a reference on the timelines and still
+   * use the list held by the master clock because the do_tick()
+   * might result in the creation of a new timeline, which gets
+   * added at the end of the list with no reference increase and
+   * thus gets disposed at the end of the iteration.
+   *
+   * this implies that a newly added timeline will not be advanced
+   * by this clock iteration, which is perfectly fine since we're
+   * in its first cycle.
+   *
+   * we also cannot steal the master clock timelines list because
+   * a timeline might be removed as the direct result of do_tick()
+   * and remove_timeline() would not find the timeline, failing
+   * and leaving a dangling pointer behind.
+   */
+  timelines = g_slist_copy (master_clock->timelines);
+  g_slist_foreach (timelines, (GFunc) g_object_ref, NULL);
+
+  for (l = timelines; l != NULL; l = l->next)
+    _clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000);
+
+  g_slist_free_full (timelines, g_object_unref);
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  if (_clutter_diagnostic_enabled ())
+    clutter_warn_if_over_budget (master_clock, start, "Animations");
+
+  master_clock->remaining_budget -= (g_get_monotonic_time () - start);
+#endif
+}
+
+static gboolean
+master_clock_update_stages (ClutterMasterClockDefault *master_clock,
+                            GSList                    *stages)
+{
+  gboolean stages_updated = FALSE;
+  GSList *l;
+#ifdef CLUTTER_ENABLE_DEBUG
+  gint64 start = g_get_monotonic_time ();
+#endif
+
+  _clutter_run_repaint_functions (CLUTTER_REPAINT_FLAGS_PRE_PAINT);
+
+  /* Update any stage that needs redraw/relayout after the clock
+   * is advanced.
+   */
+  for (l = stages; l != NULL; l = l->next)
+    stages_updated |= _clutter_stage_do_update (l->data);
+
+  _clutter_run_repaint_functions (CLUTTER_REPAINT_FLAGS_POST_PAINT);
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  if (_clutter_diagnostic_enabled ())
+    clutter_warn_if_over_budget (master_clock, start, "Updating the stage");
+
+  master_clock->remaining_budget -= (g_get_monotonic_time () - start);
+#endif
+
+  return stages_updated;
+}
+
+/*
+ * clutter_clock_source_new:
+ * @master_clock: a #ClutterMasterClock for the source
+ *
+ * The #ClutterClockSource is an idle GSource that will queue a redraw
+ * if @master_clock has at least a running #ClutterTimeline. The redraw
+ * will cause @master_clock to advance all timelines, thus advancing all
+ * animations as well.
+ *
+ * Return value: the newly created #GSource
+ */
+static GSource *
+clutter_clock_source_new (ClutterMasterClockDefault *master_clock)
+{
+  GSource *source = g_source_new (&clock_funcs, sizeof (ClutterClockSource));
+  ClutterClockSource *clock_source = (ClutterClockSource *) source;
+
+  g_source_set_name (source, "Clutter master clock");
+  g_source_set_priority (source, CLUTTER_PRIORITY_REDRAW);
+  g_source_set_can_recurse (source, FALSE);
+  clock_source->master_clock = master_clock;
+
+  return source;
+}
+
+static gboolean
+clutter_clock_prepare (GSource *source,
+                       gint    *timeout)
+{
+  ClutterClockSource *clock_source = (ClutterClockSource *) source;
+  ClutterMasterClockDefault *master_clock = clock_source->master_clock;
+  int delay;
+
+  _clutter_threads_acquire_lock ();
+
+  if (G_UNLIKELY (clutter_paint_debug_flags &
+                  CLUTTER_DEBUG_CONTINUOUS_REDRAW))
+    {
+      ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+      const GSList *stages, *l;
+
+      stages = clutter_stage_manager_peek_stages (stage_manager);
+
+      /* Queue a full redraw on all of the stages */
+      for (l = stages; l != NULL; l = l->next)
+        clutter_actor_queue_redraw (l->data);
+    }
+
+  delay = master_clock_next_frame_delay (master_clock);
+
+  _clutter_threads_release_lock ();
+
+  *timeout = delay;
+
+  return delay == 0;
+}
+
+static gboolean
+clutter_clock_check (GSource *source)
+{
+  ClutterClockSource *clock_source = (ClutterClockSource *) source;
+  ClutterMasterClockDefault *master_clock = clock_source->master_clock;
+  int delay;
+
+  _clutter_threads_acquire_lock ();
+  delay = master_clock_next_frame_delay (master_clock);
+  _clutter_threads_release_lock ();
+
+  return delay == 0;
+}
+
+static gboolean
+clutter_clock_dispatch (GSource     *source,
+                        GSourceFunc  callback,
+                        gpointer     user_data)
+{
+  ClutterClockSource *clock_source = (ClutterClockSource *) source;
+  ClutterMasterClockDefault *master_clock = clock_source->master_clock;
+  GSList *stages;
+
+  CLUTTER_NOTE (SCHEDULER, "Master clock [tick]");
+
+  _clutter_threads_acquire_lock ();
+
+  /* Get the time to use for this frame */
+  master_clock->cur_tick = g_source_get_time (source);
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  master_clock->remaining_budget = master_clock->frame_budget;
+#endif
+
+  /* We need to protect ourselves against stages being destroyed during
+   * event handling - master_clock_list_ready_stages() returns a
+   * list of referenced that we'll unref afterwards.
+   */
+  stages = master_clock_list_ready_stages (master_clock);
+
+  /* Each frame is split into three separate phases: */
+
+  /* 1. process all the events; each stage goes through its events queue
+   *    and processes each event according to its type, then emits the
+   *    various signals that are associated with the event
+   */
+  master_clock_process_events (master_clock, stages);
+
+  /* 2. advance the timelines */
+  master_clock_advance_timelines (master_clock);
+
+  /* 3. relayout and redraw the stages */
+  master_clock_update_stages (master_clock, stages);
+
+  master_clock_reschedule_stage_updates (master_clock, stages);
+
+  g_slist_free_full (stages, g_object_unref);
+
+  _clutter_threads_release_lock ();
+
+  return TRUE;
+}
+
+static void
+clutter_master_clock_default_finalize (GObject *gobject)
+{
+  ClutterMasterClockDefault *master_clock = CLUTTER_MASTER_CLOCK_DEFAULT (gobject);
+
+  g_slist_free (master_clock->timelines);
+
+  G_OBJECT_CLASS (clutter_master_clock_default_parent_class)->finalize (gobject);
+}
+
+static void
+clutter_master_clock_default_class_init (ClutterMasterClockDefaultClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->finalize = clutter_master_clock_default_finalize;
+}
+
+static void
+clutter_master_clock_default_init (ClutterMasterClockDefault *self)
+{
+  GSource *source;
+
+  source = clutter_clock_source_new (self);
+  self->source = source;
+
+  self->ensure_next_iteration = FALSE;
+  self->paused = FALSE;
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  self->frame_budget = G_USEC_PER_SEC / 60;
+#endif
+
+  g_source_attach (source, NULL);
+}
+
+static void
+clutter_master_clock_default_add_timeline (ClutterMasterClock *clock,
+                                           ClutterTimeline    *timeline)
+{
+  ClutterMasterClockDefault *master_clock = (ClutterMasterClockDefault *) clock;
+  gboolean is_first;
+
+  if (g_slist_find (master_clock->timelines, timeline))
+    return;
+
+  is_first = master_clock->timelines == NULL;
+
+  master_clock->timelines = g_slist_prepend (master_clock->timelines,
+                                             timeline);
+
+  if (is_first)
+    {
+      master_clock_schedule_stage_updates (master_clock);
+      _clutter_master_clock_start_running (clock);
+    }
+}
+
+static void
+clutter_master_clock_default_remove_timeline (ClutterMasterClock *clock,
+                                              ClutterTimeline    *timeline)
+{
+  ClutterMasterClockDefault *master_clock = (ClutterMasterClockDefault *) clock;
+
+  master_clock->timelines = g_slist_remove (master_clock->timelines,
+                                            timeline);
+}
+
+static void
+clutter_master_clock_default_start_running (ClutterMasterClock *master_clock)
+{
+  /* If called from a different thread, we need to wake up the
+   * main loop to start running the timelines
+   */
+  g_main_context_wakeup (NULL);
+}
+
+static void
+clutter_master_clock_default_ensure_next_iteration (ClutterMasterClock *clock)
+{
+  ClutterMasterClockDefault *master_clock = (ClutterMasterClockDefault *) clock;
+
+  master_clock->ensure_next_iteration = TRUE;
+}
+
+static void
+clutter_master_clock_default_set_paused (ClutterMasterClock *clock,
+                                         gboolean            paused)
+{
+  ClutterMasterClockDefault *master_clock = (ClutterMasterClockDefault *) clock;
+
+  if (paused && !master_clock->paused)
+    {
+      g_clear_pointer (&master_clock->source, g_source_destroy);
+    }
+  else if (!paused && master_clock->paused)
+    {
+      master_clock->source = clutter_clock_source_new (master_clock);
+      g_source_attach (master_clock->source, NULL);
+    }
+
+  master_clock->paused = !!paused;
+}
+
+static void
+clutter_master_clock_iface_init (ClutterMasterClockInterface *iface)
+{
+  iface->add_timeline = clutter_master_clock_default_add_timeline;
+  iface->remove_timeline = clutter_master_clock_default_remove_timeline;
+  iface->start_running = clutter_master_clock_default_start_running;
+  iface->ensure_next_iteration = clutter_master_clock_default_ensure_next_iteration;
+  iface->set_paused = clutter_master_clock_default_set_paused;
+}
--- a/clutter/clutter/clutter-master-clock-default.h
+++ b/clutter/clutter/clutter-master-clock-default.h
@@ -0,0 +1,48 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com>
+ *
+ * Copyright (C) 2015  Intel Corporation.
+ *
+ * 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_MASTER_CLOCK_DEFAULT_H__
+#define __CLUTTER_MASTER_CLOCK_DEFAULT_H__
+
+#include <clutter/clutter-timeline.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_MASTER_CLOCK_DEFAULT            (_clutter_master_clock_default_get_type ())
+#define CLUTTER_MASTER_CLOCK_DEFAULT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_MASTER_CLOCK_DEFAULT, ClutterMasterClockDefault))
+#define CLUTTER_IS_MASTER_CLOCK_DEFAULT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_MASTER_CLOCK_DEFAULT))
+#define CLUTTER_MASTER_CLOCK_DEFAULT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_MASTER_CLOCK_DEFAULT, ClutterMasterClockDefaultClass))
+
+typedef struct _ClutterMasterClockDefault      ClutterMasterClockDefault;
+typedef struct _ClutterMasterClockDefaultClass ClutterMasterClockDefaultClass;
+
+struct _ClutterMasterClockDefaultClass
+{
+  GObjectClass parent_class;
+};
+
+GType _clutter_master_clock_default_get_type (void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* __CLUTTER_MASTER_CLOCK_DEFAULT_H__ */
--- a/clutter/clutter/clutter-master-clock.c
+++ b/clutter/clutter/clutter-master-clock.c
@@ -0,0 +1,132 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By: Emmanuele Bassi <ebassi@linux.intel.com>
+ *
+ * Copyright (C) 2009  Intel Corporation.
+ *
+ * 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/>.
+ */
+
+/*
+ * SECTION:clutter-master-clock
+ * @short_description: The master clock for all animations
+ *
+ * The #ClutterMasterClock class is responsible for advancing all
+ * #ClutterTimelines when a stage is being redrawn. The master clock
+ * makes sure that the scenegraph is always integrally updated before
+ * painting it.
+ */
+
+#include "clutter-build-config.h"
+
+#include "clutter-master-clock.h"
+#include "clutter-master-clock-default.h"
+#include "clutter-private.h"
+
+G_DEFINE_INTERFACE (ClutterMasterClock, clutter_master_clock, G_TYPE_OBJECT)
+
+static void
+clutter_master_clock_default_init (ClutterMasterClockInterface *iface)
+{
+}
+
+ClutterMasterClock *
+_clutter_master_clock_get_default (void)
+{
+  ClutterMainContext *context = _clutter_context_get_default ();
+
+  if (G_UNLIKELY (context->master_clock == NULL))
+    context->master_clock = g_object_new (CLUTTER_TYPE_MASTER_CLOCK_DEFAULT, NULL);
+
+  return context->master_clock;
+
+}
+
+/*
+ * _clutter_master_clock_add_timeline:
+ * @master_clock: a #ClutterMasterClock
+ * @timeline: a #ClutterTimeline
+ *
+ * Adds @timeline to the list of playing timelines held by the master
+ * clock.
+ */
+void
+_clutter_master_clock_add_timeline (ClutterMasterClock *master_clock,
+                                    ClutterTimeline    *timeline)
+{
+  g_return_if_fail (CLUTTER_IS_MASTER_CLOCK (master_clock));
+
+  CLUTTER_MASTER_CLOCK_GET_IFACE (master_clock)->add_timeline (master_clock,
+                                                               timeline);
+}
+
+/*
+ * _clutter_master_clock_remove_timeline:
+ * @master_clock: a #ClutterMasterClock
+ * @timeline: a #ClutterTimeline
+ *
+ * Removes @timeline from the list of playing timelines held by the
+ * master clock.
+ */
+void
+_clutter_master_clock_remove_timeline (ClutterMasterClock *master_clock,
+                                       ClutterTimeline    *timeline)
+{
+  g_return_if_fail (CLUTTER_IS_MASTER_CLOCK (master_clock));
+
+  CLUTTER_MASTER_CLOCK_GET_IFACE (master_clock)->remove_timeline (master_clock,
+                                                                  timeline);
+}
+
+/*
+ * _clutter_master_clock_start_running:
+ * @master_clock: a #ClutterMasterClock
+ *
+ * Called when we have events or redraws to process; if the clock
+ * is stopped, does the processing necessary to wake it up again.
+ */
+void
+_clutter_master_clock_start_running (ClutterMasterClock *master_clock)
+{
+  g_return_if_fail (CLUTTER_IS_MASTER_CLOCK (master_clock));
+
+  CLUTTER_MASTER_CLOCK_GET_IFACE (master_clock)->start_running (master_clock);
+}
+
+/**
+ * _clutter_master_clock_ensure_next_iteration:
+ * @master_clock: a #ClutterMasterClock
+ *
+ * Ensures that the master clock will run at least one iteration
+ */
+void
+_clutter_master_clock_ensure_next_iteration (ClutterMasterClock *master_clock)
+{
+  g_return_if_fail (CLUTTER_IS_MASTER_CLOCK (master_clock));
+
+  CLUTTER_MASTER_CLOCK_GET_IFACE (master_clock)->ensure_next_iteration (master_clock);
+}
+
+void
+_clutter_master_clock_set_paused (ClutterMasterClock *master_clock,
+                                  gboolean            paused)
+{
+  g_return_if_fail (CLUTTER_IS_MASTER_CLOCK (master_clock));
+
+  CLUTTER_MASTER_CLOCK_GET_IFACE (master_clock)->set_paused (master_clock,
+                                                             !!paused);
+}
--- a/clutter/clutter/clutter-master-clock.h
+++ b/clutter/clutter/clutter-master-clock.h
@@ -0,0 +1,69 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By: Emmanuele Bassi <ebassi@linux.intel.com>
+ *
+ * Copyright (C) 2009  Intel Corporation.
+ *
+ * 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_MASTER_CLOCK_H__
+#define __CLUTTER_MASTER_CLOCK_H__
+
+#include <clutter/clutter-timeline.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_MASTER_CLOCK (clutter_master_clock_get_type ())
+G_DECLARE_INTERFACE (ClutterMasterClock, clutter_master_clock,
+                     CLUTTER, MASTER_CLOCK,
+                     GObject)
+
+struct _ClutterMasterClockInterface
+{
+  /*< private >*/
+  GTypeInterface parent_iface;
+
+  void (* add_timeline)           (ClutterMasterClock *master_clock,
+                                   ClutterTimeline    *timeline);
+  void (* remove_timeline)        (ClutterMasterClock *master_clock,
+                                   ClutterTimeline    *timeline);
+  void (* start_running)          (ClutterMasterClock *master_clock);
+  void (* ensure_next_iteration)  (ClutterMasterClock *master_clock);
+  void (* set_paused)             (ClutterMasterClock *master_clock,
+                                   gboolean            paused);
+};
+
+ClutterMasterClock *    _clutter_master_clock_get_default               (void);
+void                    _clutter_master_clock_add_timeline              (ClutterMasterClock *master_clock,
+                                                                         ClutterTimeline    *timeline);
+void                    _clutter_master_clock_remove_timeline           (ClutterMasterClock *master_clock,
+                                                                         ClutterTimeline    *timeline);
+void                    _clutter_master_clock_start_running             (ClutterMasterClock *master_clock);
+void                    _clutter_master_clock_ensure_next_iteration     (ClutterMasterClock *master_clock);
+void                    _clutter_master_clock_set_paused                (ClutterMasterClock *master_clock,
+                                                                         gboolean            paused);
+
+void                    _clutter_timeline_advance                       (ClutterTimeline    *timeline,
+                                                                         gint64              tick_time);
+gint64                  _clutter_timeline_get_delta                     (ClutterTimeline    *timeline);
+void                    _clutter_timeline_do_tick                       (ClutterTimeline    *timeline,
+                                                                         gint64              tick_time);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_MASTER_CLOCK_H__ */
--- a/clutter/clutter/clutter-mutter.h
+++ b/clutter/clutter/clutter-mutter.h
@@ -36,13 +36,6 @@
 #include "cogl/clutter-stage-cogl.h"
 #include "clutter/x11/clutter-backend-x11.h"

-CLUTTER_EXPORT
-GList * clutter_stage_peek_stage_views (ClutterStage *stage);
-
-CLUTTER_EXPORT
-gboolean clutter_actor_is_effectively_on_stage_view (ClutterActor     *self,
-                                                     ClutterStageView *view);
-
 CLUTTER_EXPORT
 void clutter_set_custom_backend_func (ClutterBackend *(* func) (void));

@@ -56,25 +49,17 @@ void clutter_stage_capture_into (ClutterStage          *stage,
                                 uint8_t               *data);

 CLUTTER_EXPORT
-void clutter_stage_clear_stage_views (ClutterStage *stage);
+void clutter_stage_freeze_updates (ClutterStage *stage);

 CLUTTER_EXPORT
-void clutter_stage_view_assign_next_scanout (ClutterStageView *stage_view,
-                                             CoglScanout      *scanout);
+void clutter_stage_thaw_updates (ClutterStage *stage);
+
+CLUTTER_EXPORT
+void clutter_stage_update_resource_scales (ClutterStage *stage);

 CLUTTER_EXPORT
 gboolean clutter_actor_has_damage (ClutterActor *actor);

-CLUTTER_EXPORT
-gboolean clutter_actor_has_transitions (ClutterActor *actor);
-
-CLUTTER_EXPORT
-ClutterFrameClock * clutter_actor_pick_frame_clock (ClutterActor  *self,
-                                                    ClutterActor **out_actor);
-CLUTTER_EXPORT
-gboolean clutter_seat_handle_event_post (ClutterSeat        *seat,
-                                         const ClutterEvent *event);
-
 #undef __CLUTTER_H_INSIDE__

 #endif /* __CLUTTER_MUTTER_H__ */
--- a/clutter/clutter/clutter-offscreen-effect.c
+++ b/clutter/clutter/clutter-offscreen-effect.c
@@ -81,7 +81,7 @@
 struct _ClutterOffscreenEffectPrivate
 {
  CoglHandle offscreen;
-  CoglPipeline *pipeline;
+  CoglPipeline *target;
  CoglHandle texture;

  ClutterActor *actor;
@@ -100,8 +100,6 @@ struct _ClutterOffscreenEffectPrivate
  int target_height;

  gint old_opacity_override;
-
-  gulong purge_handler_id;
 };

 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ClutterOffscreenEffect,
@@ -142,7 +140,7 @@ ensure_pipeline_filter_for_scale (ClutterOffscreenEffect *self,
 {
  CoglPipelineFilter filter;

-  if (!self->priv->pipeline)
+  if (!self->priv->target)
    return;

  /* If no fractional scaling is set, we're always going to render the texture
@@ -156,16 +154,10 @@ ensure_pipeline_filter_for_scale (ClutterOffscreenEffect *self,
  else
    filter = COGL_PIPELINE_FILTER_LINEAR;

-  cogl_pipeline_set_layer_filters (self->priv->pipeline, 0 /* layer_index */,
+  cogl_pipeline_set_layer_filters (self->priv->target, 0 /* layer_index */,
                                   filter, filter);
 }

-static void
-video_memory_purged (ClutterOffscreenEffect *self)
-{
-  g_clear_pointer (&self->priv->offscreen, cogl_object_unref);
-}
-
 static gboolean
 update_fbo (ClutterEffect *effect,
            int            target_width,
@@ -174,26 +166,8 @@ update_fbo (ClutterEffect *effect,
 {
  ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
  ClutterOffscreenEffectPrivate *priv = self->priv;
-  ClutterActor *stage_actor;
-
-  stage_actor = clutter_actor_get_stage (priv->actor);
-  if (stage_actor != priv->stage)
-    {
-      g_clear_signal_handler (&priv->purge_handler_id, priv->stage);
-
-      priv->stage = stage_actor;
-
-      if (priv->stage)
-        {
-          priv->purge_handler_id =
-            g_signal_connect_object (priv->stage,
-                                     "gl-video-memory-purged",
-                                     G_CALLBACK (video_memory_purged),
-                                     self,
-                                     G_CONNECT_SWAPPED);
-        }
-    }

+  priv->stage = clutter_actor_get_stage (priv->actor);
  if (priv->stage == NULL)
    {
      CLUTTER_NOTE (MISC, "The actor '%s' is not part of a stage",
@@ -211,12 +185,12 @@ update_fbo (ClutterEffect *effect,
    return TRUE;
  }

-  if (priv->pipeline == NULL)
+  if (priv->target == NULL)
    {
      CoglContext *ctx =
        clutter_backend_get_cogl_context (clutter_get_default_backend ());

-      priv->pipeline = cogl_pipeline_new (ctx);
+      priv->target = cogl_pipeline_new (ctx);
      ensure_pipeline_filter_for_scale (self, resource_scale);
    }

@@ -228,7 +202,7 @@ update_fbo (ClutterEffect *effect,
  if (priv->texture == NULL)
    return FALSE;

-  cogl_pipeline_set_layer_texture (priv->pipeline, 0, priv->texture);
+  cogl_pipeline_set_layer_texture (priv->target, 0, priv->texture);

  priv->target_width = target_width;
  priv->target_height = target_height;
@@ -238,8 +212,8 @@ update_fbo (ClutterEffect *effect,
    {
      g_warning ("%s: Unable to create an Offscreen buffer", G_STRLOC);

-      cogl_object_unref (priv->pipeline);
-      priv->pipeline = NULL;
+      cogl_object_unref (priv->target);
+      priv->target = NULL;

      priv->target_width = 0;
      priv->target_height = 0;
@@ -264,8 +238,8 @@ clutter_offscreen_effect_pre_paint (ClutterEffect       *effect,
  gfloat stage_width, stage_height;
  gfloat target_width = -1, target_height = -1;
  CoglFramebuffer *framebuffer;
-  float resource_scale;
-  float ceiled_resource_scale;
+  gfloat resource_scale;
+  gfloat ceiled_resource_scale;
  graphene_point3d_t local_offset;
  gfloat old_viewport[4];

@@ -280,11 +254,17 @@ clutter_offscreen_effect_pre_paint (ClutterEffect       *effect,
  stage = _clutter_actor_get_stage_internal (priv->actor);
  clutter_actor_get_size (stage, &stage_width, &stage_height);

-  resource_scale = clutter_actor_get_real_resource_scale (priv->actor);
-
-  ceiled_resource_scale = ceilf (resource_scale);
-  stage_width *= ceiled_resource_scale;
-  stage_height *= ceiled_resource_scale;
+  if (_clutter_actor_get_real_resource_scale (priv->actor, &resource_scale))
+    {
+      ceiled_resource_scale = ceilf (resource_scale);
+      stage_width *= ceiled_resource_scale;
+      stage_height *= ceiled_resource_scale;
+    }
+  else
+    {
+      /* We are sure we have a resource scale set to a good value at paint */
+      g_assert_not_reached ();
+    }

  /* Get the minimal bounding box for what we want to paint, relative to the
   * parent of priv->actor. Note that we may actually be painting a clone of
@@ -400,7 +380,7 @@ clutter_offscreen_effect_real_paint_target (ClutterOffscreenEffect *effect,

  paint_opacity = clutter_actor_get_paint_opacity (priv->actor);

-  cogl_pipeline_set_color4ub (priv->pipeline,
+  cogl_pipeline_set_color4ub (priv->target,
                              paint_opacity,
                              paint_opacity,
                              paint_opacity,
@@ -412,7 +392,7 @@ clutter_offscreen_effect_real_paint_target (ClutterOffscreenEffect *effect,
   * hadn't been redirected offscreen.
   */
  cogl_framebuffer_draw_textured_rectangle (framebuffer,
-                                            priv->pipeline,
+                                            priv->target,
                                            0, 0,
                                            cogl_texture_get_width (priv->texture),
                                            cogl_texture_get_height (priv->texture),
@@ -437,9 +417,8 @@ clutter_offscreen_effect_paint_texture (ClutterOffscreenEffect *effect,
   */
  cogl_framebuffer_get_modelview_matrix (framebuffer, &modelview);

-  resource_scale = clutter_actor_get_resource_scale (priv->actor);
-
-  if (resource_scale != 1.0f)
+  if (clutter_actor_get_resource_scale (priv->actor, &resource_scale) &&
+      resource_scale != 1.0f)
    {
      float paint_scale = 1.0f / resource_scale;
      cogl_matrix_scale (&modelview, paint_scale, paint_scale, 1);
@@ -467,16 +446,13 @@ clutter_offscreen_effect_post_paint (ClutterEffect       *effect,
  ClutterOffscreenEffectPrivate *priv = self->priv;
  CoglFramebuffer *framebuffer;

-  g_warn_if_fail (priv->offscreen);
-  g_warn_if_fail (priv->pipeline);
-  g_warn_if_fail (priv->actor);
+  if (priv->offscreen == NULL ||
+      priv->target == NULL ||
+      priv->actor == NULL)
+    return;

  /* Restore the previous opacity override */
-  if (priv->actor)
-    {
-      clutter_actor_set_opacity_override (priv->actor,
-                                          priv->old_opacity_override);
-    }
+  clutter_actor_set_opacity_override (priv->actor, priv->old_opacity_override);

  framebuffer = clutter_paint_context_get_framebuffer (paint_context);
  cogl_framebuffer_pop_matrix (framebuffer);
@@ -522,17 +498,16 @@ clutter_offscreen_effect_paint (ClutterEffect           *effect,
 }

 static void
-clutter_offscreen_effect_set_enabled (ClutterActorMeta *meta,
-                                      gboolean          is_enabled)
+clutter_offscreen_effect_notify (GObject    *gobject,
+                                 GParamSpec *pspec)
 {
-  ClutterActorMetaClass *parent_class =
-    CLUTTER_ACTOR_META_CLASS (clutter_offscreen_effect_parent_class);
-  ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (meta);
+  ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (gobject);
  ClutterOffscreenEffectPrivate *priv = offscreen_effect->priv;

-  g_clear_pointer (&priv->offscreen, cogl_object_unref);
+  if (strcmp (pspec->name, "enabled") == 0)
+    g_clear_pointer (&priv->offscreen, cogl_object_unref);

-  parent_class->set_enabled (meta, is_enabled);
+  G_OBJECT_CLASS (clutter_offscreen_effect_parent_class)->notify (gobject, pspec);
 }

 static void
@@ -543,7 +518,7 @@ clutter_offscreen_effect_finalize (GObject *gobject)

  g_clear_pointer (&priv->offscreen, cogl_object_unref);
  g_clear_pointer (&priv->texture, cogl_object_unref);
-  g_clear_pointer (&priv->pipeline, cogl_object_unref);
+  g_clear_pointer (&priv->target, cogl_object_unref);

  G_OBJECT_CLASS (clutter_offscreen_effect_parent_class)->finalize (gobject);
 }
@@ -559,13 +534,13 @@ clutter_offscreen_effect_class_init (ClutterOffscreenEffectClass *klass)
  klass->paint_target = clutter_offscreen_effect_real_paint_target;

  meta_class->set_actor = clutter_offscreen_effect_set_actor;
-  meta_class->set_enabled = clutter_offscreen_effect_set_enabled;

  effect_class->pre_paint = clutter_offscreen_effect_pre_paint;
  effect_class->post_paint = clutter_offscreen_effect_post_paint;
  effect_class->paint = clutter_offscreen_effect_paint;

  gobject_class->finalize = clutter_offscreen_effect_finalize;
+  gobject_class->notify = clutter_offscreen_effect_notify;
 }

 static void
@@ -625,7 +600,7 @@ clutter_offscreen_effect_get_target (ClutterOffscreenEffect *effect)
  g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect),
                        NULL);

-  return (CoglMaterial *)effect->priv->pipeline;
+  return (CoglMaterial *)effect->priv->target;
 }

 /**
--- a/clutter/clutter/clutter-paint-context-private.h
+++ b/clutter/clutter/clutter-paint-context-private.h
@@ -20,9 +20,7 @@

 #include "clutter-paint-context.h"

-ClutterPaintContext * clutter_paint_context_new_for_view (ClutterStageView     *view,
-                                                          const cairo_region_t *redraw_clip,
-                                                          ClutterPaintFlag      paint_flags);
+ClutterPaintContext * clutter_paint_context_new_for_view (ClutterStageView *view);

 gboolean clutter_paint_context_is_drawing_off_stage (ClutterPaintContext *paint_context);

--- a/clutter/clutter/clutter-paint-context.c
+++ b/clutter/clutter/clutter-paint-context.c
@@ -23,13 +23,9 @@ struct _ClutterPaintContext
 {
  grefcount ref_count;

-  ClutterPaintFlag paint_flags;
-
  GList *framebuffers;

  ClutterStageView *view;
-
-  cairo_region_t *redraw_clip;
 };

 G_DEFINE_BOXED_TYPE (ClutterPaintContext, clutter_paint_context,
@@ -37,9 +33,7 @@ G_DEFINE_BOXED_TYPE (ClutterPaintContext, clutter_paint_context,
                     clutter_paint_context_unref)

 ClutterPaintContext *
-clutter_paint_context_new_for_view (ClutterStageView     *view,
-                                    const cairo_region_t *redraw_clip,
-                                    ClutterPaintFlag      paint_flags)
+clutter_paint_context_new_for_view (ClutterStageView *view)
 {
  ClutterPaintContext *paint_context;
  CoglFramebuffer *framebuffer;
@@ -47,8 +41,6 @@ clutter_paint_context_new_for_view (ClutterStageView     *view,
  paint_context = g_new0 (ClutterPaintContext, 1);
  g_ref_count_init (&paint_context->ref_count);
  paint_context->view = view;
-  paint_context->redraw_clip = cairo_region_copy (redraw_clip);
-  paint_context->paint_flags = paint_flags;

  framebuffer = clutter_stage_view_get_framebuffer (view);
  clutter_paint_context_push_framebuffer (paint_context, framebuffer);
@@ -60,16 +52,12 @@ clutter_paint_context_new_for_view (ClutterStageView     *view,
 * clutter_paint_context_new_for_framebuffer: (skip)
 */
 ClutterPaintContext *
-clutter_paint_context_new_for_framebuffer (CoglFramebuffer      *framebuffer,
-                                           const cairo_region_t *redraw_clip,
-                                           ClutterPaintFlag      paint_flags)
+clutter_paint_context_new_for_framebuffer (CoglFramebuffer *framebuffer)
 {
  ClutterPaintContext *paint_context;

  paint_context = g_new0 (ClutterPaintContext, 1);
  g_ref_count_init (&paint_context->ref_count);
-  paint_context->redraw_clip = cairo_region_copy (redraw_clip);
-  paint_context->paint_flags = paint_flags;

  clutter_paint_context_push_framebuffer (paint_context, framebuffer);

@@ -89,7 +77,6 @@ clutter_paint_context_dispose (ClutterPaintContext *paint_context)
  g_list_free_full (paint_context->framebuffers,
                    cogl_object_unref);
  paint_context->framebuffers = NULL;
-  g_clear_pointer (&paint_context->redraw_clip, cairo_region_destroy);
 }

 void
@@ -128,12 +115,6 @@ clutter_paint_context_pop_framebuffer (ClutterPaintContext *paint_context)
                        paint_context->framebuffers);
 }

-const cairo_region_t *
-clutter_paint_context_get_redraw_clip (ClutterPaintContext *paint_context)
-{
-  return paint_context->redraw_clip;
-}
-
 /**
 * clutter_paint_context_get_framebuffer:
 * @paint_context: The #ClutterPaintContext
@@ -178,12 +159,3 @@ clutter_paint_context_is_drawing_off_stage (ClutterPaintContext *paint_context)

  return !paint_context->view;
 }
-
-/**
- * clutter_paint_context_get_paint_flags: (skip)
- */
-ClutterPaintFlag
-clutter_paint_context_get_paint_flags (ClutterPaintContext *paint_context)
-{
-  return paint_context->paint_flags;
-}
--- a/clutter/clutter/clutter-paint-context.h
+++ b/clutter/clutter/clutter-paint-context.h
@@ -29,22 +29,13 @@

 typedef struct _ClutterPaintContext ClutterPaintContext;

-typedef enum _ClutterPaintFlag
-{
-  CLUTTER_PAINT_FLAG_NONE = 0,
-  CLUTTER_PAINT_FLAG_NO_CURSORS = 1 << 0,
-  CLUTTER_PAINT_FLAG_FORCE_CURSORS = 1 << 1,
-} ClutterPaintFlag;
-
 #define CLUTTER_TYPE_PAINT_CONTEXT (clutter_paint_context_get_type ())

 CLUTTER_EXPORT
 GType clutter_paint_context_get_type (void);

 CLUTTER_EXPORT
-ClutterPaintContext * clutter_paint_context_new_for_framebuffer (CoglFramebuffer      *framebuffer,
-                                                                 const cairo_region_t *redraw_clip,
-                                                                 ClutterPaintFlag      paint_flags);
+ClutterPaintContext * clutter_paint_context_new_for_framebuffer (CoglFramebuffer *framebuffer);

 CLUTTER_EXPORT
 ClutterPaintContext * clutter_paint_context_ref (ClutterPaintContext *paint_context);
@@ -68,10 +59,4 @@ void clutter_paint_context_push_framebuffer (ClutterPaintContext *paint_context,
 CLUTTER_EXPORT
 void clutter_paint_context_pop_framebuffer (ClutterPaintContext *paint_context);

-CLUTTER_EXPORT
-const cairo_region_t * clutter_paint_context_get_redraw_clip (ClutterPaintContext *paint_context);
-
-CLUTTER_EXPORT
-ClutterPaintFlag clutter_paint_context_get_paint_flags (ClutterPaintContext *paint_context);
-
 #endif /* CLUTTER_PAINT_CONTEXT_H */
--- a/clutter/clutter/clutter-paint-node-private.h
+++ b/clutter/clutter/clutter-paint-node-private.h
@@ -83,6 +83,7 @@ typedef enum
  PAINT_OP_INVALID = 0,
  PAINT_OP_TEX_RECT,
  PAINT_OP_MULTITEX_RECT,
+  PAINT_OP_PATH,
  PAINT_OP_PRIMITIVE
 } PaintOpCode;

@@ -95,6 +96,8 @@ struct _ClutterPaintOperation
  union {
    float texrect[8];

+    CoglPath *path;
+
    CoglPrimitive *primitive;
  } op;
 };
--- a/clutter/clutter/clutter-paint-node.c
+++ b/clutter/clutter/clutter-paint-node.c
@@ -782,6 +782,11 @@ clutter_paint_operation_clear (ClutterPaintOperation *op)
        g_array_unref (op->multitex_coords);
      break;

+    case PAINT_OP_PATH:
+      if (op->op.path != NULL)
+        cogl_object_unref (op->op.path);
+      break;
+
    case PAINT_OP_PRIMITIVE:
      if (op->op.primitive != NULL)
        cogl_object_unref (op->op.primitive);
@@ -831,6 +836,16 @@ clutter_paint_op_init_multitex_rect (ClutterPaintOperation *op,
  op->op.texrect[3] = rect->y2;
 }

+static inline void
+clutter_paint_op_init_path (ClutterPaintOperation *op,
+                            CoglPath              *path)
+{
+  clutter_paint_operation_clear (op);
+
+  op->opcode = PAINT_OP_PATH;
+  op->op.path = cogl_object_ref (path);
+}
+
 static inline void
 clutter_paint_op_init_primitive (ClutterPaintOperation *op,
                                 CoglPrimitive         *primitive)
@@ -935,6 +950,34 @@ clutter_paint_node_add_multitexture_rectangle (ClutterPaintNode      *node,
  g_array_append_val (node->operations, operation);
 }

+/**
+ * clutter_paint_node_add_path: (skip)
+ * @node: a #ClutterPaintNode
+ * @path: a Cogl path
+ *
+ * Adds a region described as a path to the @node.
+ *
+ * This function acquires a reference on the passed @path, so it
+ * is safe to call cogl_object_unref() when it returns.
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+void
+clutter_paint_node_add_path (ClutterPaintNode *node,
+                             CoglPath         *path)
+{
+  ClutterPaintOperation operation = PAINT_OP_INIT;
+
+  g_return_if_fail (CLUTTER_IS_PAINT_NODE (node));
+  g_return_if_fail (cogl_is_path (path));
+
+  clutter_paint_node_maybe_init_operations (node);
+
+  clutter_paint_op_init_path (&operation, path);
+  g_array_append_val (node->operations, operation);
+}
+
 /**
 * clutter_paint_node_add_primitive: (skip)
 * @node: a #ClutterPaintNode
@@ -1071,6 +1114,11 @@ clutter_paint_node_to_json (ClutterPaintNode *node)
              json_builder_end_array (builder);
              break;

+            case PAINT_OP_PATH:
+              json_builder_set_member_name (builder, "path");
+              json_builder_add_int_value (builder, (intptr_t) op->op.path);
+              break;
+
            case PAINT_OP_PRIMITIVE:
              json_builder_set_member_name (builder, "primitive");
              json_builder_add_int_value (builder, (intptr_t) op->op.primitive);
@@ -1146,6 +1194,8 @@ _clutter_paint_node_create (GType gtype)
 {
  g_return_val_if_fail (g_type_is_a (gtype, CLUTTER_TYPE_PAINT_NODE), NULL);

+  _clutter_paint_node_init_types ();
+
  return (gpointer) g_type_create_instance (gtype);
 }

--- a/clutter/clutter/clutter-paint-node.h
+++ b/clutter/clutter/clutter-paint-node.h
@@ -84,6 +84,9 @@ void                   clutter_paint_node_add_multitexture_rectangle   (ClutterP
                                                                        unsigned int            text_coords_len);

 CLUTTER_EXPORT
+void                    clutter_paint_node_add_path                     (ClutterPaintNode      *node,
+                                                                         CoglPath              *path);
+CLUTTER_EXPORT
 void                    clutter_paint_node_add_primitive                (ClutterPaintNode      *node,
                                                                         CoglPrimitive         *primitive);

--- a/clutter/clutter/clutter-paint-nodes.c
+++ b/clutter/clutter/clutter-paint-nodes.c
@@ -477,6 +477,10 @@ clutter_pipeline_node_draw (ClutterPaintNode    *node,
                                                         op->multitex_coords->len);
          break;

+        case PAINT_OP_PATH:
+          cogl_framebuffer_fill_path (fb, pnode->pipeline, op->op.path);
+          break;
+
        case PAINT_OP_PRIMITIVE:
          cogl_framebuffer_draw_primitive (fb,
                                           pnode->pipeline,
@@ -872,6 +876,7 @@ clutter_text_node_draw (ClutterPaintNode    *node,
          break;

        case PAINT_OP_MULTITEX_RECT:
+        case PAINT_OP_PATH:
        case PAINT_OP_PRIMITIVE:
        case PAINT_OP_INVALID:
          break;
@@ -1032,6 +1037,11 @@ clutter_clip_node_pre_draw (ClutterPaintNode    *node,
          retval = TRUE;
          break;

+        case PAINT_OP_PATH:
+          cogl_framebuffer_push_path_clip (fb, op->op.path);
+          retval = TRUE;
+          break;
+
        case PAINT_OP_MULTITEX_RECT:
        case PAINT_OP_PRIMITIVE:
        case PAINT_OP_INVALID:
@@ -1062,6 +1072,7 @@ clutter_clip_node_post_draw (ClutterPaintNode    *node,

      switch (op->opcode)
        {
+        case PAINT_OP_PATH:
        case PAINT_OP_TEX_RECT:
          cogl_framebuffer_pop_clip (fb);
          break;
@@ -1231,8 +1242,9 @@ struct _ClutterLayerNode
  float fbo_width;
  float fbo_height;

-  CoglPipeline *pipeline;
+  CoglPipeline *state;
  CoglFramebuffer *offscreen;
+  CoglTexture *texture;

  guint8 opacity;
 };
@@ -1322,7 +1334,7 @@ clutter_layer_node_post_draw (ClutterPaintNode    *node,
        case PAINT_OP_TEX_RECT:
          /* now we need to paint the texture */
          cogl_framebuffer_draw_textured_rectangle (fb,
-                                                    lnode->pipeline,
+                                                    lnode->state,
                                                    op->op.texrect[0],
                                                    op->op.texrect[1],
                                                    op->op.texrect[2],
@@ -1335,7 +1347,7 @@ clutter_layer_node_post_draw (ClutterPaintNode    *node,

        case PAINT_OP_MULTITEX_RECT:
          cogl_framebuffer_draw_multitextured_rectangle (fb,
-                                                         lnode->pipeline,
+                                                         lnode->state,
                                                         op->op.texrect[0],
                                                         op->op.texrect[1],
                                                         op->op.texrect[2],
@@ -1344,10 +1356,12 @@ clutter_layer_node_post_draw (ClutterPaintNode    *node,
                                                         op->multitex_coords->len);
          break;

+        case PAINT_OP_PATH:
+          cogl_framebuffer_fill_path (fb, lnode->state, op->op.path);
+          break;
+
        case PAINT_OP_PRIMITIVE:
-          cogl_framebuffer_draw_primitive (fb,
-                                           lnode->pipeline,
-                                           op->op.primitive);
+          cogl_framebuffer_draw_primitive (fb, lnode->state, op->op.primitive);
          break;
        }
    }
@@ -1358,8 +1372,8 @@ clutter_layer_node_finalize (ClutterPaintNode *node)
 {
  ClutterLayerNode *lnode = CLUTTER_LAYER_NODE (node);

-  if (lnode->pipeline != NULL)
-    cogl_object_unref (lnode->pipeline);
+  if (lnode->state != NULL)
+    cogl_object_unref (lnode->state);

  if (lnode->offscreen != NULL)
    cogl_object_unref (lnode->offscreen);
@@ -1411,9 +1425,6 @@ clutter_layer_node_new (const CoglMatrix        *projection,
                        guint8                   opacity)
 {
  ClutterLayerNode *res;
-  CoglContext *context;
-  CoglTexture2D *tex_2d;
-  CoglTexture *texture;
  CoglColor color;

  res = _clutter_paint_node_create (CLUTTER_TYPE_LAYER_NODE);
@@ -1425,18 +1436,19 @@ clutter_layer_node_new (const CoglMatrix        *projection,
  res->opacity = opacity;

  /* the texture backing the FBO */
-  context = clutter_backend_get_cogl_context (clutter_get_default_backend ());
+  res->texture = cogl_texture_new_with_size (MAX (res->fbo_width, 1),
+                                             MAX (res->fbo_height, 1),
+                                             COGL_TEXTURE_NO_SLICING,
+                                             COGL_PIXEL_FORMAT_RGBA_8888_PRE);

-  tex_2d = cogl_texture_2d_new_with_size (context,
-                                          MAX (res->fbo_width, 1),
-                                          MAX (res->fbo_height, 1));
-  texture = COGL_TEXTURE (tex_2d);
-  cogl_texture_set_premultiplied (texture, TRUE);
-
-  res->offscreen = COGL_FRAMEBUFFER (cogl_offscreen_new_to_texture (texture));
+  res->offscreen = COGL_FRAMEBUFFER (cogl_offscreen_new_to_texture (res->texture));
  if (res->offscreen == NULL)
    {
      g_critical ("%s: Unable to create an offscreen buffer", G_STRLOC);
+
+      cogl_object_unref (res->texture);
+      res->texture = NULL;
+
      goto out;
    }

@@ -1446,15 +1458,14 @@ clutter_layer_node_new (const CoglMatrix        *projection,
   * interpolation filters because the texture is always
   * going to be painted at a 1:1 texel:pixel ratio
   */
-  res->pipeline = cogl_pipeline_copy (default_texture_pipeline);
-  cogl_pipeline_set_layer_filters (res->pipeline, 0,
+  res->state = cogl_pipeline_copy (default_texture_pipeline);
+  cogl_pipeline_set_layer_filters (res->state, 0,
                                   COGL_PIPELINE_FILTER_NEAREST,
                                   COGL_PIPELINE_FILTER_NEAREST);
-  cogl_pipeline_set_layer_texture (res->pipeline, 0, texture);
-  cogl_pipeline_set_color (res->pipeline, &color);
+  cogl_pipeline_set_layer_texture (res->state, 0, res->texture);
+  cogl_pipeline_set_color (res->state, &color);
+  cogl_object_unref (res->texture);

 out:
-  cogl_object_unref (texture);
-
  return (ClutterPaintNode *) res;
 }
--- a/clutter/clutter/clutter-pan-action.c
+++ b/clutter/clutter/clutter-pan-action.c
@@ -62,7 +62,6 @@
 #include "clutter-gesture-action-private.h"
 #include "clutter-marshal.h"
 #include "clutter-private.h"
-#include "clutter-timeline.h"
 #include <math.h>

 #define FLOAT_EPSILON   (1e-15)
@@ -137,8 +136,7 @@ enum

 static guint pan_signals[LAST_SIGNAL] = { 0, };

-G_DEFINE_TYPE_WITH_PRIVATE (ClutterPanAction, clutter_pan_action,
-                            CLUTTER_TYPE_GESTURE_ACTION)
+G_DEFINE_TYPE_WITH_PRIVATE (ClutterPanAction, clutter_pan_action, CLUTTER_TYPE_GESTURE_ACTION)

 static void
 emit_pan (ClutterPanAction *self,
@@ -158,18 +156,14 @@ emit_pan (ClutterPanAction *self,
          gfloat scroll_threshold = G_PI_4/2;
          gfloat drag_angle;

-          clutter_gesture_action_get_motion_delta (CLUTTER_GESTURE_ACTION (self),
-                                                   0,
-                                                   &delta_x,
-                                                   &delta_y);
+          clutter_gesture_action_get_motion_delta (CLUTTER_GESTURE_ACTION (self), 0, &delta_x, &delta_y);

          if (delta_x != 0.0f)
            drag_angle = atanf (delta_y / delta_x);
          else
            drag_angle = G_PI_2;

-          if ((drag_angle > -scroll_threshold) &&
-              (drag_angle < scroll_threshold))
+          if ((drag_angle > -scroll_threshold) && (drag_angle < scroll_threshold))
            priv->pin_state = SCROLL_PINNED_HORIZONTAL;
          else if ((drag_angle > (G_PI_2 - scroll_threshold)) ||
                    (drag_angle < -(G_PI_2 - scroll_threshold)))
@@ -288,10 +282,7 @@ gesture_end (ClutterGestureAction *gesture,
  gfloat tau;
  gint duration;

-  clutter_gesture_action_get_release_coords (CLUTTER_GESTURE_ACTION (self),
-                                             0,
-                                             &priv->release_x,
-                                             &priv->release_y);
+  clutter_gesture_action_get_release_coords (CLUTTER_GESTURE_ACTION (self), 0, &priv->release_x, &priv->release_y);

  if (!priv->should_interpolate)
    {
@@ -302,9 +293,7 @@ gesture_end (ClutterGestureAction *gesture,
  priv->state = PAN_STATE_INTERPOLATING;

  clutter_gesture_action_get_motion_delta (gesture, 0, &delta_x, &delta_y);
-  velocity = clutter_gesture_action_get_velocity (gesture, 0,
-                                                  &velocity_x,
-                                                  &velocity_y);
+  velocity = clutter_gesture_action_get_velocity (gesture, 0, &velocity_x, &velocity_y);

  /* Exponential timing constant v(t) = v(0) * exp(-t/tau)
   * tau = 1000ms / (frame_per_second * - ln(decay_per_frame))
@@ -315,26 +304,17 @@ gesture_end (ClutterGestureAction *gesture,
  /* See where the decreasing velocity reaches $min_velocity px/ms
   * v(t) = v(0) * exp(-t/tau) = min_velocity
   * t = - tau * ln( min_velocity / |v(0)|) */
-  duration = - tau * logf (min_velocity / (ABS (velocity) *
-                                           priv->acceleration_factor));
+  duration = - tau * logf (min_velocity / (ABS (velocity) * priv->acceleration_factor));

  /* Target point: x(t) = v(0) * tau * [1 - exp(-t/tau)] */
-  priv->target_x = (velocity_x * priv->acceleration_factor * tau *
-                    (1 - exp ((float)-duration / tau)));
-  priv->target_y = (velocity_y * priv->acceleration_factor * tau *
-                    (1 - exp ((float)-duration / tau)));
+  priv->target_x = velocity_x * priv->acceleration_factor * tau * (1 - exp ((float)-duration / tau));
+  priv->target_y = velocity_y * priv->acceleration_factor * tau * (1 - exp ((float)-duration / tau));

-  if (ABS (velocity) * priv->acceleration_factor > min_velocity &&
-      duration > FLOAT_EPSILON)
+  if (ABS (velocity) * priv->acceleration_factor > min_velocity && duration > FLOAT_EPSILON)
    {
-      ClutterActor *pan_actor =
-        clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (gesture));
-
      priv->interpolated_x = priv->interpolated_y = 0.0f;
-      priv->deceleration_timeline = clutter_timeline_new_for_actor (pan_actor,
-                                                                    duration);
-      clutter_timeline_set_progress_mode (priv->deceleration_timeline,
-                                          CLUTTER_EASE_OUT_EXPO);
+      priv->deceleration_timeline = clutter_timeline_new (duration);
+      clutter_timeline_set_progress_mode (priv->deceleration_timeline, CLUTTER_EASE_OUT_EXPO);

      g_signal_connect (priv->deceleration_timeline, "new_frame",
                        G_CALLBACK (on_deceleration_new_frame), self);
@@ -387,8 +367,7 @@ clutter_pan_action_set_property (GObject      *gobject,
      break;

    case PROP_ACCELERATION_FACTOR :
-      clutter_pan_action_set_acceleration_factor (self,
-                                                  g_value_get_double (value));
+      clutter_pan_action_set_acceleration_factor (self, g_value_get_double (value));
      break;

    default:
@@ -432,11 +411,9 @@ static void
 clutter_pan_action_constructed (GObject *gobject)
 {
  ClutterGestureAction *gesture;
-  ClutterGestureTriggerEdge edge;

  gesture = CLUTTER_GESTURE_ACTION (gobject);
-  edge = CLUTTER_GESTURE_TRIGGER_EDGE_AFTER;
-  clutter_gesture_action_set_threshold_trigger_edge (gesture, edge);
+  clutter_gesture_action_set_threshold_trigger_edge (gesture, CLUTTER_GESTURE_TRIGGER_EDGE_AFTER);
 }

 static void
@@ -463,12 +440,9 @@ clutter_pan_action_set_actor (ClutterActorMeta *meta,
      /* make sure we reset the state */
      if (priv->state == PAN_STATE_INTERPOLATING)
        g_clear_object (&priv->deceleration_timeline);
-      else if (priv->deceleration_timeline)
-        clutter_timeline_set_actor (priv->deceleration_timeline, actor);
    }

-  CLUTTER_ACTOR_META_CLASS (clutter_pan_action_parent_class)->set_actor (meta,
-                                                                         actor);
+  CLUTTER_ACTOR_META_CLASS (clutter_pan_action_parent_class)->set_actor (meta, actor);
 }


@@ -906,9 +880,7 @@ clutter_pan_action_get_constrained_motion_delta (ClutterPanAction *self,

  priv = self->priv;

-  distance = clutter_pan_action_get_motion_delta (self, point,
-                                                  &delta_x,
-                                                  &delta_y);
+  distance = clutter_pan_action_get_motion_delta (self, point, &delta_x, &delta_y);

  switch (priv->pan_axis)
    {
--- a/clutter/clutter/clutter-private.h
+++ b/clutter/clutter/clutter-private.h
@@ -37,6 +37,7 @@
 #include "clutter-feature.h"
 #include "clutter-id-pool.h"
 #include "clutter-layout-manager.h"
+#include "clutter-master-clock.h"
 #include "clutter-settings.h"
 #include "clutter-stage-manager.h"
 #include "clutter-stage.h"
@@ -64,6 +65,7 @@ typedef struct _ClutterVertex4          ClutterVertex4;

 #define CLUTTER_ACTOR_IS_TOPLEVEL(a)            ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IS_TOPLEVEL) != FALSE)
 #define CLUTTER_ACTOR_IN_DESTRUCTION(a)         ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_DESTRUCTION) != FALSE)
+#define CLUTTER_ACTOR_IN_REPARENT(a)            ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_REPARENT) != FALSE)
 #define CLUTTER_ACTOR_IN_PAINT(a)               ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_PAINT) != FALSE)
 #define CLUTTER_ACTOR_IN_PICK(a)                ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_PICK) != FALSE)
 #define CLUTTER_ACTOR_IN_RELAYOUT(a)            ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_RELAYOUT) != FALSE)
@@ -97,6 +99,7 @@ typedef enum

  CLUTTER_IN_DESTRUCTION = 1 << 0,
  CLUTTER_IS_TOPLEVEL    = 1 << 1,
+  CLUTTER_IN_REPARENT    = 1 << 2,
  CLUTTER_IN_PREF_WIDTH  = 1 << 3,
  CLUTTER_IN_PREF_HEIGHT = 1 << 4,

@@ -121,8 +124,11 @@ struct _ClutterMainContext
  /* the object holding all the stage instances */
  ClutterStageManager *stage_manager;

+  /* the clock driving all the frame operations */
+  ClutterMasterClock *master_clock;
+
  /* the main event queue */
-  GAsyncQueue *events_queue;
+  GQueue *events_queue;

  /* the event filters added via clutter_event_add_filter. these are
   * ordered from least recently added to most recently added */
@@ -173,6 +179,11 @@ typedef struct
 gboolean _clutter_threads_dispatch      (gpointer data);
 void     _clutter_threads_dispatch_free (gpointer data);

+CLUTTER_EXPORT
+void                    _clutter_threads_acquire_lock                   (void);
+CLUTTER_EXPORT
+void                    _clutter_threads_release_lock                   (void);
+
 ClutterMainContext *    _clutter_context_get_default                    (void);
 void                    _clutter_context_lock                           (void);
 void                    _clutter_context_unlock                         (void);
@@ -237,9 +248,6 @@ gboolean _clutter_util_rectangle_intersection (const cairo_rectangle_int_t *src1
                                               const cairo_rectangle_int_t *src2,
                                               cairo_rectangle_int_t       *dest);

-gboolean clutter_util_rectangle_equal (const cairo_rectangle_int_t *src1,
-                                       const cairo_rectangle_int_t *src2);
-

 struct _ClutterVertex4
 {
@@ -307,36 +315,6 @@ gboolean        _clutter_run_progress_function  (GType gtype,

 void            clutter_timeline_cancel_delay (ClutterTimeline *timeline);

-static inline uint64_t
-us (uint64_t us)
-{
-  return us;
-}
-
-static inline uint32_t
-ms (uint32_t ms)
-{
-  return ms;
-}
-
-static inline uint64_t
-ms2us (uint64_t ms)
-{
-  return us (ms * 1000);
-}
-
-static inline uint32_t
-us2ms (uint64_t us)
-{
-  return (uint32_t) (us / 1000);
-}
-
-static inline uint64_t
-ns2us (uint64_t ns)
-{
-  return us (ns / 1000);
-}
-
 G_END_DECLS

 #endif /* __CLUTTER_PRIVATE_H__ */
--- a/clutter/clutter/clutter-property-transition.c
+++ b/clutter/clutter/clutter-property-transition.c
@@ -278,26 +278,6 @@ clutter_property_transition_init (ClutterPropertyTransition *self)
  self->priv = clutter_property_transition_get_instance_private (self);
 }

-/**
- * clutter_property_transition_new_for_actor:
- * @actor: a #ClutterActor
- * @property_name: (allow-none): a property of @animatable, or %NULL
- *
- * Creates a new #ClutterPropertyTransition.
- *
- * Return value: (transfer full): the newly created #ClutterPropertyTransition.
- *   Use g_object_unref() when done
- */
-ClutterTransition *
-clutter_property_transition_new_for_actor (ClutterActor *actor,
-                                           const char   *property_name)
-{
-  return g_object_new (CLUTTER_TYPE_PROPERTY_TRANSITION,
-                       "actor", actor,
-                       "property-name", property_name,
-                       NULL);
-}
-
 /**
 * clutter_property_transition_new:
 * @property_name: (allow-none): a property of @animatable, or %NULL
--- a/clutter/clutter/clutter-property-transition.h
+++ b/clutter/clutter/clutter-property-transition.h
@@ -78,13 +78,8 @@ struct _ClutterPropertyTransitionClass
 CLUTTER_EXPORT
 GType clutter_property_transition_get_type (void) G_GNUC_CONST;

-CLUTTER_EXPORT
-ClutterTransition *     clutter_property_transition_new_for_actor       (ClutterActor              *actor,
-                                                                         const char                *property_name);
-
 CLUTTER_EXPORT
 ClutterTransition *     clutter_property_transition_new                 (const char                *property_name);
-
 CLUTTER_EXPORT
 void                    clutter_property_transition_set_property_name   (ClutterPropertyTransition *transition,
                                                                         const char                *property_name);
--- a/clutter/clutter/clutter-script-parser.c
+++ b/clutter/clutter/clutter-script-parser.c
@@ -34,6 +34,7 @@

 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "deprecated/clutter-container.h"
+#include "deprecated/clutter-alpha.h"

 #include "clutter-actor.h"
 #include "clutter-debug.h"
@@ -798,6 +799,232 @@ parse_signals (ClutterScript *script,
  return retval;
 }

+static ClutterTimeline *
+construct_timeline (ClutterScript *script,
+                    JsonObject    *object)
+{
+  ClutterTimeline *retval = NULL;
+  ObjectInfo *oinfo;
+  GList *members, *l;
+
+  /* we fake an ObjectInfo so we can reuse clutter_script_construct_object()
+   * here; we do not save it inside the hash table, because if this had
+   * been a named object then we wouldn't have ended up here in the first
+   * place
+   */
+  oinfo = g_slice_new0 (ObjectInfo);
+  oinfo->gtype = CLUTTER_TYPE_TIMELINE;
+  oinfo->id = g_strdup ("dummy");
+
+  members = json_object_get_members (object);
+  for (l = members; l != NULL; l = l->next)
+    {
+      const gchar *name = l->data;
+      JsonNode *node = json_object_get_member (object, name);
+      PropertyInfo *pinfo = g_slice_new0 (PropertyInfo);
+
+      pinfo->name = g_strdelimit (g_strdup (name), G_STR_DELIMITERS, '-');
+      pinfo->node = json_node_copy (node);
+
+      oinfo->properties = g_list_prepend (oinfo->properties, pinfo);
+    }
+
+  g_list_free (members);
+
+  _clutter_script_construct_object (script, oinfo);
+  _clutter_script_apply_properties (script, oinfo);
+  retval = CLUTTER_TIMELINE (oinfo->object);
+
+  /* we transfer ownership to the alpha function, so we ref before
+   * destroying the ObjectInfo to avoid the timeline going away
+   */
+  g_object_ref (retval);
+  object_info_free (oinfo);
+
+  return retval;
+}
+
+/* define the names of the animation modes to match the ones
+ * that developers might be more accustomed to
+ */
+static const struct
+{
+  const gchar *name;
+  ClutterAnimationMode mode;
+} animation_modes[] = {
+  { "linear", CLUTTER_LINEAR },
+  { "easeInQuad", CLUTTER_EASE_IN_QUAD },
+  { "easeOutQuad", CLUTTER_EASE_OUT_QUAD },
+  { "easeInOutQuad", CLUTTER_EASE_IN_OUT_QUAD },
+  { "easeInCubic", CLUTTER_EASE_IN_CUBIC },
+  { "easeOutCubic", CLUTTER_EASE_OUT_CUBIC },
+  { "easeInOutCubic", CLUTTER_EASE_IN_OUT_CUBIC },
+  { "easeInQuart", CLUTTER_EASE_IN_QUART },
+  { "easeOutQuart", CLUTTER_EASE_OUT_QUART },
+  { "easeInOutQuart", CLUTTER_EASE_IN_OUT_QUART },
+  { "easeInQuint", CLUTTER_EASE_IN_QUINT },
+  { "easeOutQuint", CLUTTER_EASE_OUT_QUINT },
+  { "easeInOutQuint", CLUTTER_EASE_IN_OUT_QUINT },
+  { "easeInSine", CLUTTER_EASE_IN_SINE },
+  { "easeOutSine", CLUTTER_EASE_OUT_SINE },
+  { "easeInOutSine", CLUTTER_EASE_IN_OUT_SINE },
+  { "easeInExpo", CLUTTER_EASE_IN_EXPO },
+  { "easeOutExpo", CLUTTER_EASE_OUT_EXPO },
+  { "easeInOutExpo", CLUTTER_EASE_IN_OUT_EXPO },
+  { "easeInCirc", CLUTTER_EASE_IN_CIRC },
+  { "easeOutCirc", CLUTTER_EASE_OUT_CIRC },
+  { "easeInOutCirc", CLUTTER_EASE_IN_OUT_CIRC },
+  { "easeInElastic", CLUTTER_EASE_IN_ELASTIC },
+  { "easeOutElastic", CLUTTER_EASE_OUT_ELASTIC },
+  { "easeInOutElastic", CLUTTER_EASE_IN_OUT_ELASTIC },
+  { "easeInBack", CLUTTER_EASE_IN_BACK },
+  { "easeOutBack", CLUTTER_EASE_OUT_BACK },
+  { "easeInOutBack", CLUTTER_EASE_IN_OUT_BACK },
+  { "easeInBounce", CLUTTER_EASE_IN_BOUNCE },
+  { "easeOutBounce", CLUTTER_EASE_OUT_BOUNCE },
+  { "easeInOutBounce", CLUTTER_EASE_IN_OUT_BOUNCE },
+};
+
+static const gint n_animation_modes = G_N_ELEMENTS (animation_modes);
+
+gulong
+_clutter_script_resolve_animation_mode (JsonNode *node)
+{
+  gint i, res = CLUTTER_CUSTOM_MODE;
+
+  if (JSON_NODE_TYPE (node) != JSON_NODE_VALUE)
+    return CLUTTER_CUSTOM_MODE;
+
+  if (json_node_get_value_type (node) == G_TYPE_INT64)
+    return json_node_get_int (node);
+
+  if (json_node_get_value_type (node) == G_TYPE_STRING)
+    {
+      const gchar *name = json_node_get_string (node);
+
+      /* XXX - we might be able to optimize by changing the ordering
+       * of the animation_modes array, e.g.
+       *  - special casing linear
+       *  - tokenizing ('ease', 'In', 'Sine') and matching on token
+       *  - binary searching?
+       */
+      for (i = 0; i < n_animation_modes; i++)
+        {
+          if (strcmp (animation_modes[i].name, name) == 0)
+            return animation_modes[i].mode;
+        }
+
+      if (_clutter_script_enum_from_string (CLUTTER_TYPE_ANIMATION_MODE,
+                                            name,
+                                            &res))
+        return res;
+
+      g_warning ("Unable to find the animation mode '%s'", name);
+    }
+
+  return CLUTTER_CUSTOM_MODE;
+}
+
+static ClutterAlphaFunc
+resolve_alpha_func (const gchar *name)
+{
+  static GModule *module = NULL;
+  ClutterAlphaFunc func;
+
+  CLUTTER_NOTE (SCRIPT, "Looking up '%s' alpha function", name);
+
+  if (G_UNLIKELY (!module))
+    module = g_module_open (NULL, 0);
+
+  if (g_module_symbol (module, name, (gpointer) &func))
+    {
+      CLUTTER_NOTE (SCRIPT, "Found '%s' alpha function in the symbols table",
+                    name);
+      return func;
+    }
+
+  return NULL;
+}
+
+GObject *
+_clutter_script_parse_alpha (ClutterScript *script,
+                             JsonNode      *node)
+{
+  GObject *retval = NULL;
+  JsonObject *object;
+  ClutterTimeline *timeline = NULL;
+  ClutterAlphaFunc alpha_func = NULL;
+  ClutterAnimationMode mode = CLUTTER_CUSTOM_MODE;
+  JsonNode *val;
+  gboolean unref_timeline = FALSE;
+
+  if (JSON_NODE_TYPE (node) != JSON_NODE_OBJECT)
+    return NULL;
+
+  object = json_node_get_object (node);
+
+  val = json_object_get_member (object, "timeline");
+  if (val)
+    {
+      if (JSON_NODE_TYPE (val) == JSON_NODE_VALUE &&
+          json_node_get_string (val) != NULL)
+        {
+          const gchar *id_ = json_node_get_string (val);
+
+          timeline =
+            CLUTTER_TIMELINE (clutter_script_get_object (script, id_));
+        }
+      else if (JSON_NODE_TYPE (val) == JSON_NODE_OBJECT)
+        {
+          timeline = construct_timeline (script, json_node_get_object (val));
+          unref_timeline = TRUE;
+        }
+    }
+
+  val = json_object_get_member (object, "mode");
+  if (val != NULL)
+    mode = _clutter_script_resolve_animation_mode (val);
+
+  if (mode == CLUTTER_CUSTOM_MODE)
+    {
+      val = json_object_get_member (object, "function");
+      if (val && json_node_get_string (val) != NULL)
+        {
+          alpha_func = resolve_alpha_func (json_node_get_string (val));
+          if (!alpha_func)
+            {
+              g_warning ("Unable to find the function '%s' in the "
+                         "Clutter alpha functions or the symbols table",
+                         json_node_get_string (val));
+            }
+        }
+    }
+
+  CLUTTER_NOTE (SCRIPT, "Parsed alpha: %s timeline (%p) (mode:%d, func:%p)",
+                unref_timeline ? "implicit" : "explicit",
+                timeline ? timeline : 0x0,
+                mode != CLUTTER_CUSTOM_MODE ? mode : 0,
+                alpha_func ? alpha_func : 0x0);
+
+  retval = g_object_new (CLUTTER_TYPE_ALPHA, NULL);
+
+  if (mode != CLUTTER_CUSTOM_MODE)
+    clutter_alpha_set_mode (CLUTTER_ALPHA (retval), mode);
+
+  if (alpha_func != NULL)
+    clutter_alpha_set_func (CLUTTER_ALPHA (retval), alpha_func, NULL, NULL);
+
+  clutter_alpha_set_timeline (CLUTTER_ALPHA (retval), timeline);
+
+  /* if we created an implicit timeline, the Alpha has full ownership
+   * of it now, since it won't be accessible from ClutterScript
+   */
+  if (unref_timeline)
+    g_object_unref (timeline);
+
+  return retval;
+}
+
 static void
 clutter_script_parser_object_end (JsonParser *json_parser,
                                  JsonObject *object)
@@ -1523,7 +1750,7 @@ clutter_script_construct_parameters (ClutterScript  *script,
          continue;
        }

-      if (!(pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY)))
+      if (!(pspec->flags & G_PARAM_CONSTRUCT_ONLY))
        {
          unparsed = g_list_prepend (unparsed, pinfo);
          continue;
--- a/clutter/clutter/clutter-script-private.h
+++ b/clutter/clutter/clutter-script-private.h
@@ -110,6 +110,8 @@ gboolean _clutter_script_parse_node        (ClutterScript *script,
 GType    _clutter_script_get_type_from_symbol (const gchar *symbol);
 GType    _clutter_script_get_type_from_class  (const gchar *name);

+gulong   _clutter_script_resolve_animation_mode (JsonNode *node);
+
 gboolean _clutter_script_enum_from_string  (GType          gtype,
                                            const gchar   *string,
                                            gint          *enum_value);
@@ -126,6 +128,8 @@ gboolean _clutter_script_parse_rect        (ClutterScript   *script,
 gboolean _clutter_script_parse_color       (ClutterScript   *script,
                                            JsonNode        *node,
                                            ClutterColor    *color);
+GObject *_clutter_script_parse_alpha       (ClutterScript   *script,
+                                            JsonNode        *node);
 gboolean _clutter_script_parse_point       (ClutterScript    *script,
                                            JsonNode         *node,
                                            graphene_point_t *point);
--- a/clutter/clutter/clutter-script.c
+++ b/clutter/clutter/clutter-script.c
@@ -50,14 +50,14 @@
 * <informalexample><programlisting><![CDATA[
 * {
 *   "id"     : "red-button",
- *   "type"   : "ClutterActor",
+ *   "type"   : "ClutterRectangle",
 *   "width"  : 100,
 *   "height" : 100,
- *   "background-color" : "&num;ff0000ff"
+ *   "color"  : "&num;ff0000ff"
 * }
 * ]]></programlisting></informalexample>
 *
- * This will produce a red #ClutterActor, 100x100 pixels wide, and
+ * This will produce a red #ClutterRectangle, 100x100 pixels wide, and
 * with a ClutterScript id of "red-button"; it can be retrieved by calling:
 *
 * |[
@@ -98,6 +98,49 @@
 * respectively) and the "object" string member for calling
 * g_signal_connect_object() instead of g_signal_connect().
 *
+ * Signals can also be directly attached to a specific state defined
+ * inside a #ClutterState instance, for instance:
+ *
+ * |[
+ *   ...
+ *   "signals" : [
+ *     {
+ *       "name" : "enter-event",
+ *       "states" : "button-states",
+ *       "target-state" : "hover"
+ *     },
+ *     {
+ *       "name" : "leave-event",
+ *       "states" : "button-states",
+ *       "target-state" : "base"
+ *     },
+ *     {
+ *       "name" : "button-press-event",
+ *       "states" : "button-states",
+ *       "target-state" : "active",
+ *     },
+ *     {
+ *       "name" : "key-press-event",
+ *       "states" : "button-states",
+ *       "target-state" : "key-focus",
+ *       "warp" : true
+ *     }
+ *   ],
+ *   ...
+ * ]|
+ *
+ * The "states" key defines the #ClutterState instance to be used to
+ * resolve the "target-state" key; it can be either a script id for a
+ * #ClutterState built by the same #ClutterScript instance, or to a
+ * #ClutterState built in code and associated to the #ClutterScript
+ * instance through the clutter_script_add_states() function. If no
+ * "states" key is present, then the default #ClutterState associated to
+ * the #ClutterScript instance will be used; the default #ClutterState
+ * can be set using clutter_script_add_states() using a %NULL name. The
+ * "warp" key can be used to warp to a specific state instead of
+ * animating to it. State changes on signal emission will not affect
+ * the signal emission chain.
+ *
 * Clutter reserves the following names, so classes defining properties
 * through the usual GObject registration process should avoid using these
 * names to avoid collisions:
@@ -141,7 +184,9 @@
 #include "clutter-private.h"
 #include "clutter-debug.h"

+#include "deprecated/clutter-alpha.h"
 #include "deprecated/clutter-container.h"
+#include "deprecated/clutter-state.h"

 enum
 {
@@ -165,6 +210,8 @@ struct _ClutterScriptPrivate

  ClutterScriptParser *parser;

+  GHashTable *states;
+
  gchar **search_paths;

  gchar *translation_domain;
@@ -217,6 +264,7 @@ signal_info_free (gpointer data)
      g_free (sinfo->name);
      g_free (sinfo->handler);
      g_free (sinfo->object);
+      g_free (sinfo->state);
      g_free (sinfo->target);

      g_slice_free (SignalInfo, sinfo);
@@ -271,6 +319,7 @@ clutter_script_finalize (GObject *gobject)
  g_hash_table_destroy (priv->objects);
  g_strfreev (priv->search_paths);
  g_free (priv->filename);
+  g_hash_table_destroy (priv->states);
  g_free (priv->translation_domain);

  G_OBJECT_CLASS (clutter_script_parent_class)->finalize (gobject);
@@ -405,6 +454,9 @@ clutter_script_init (ClutterScript *script)
  priv->objects = g_hash_table_new_full (g_str_hash, g_str_equal,
                                         NULL,
                                         object_info_free);
+  priv->states = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                        g_free,
+                                        (GDestroyNotify) g_object_unref);
 }

 /**
@@ -920,12 +972,65 @@ clutter_script_connect_signals (ClutterScript *script,
  g_free (cd);
 }

+typedef struct {
+  ClutterState *state;
+  GObject *emitter;
+  gchar *target;
+  gulong signal_id;
+  gulong hook_id;
+  gboolean warp_to;
+} HookData;
+
 typedef struct {
  ClutterScript *script;
  ClutterScriptConnectFunc func;
  gpointer user_data;
 } SignalConnectData;

+static void
+hook_data_free (gpointer data)
+{
+  if (G_LIKELY (data != NULL))
+    {
+      HookData *hook_data = data;
+
+      g_free (hook_data->target);
+      g_slice_free (HookData, hook_data);
+    }
+}
+
+static gboolean
+clutter_script_state_change_hook (GSignalInvocationHint *ihint,
+                                  guint                  n_params,
+                                  const GValue          *params,
+                                  gpointer               user_data)
+{
+  HookData *hook_data = user_data;
+  GObject *emitter;
+
+  emitter = g_value_get_object (&params[0]);
+
+  if (emitter == hook_data->emitter)
+    {
+      if (hook_data->warp_to)
+        clutter_state_warp_to_state (hook_data->state, hook_data->target);
+      else
+        clutter_state_set_state (hook_data->state, hook_data->target);
+    }
+
+  return TRUE;
+}
+
+static void
+clutter_script_remove_state_change_hook (gpointer  user_data,
+                                         GObject  *object_p)
+{
+  HookData *hook_data = user_data;
+
+  g_signal_remove_emission_hook (hook_data->signal_id,
+                                 hook_data->hook_id);
+}
+
 static void
 connect_each_object (gpointer key,
                     gpointer value,
@@ -965,7 +1070,64 @@ connect_each_object (gpointer key,
        }
      else
        {
-          g_warn_if_reached ();
+          GObject *state_object = NULL;
+          const gchar *signal_name, *signal_detail;
+          gchar **components;
+          GQuark signal_quark;
+          guint signal_id;
+          HookData *hook_data;
+
+          if (sinfo->state == NULL)
+            state_object = (GObject *) clutter_script_get_states (script, NULL);
+          else
+            {
+              state_object = clutter_script_get_object (script, sinfo->state);
+              if (state_object == NULL)
+                state_object = (GObject *) clutter_script_get_states (script, sinfo->state);
+            }
+
+          if (state_object == NULL)
+            continue;
+
+          components = g_strsplit (sinfo->name, "::", 2);
+          if (g_strv_length (components) == 2)
+            {
+              signal_name = components[0];
+              signal_detail = components[1];
+            }
+          else
+            {
+              signal_name = components[0];
+              signal_detail = NULL;
+            }
+
+          signal_id = g_signal_lookup (signal_name, G_OBJECT_TYPE (object));
+          if (signal_id == 0)
+            {
+              g_strfreev (components);
+              continue;
+            }
+
+          if (signal_detail != NULL)
+            signal_quark = g_quark_from_string (signal_detail);
+          else
+            signal_quark = 0;
+
+          hook_data = g_slice_new (HookData);
+          hook_data->emitter = object;
+          hook_data->state = CLUTTER_STATE (state_object);
+          hook_data->target = g_strdup (sinfo->target);
+          hook_data->warp_to = sinfo->warp_to;
+          hook_data->signal_id = signal_id;
+          hook_data->hook_id =
+            g_signal_add_emission_hook (signal_id, signal_quark,
+                                        clutter_script_state_change_hook,
+                                        hook_data,
+                                        hook_data_free);
+
+          g_object_weak_ref (hook_data->emitter,
+                             clutter_script_remove_state_change_hook,
+                             hook_data);
        }

      signal_info_free (sinfo);
@@ -1190,6 +1352,72 @@ clutter_script_list_objects (ClutterScript *script)
  return retval;
 }

+/**
+ * clutter_script_add_states:
+ * @script: a #ClutterScript
+ * @name: (allow-none): a name for the @state, or %NULL to
+ *   set the default #ClutterState
+ * @state: a #ClutterState
+ *
+ * Associates a #ClutterState to the #ClutterScript instance using the given
+ * name.
+ *
+ * The #ClutterScript instance will use @state to resolve target states when
+ * connecting signal handlers.
+ *
+ * The #ClutterScript instance will take a reference on the #ClutterState
+ * passed to this function.
+ *
+ * Since: 1.8
+ *
+ * Deprecated: 1.12
+ */
+void
+clutter_script_add_states (ClutterScript *script,
+                           const gchar   *name,
+                           ClutterState  *state)
+{
+  g_return_if_fail (CLUTTER_IS_SCRIPT (script));
+  g_return_if_fail (CLUTTER_IS_STATE (state));
+
+  if (name == NULL || *name == '\0')
+    name = "__clutter_script_default_state";
+
+  g_hash_table_replace (script->priv->states,
+                        g_strdup (name),
+                        g_object_ref (state));
+}
+
+/**
+ * clutter_script_get_states:
+ * @script: a #ClutterScript
+ * @name: (allow-none): the name of the #ClutterState, or %NULL
+ *
+ * Retrieves the #ClutterState for the given @state_name.
+ *
+ * If @name is %NULL, this function will return the default
+ * #ClutterState instance.
+ *
+ * Return value: (transfer none): a pointer to the #ClutterState for the
+ *   given name. The #ClutterState is owned by the #ClutterScript instance
+ *   and it should not be unreferenced
+ *
+ * Since: 1.8
+ *
+ * Deprecated: 1.12
+ */
+ClutterState *
+clutter_script_get_states (ClutterScript *script,
+                           const gchar   *name)
+{
+  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), NULL);
+
+  if (name == NULL || *name == '\0')
+    name = "__clutter_script_default_state";
+
+  return g_hash_table_lookup (script->priv->states, name);
+}
+
 /**
 * clutter_script_set_translation_domain:
 * @script: a #ClutterScript
--- a/clutter/clutter/clutter-script.h
+++ b/clutter/clutter/clutter-script.h
@@ -179,6 +179,15 @@ void            clutter_script_unmerge_objects          (ClutterScript
 CLUTTER_EXPORT
 void            clutter_script_ensure_objects           (ClutterScript             *script);

+CLUTTER_DEPRECATED
+void            clutter_script_add_states               (ClutterScript             *script,
+                                                         const gchar               *name,
+                                                         ClutterState              *state);
+
+CLUTTER_DEPRECATED
+ClutterState *  clutter_script_get_states               (ClutterScript             *script,
+                                                         const gchar               *name);
+
 CLUTTER_EXPORT
 void            clutter_script_connect_signals          (ClutterScript             *script,
                                                         gpointer                   user_data);
--- a/clutter/clutter/clutter-seat.c
+++ b/clutter/clutter/clutter-seat.c
@@ -27,7 +27,6 @@
 #include "clutter-input-device-tool.h"
 #include "clutter-input-pointer-a11y-private.h"
 #include "clutter-marshal.h"
-#include "clutter-mutter.h"
 #include "clutter-private.h"
 #include "clutter-seat.h"
 #include "clutter-virtual-input-device.h"
@@ -66,6 +65,9 @@ struct _ClutterSeatPrivate

  unsigned int inhibit_unfocus_count;

+  /* Keyboard a11y */
+  ClutterKbdA11ySettings kbd_a11y_settings;
+
  /* Pointer a11y */
  ClutterPointerA11ySettings pointer_a11y_settings;
 };
@@ -352,17 +354,6 @@ clutter_seat_get_keyboard (ClutterSeat *seat)
  return CLUTTER_SEAT_GET_CLASS (seat)->get_keyboard (seat);
 }

-/**
- * clutter_seat_peek_devices: (skip)
- **/
-const GList *
-clutter_seat_peek_devices (ClutterSeat *seat)
-{
-  g_return_val_if_fail (CLUTTER_IS_SEAT (seat), NULL);
-
-  return CLUTTER_SEAT_GET_CLASS (seat)->peek_devices (seat);
-}
-
 /**
 * clutter_seat_list_devices:
 * @seat: a #ClutterSeat
@@ -379,7 +370,7 @@ clutter_seat_list_devices (ClutterSeat *seat)
 {
  g_return_val_if_fail (CLUTTER_IS_SEAT (seat), NULL);

-  return g_list_copy ((GList *)clutter_seat_peek_devices (seat));
+  return CLUTTER_SEAT_GET_CLASS (seat)->list_devices (seat);
 }

 void
@@ -402,6 +393,43 @@ clutter_seat_get_keymap (ClutterSeat *seat)
  return CLUTTER_SEAT_GET_CLASS (seat)->get_keymap (seat);
 }

+static gboolean
+are_kbd_a11y_settings_equal (ClutterKbdA11ySettings *a,
+                             ClutterKbdA11ySettings *b)
+{
+  return (memcmp (a, b, sizeof (ClutterKbdA11ySettings)) == 0);
+}
+
+void
+clutter_seat_set_kbd_a11y_settings (ClutterSeat            *seat,
+                                    ClutterKbdA11ySettings *settings)
+{
+  ClutterSeatClass *seat_class;
+  ClutterSeatPrivate *priv = clutter_seat_get_instance_private (seat);
+
+  g_return_if_fail (CLUTTER_IS_SEAT (seat));
+
+  if (are_kbd_a11y_settings_equal (&priv->kbd_a11y_settings, settings))
+    return;
+
+  priv->kbd_a11y_settings = *settings;
+
+  seat_class = CLUTTER_SEAT_GET_CLASS (seat);
+  if (seat_class->apply_kbd_a11y_settings)
+    seat_class->apply_kbd_a11y_settings (seat, settings);
+}
+
+void
+clutter_seat_get_kbd_a11y_settings (ClutterSeat            *seat,
+                                    ClutterKbdA11ySettings *settings)
+{
+  ClutterSeatPrivate *priv = clutter_seat_get_instance_private (seat);
+
+  g_return_if_fail (CLUTTER_IS_SEAT (seat));
+
+  *settings = priv->kbd_a11y_settings;
+}
+
 void
 clutter_seat_ensure_a11y_state (ClutterSeat *seat)
 {
@@ -606,8 +634,8 @@ clutter_seat_create_virtual_device (ClutterSeat            *seat,
 }

 /**
- * clutter_seat_get_supported_virtual_device_types: (skip)
- **/
+ * clutter_seat_supported_virtual_device_types: (skip)
+ */
 ClutterVirtualDeviceType
 clutter_seat_get_supported_virtual_device_types (ClutterSeat *seat)
 {
@@ -635,40 +663,6 @@ clutter_seat_compress_motion (ClutterSeat        *seat,
    seat_class->compress_motion (seat, event, to_discard);
 }

-gboolean
-clutter_seat_handle_event_post (ClutterSeat        *seat,
-                                const ClutterEvent *event)
-{
-  ClutterSeatClass *seat_class;
-  ClutterInputDevice *device;
-
-  g_return_val_if_fail (CLUTTER_IS_SEAT (seat), FALSE);
-  g_return_val_if_fail (event, FALSE);
-
-  seat_class = CLUTTER_SEAT_GET_CLASS (seat);
-
-  if (seat_class->handle_event_post)
-    seat_class->handle_event_post (seat, event);
-
-  device = clutter_event_get_source_device (event);
-  g_assert_true (CLUTTER_IS_INPUT_DEVICE (device));
-
-  switch (event->type)
-    {
-      case CLUTTER_DEVICE_ADDED:
-        g_signal_emit (seat, signals[DEVICE_ADDED], 0, device);
-        break;
-      case CLUTTER_DEVICE_REMOVED:
-        g_signal_emit (seat, signals[DEVICE_REMOVED], 0, device);
-        g_object_run_dispose (G_OBJECT (device));
-        break;
-      default:
-        break;
-    }
-
-  return TRUE;
-}
-
 void
 clutter_seat_warp_pointer (ClutterSeat *seat,
                           int          x,
@@ -688,6 +682,7 @@ clutter_seat_warp_pointer (ClutterSeat *seat,
 * requirements are fulfilled:
 *
 *  - A touchscreen is available
+ *  - No external keyboard is attached to the device
 *  - A tablet mode switch, if present, is enabled
 *
 * Returns: %TRUE if the device is a tablet that doesn't have an external
@@ -704,20 +699,3 @@ clutter_seat_get_touch_mode (ClutterSeat *seat)

  return touch_mode;
 }
-
-gboolean
-clutter_seat_query_state (ClutterSeat          *seat,
-                          ClutterInputDevice   *device,
-                          ClutterEventSequence *sequence,
-                          graphene_point_t     *coords,
-                          ClutterModifierType  *modifiers)
-{
-  g_return_val_if_fail (CLUTTER_IS_SEAT (seat), FALSE);
-  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), FALSE);
-
-  return CLUTTER_SEAT_GET_CLASS (seat)->query_state (seat,
-                                                     device,
-                                                     sequence,
-                                                     coords,
-                                                     modifiers);
-}
--- a/clutter/clutter/clutter-seat.h
+++ b/clutter/clutter/clutter-seat.h
@@ -37,6 +37,24 @@ CLUTTER_EXPORT
 G_DECLARE_DERIVABLE_TYPE (ClutterSeat, clutter_seat,
 			  CLUTTER, SEAT, GObject)

+/**
+ * ClutterKbdA11ySettings:
+ *
+ * The #ClutterKbdA11ySettings structure contains keyboard accessibility
+ * settings
+ *
+ */
+typedef struct _ClutterKbdA11ySettings
+{
+  ClutterKeyboardA11yFlags controls;
+  gint slowkeys_delay;
+  gint debounce_delay;
+  gint timeout_delay;
+  gint mousekeys_init_delay;
+  gint mousekeys_max_speed;
+  gint mousekeys_accel_time;
+} ClutterKbdA11ySettings;
+
 /**
 * ClutterPointerA11ySettings:
 *
@@ -78,7 +96,7 @@ struct _ClutterSeatClass
  ClutterInputDevice * (* get_pointer)  (ClutterSeat *seat);
  ClutterInputDevice * (* get_keyboard) (ClutterSeat *seat);

-  const GList * (* peek_devices) (ClutterSeat *seat);
+  GList * (* list_devices) (ClutterSeat *seat);

  void (* bell_notify) (ClutterSeat *seat);

@@ -88,19 +106,10 @@ struct _ClutterSeatClass
                            ClutterEvent       *event,
                            const ClutterEvent *to_discard);

-  gboolean (* handle_event_post) (ClutterSeat        *seat,
-                                  const ClutterEvent *event);
-
  void (* warp_pointer) (ClutterSeat *seat,
                         int          x,
                         int          y);

-  gboolean (* query_state) (ClutterSeat          *seat,
-                            ClutterInputDevice   *device,
-                            ClutterEventSequence *sequence,
-                            graphene_point_t     *coords,
-                            ClutterModifierType  *modifiers);
-
  /* Event platform data */
  void (* copy_event_data) (ClutterSeat        *seat,
                            const ClutterEvent *src,
@@ -108,6 +117,10 @@ struct _ClutterSeatClass
  void (* free_event_data) (ClutterSeat        *seat,
                            ClutterEvent       *event);

+  /* Keyboard accessibility */
+  void (* apply_kbd_a11y_settings) (ClutterSeat            *seat,
+                                    ClutterKbdA11ySettings *settings);
+
  /* Virtual devices */
  ClutterVirtualInputDevice * (* create_virtual_device) (ClutterSeat            *seat,
                                                         ClutterInputDeviceType  device_type);
@@ -120,13 +133,18 @@ CLUTTER_EXPORT
 ClutterInputDevice * clutter_seat_get_keyboard (ClutterSeat *seat);
 CLUTTER_EXPORT
 GList * clutter_seat_list_devices (ClutterSeat *seat);
-const GList * clutter_seat_peek_devices (ClutterSeat *seat);
 CLUTTER_EXPORT
 void clutter_seat_bell_notify (ClutterSeat *seat);

 CLUTTER_EXPORT
 ClutterKeymap * clutter_seat_get_keymap (ClutterSeat *seat);

+CLUTTER_EXPORT
+void clutter_seat_set_kbd_a11y_settings (ClutterSeat            *seat,
+                                         ClutterKbdA11ySettings *settings);
+CLUTTER_EXPORT
+void clutter_seat_get_kbd_a11y_settings (ClutterSeat            *seat,
+                                         ClutterKbdA11ySettings *settings);
 CLUTTER_EXPORT
 void clutter_seat_ensure_a11y_state     (ClutterSeat            *seat);

@@ -169,11 +187,4 @@ void clutter_seat_warp_pointer (ClutterSeat *seat,
 CLUTTER_EXPORT
 gboolean clutter_seat_get_touch_mode (ClutterSeat *seat);

-CLUTTER_EXPORT
-gboolean clutter_seat_query_state (ClutterSeat          *seat,
-                                   ClutterInputDevice   *device,
-                                   ClutterEventSequence *sequence,
-                                   graphene_point_t     *coords,
-                                   ClutterModifierType  *modifiers);
-
 #endif /* CLUTTER_SEAT_H */
--- a/clutter/clutter/clutter-settings.c
+++ b/clutter/clutter/clutter-settings.c
@@ -40,18 +40,6 @@
 #define CLUTTER_IS_SETTINGS_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_SETTINGS))
 #define CLUTTER_SETTINGS_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_SETTINGS, ClutterSettingsClass))

-typedef struct
-{
-  cairo_antialias_t cairo_antialias;
-  gint clutter_font_antialias;
-
-  cairo_hint_style_t cairo_hint_style;
-  const char *clutter_font_hint_style;
-
-  cairo_subpixel_order_t cairo_subpixel_order;
-  const char *clutter_font_subpixel_order;
-} FontSettings;
-
 /**
 * ClutterSettings:
 *
@@ -65,7 +53,6 @@ struct _ClutterSettings
  GObject parent_instance;

  ClutterBackend *backend;
-  GSettings *xsettings;

  gint double_click_time;
  gint double_click_distance;
@@ -280,159 +267,6 @@ settings_update_fontmap (ClutterSettings *self,
 #endif /* HAVE_PANGO_FT2 */
 }

-static void
-get_font_gsettings (GSettings    *xsettings,
-                    FontSettings *output)
-{
-  /* org.gnome.settings-daemon.GsdFontAntialiasingMode */
-  static const struct
-  {
-    cairo_antialias_t cairo_antialias;
-    gint clutter_font_antialias;
-  }
-  antialiasings[] =
-  {
-    /* none=0      */ {CAIRO_ANTIALIAS_NONE,     0},
-    /* grayscale=1 */ {CAIRO_ANTIALIAS_GRAY,     1},
-    /* rgba=2      */ {CAIRO_ANTIALIAS_SUBPIXEL, 1},
-  };
-
-  /* org.gnome.settings-daemon.GsdFontHinting */
-  static const struct
-  {
-    cairo_hint_style_t cairo_hint_style;
-    const char *clutter_font_hint_style;
-  }
-  hintings[] =
-  {
-    /* none=0   */ {CAIRO_HINT_STYLE_NONE,   "hintnone"},
-    /* slight=1 */ {CAIRO_HINT_STYLE_SLIGHT, "hintslight"},
-    /* medium=2 */ {CAIRO_HINT_STYLE_MEDIUM, "hintmedium"},
-    /* full=3   */ {CAIRO_HINT_STYLE_FULL,   "hintfull"},
-  };
-
-  /* org.gnome.settings-daemon.GsdFontRgbaOrder */
-  static const struct
-  {
-    cairo_subpixel_order_t cairo_subpixel_order;
-    const char *clutter_font_subpixel_order;
-  }
-  rgba_orders[] =
-  {
-    /* rgba=0 */ {CAIRO_SUBPIXEL_ORDER_RGB,  "rgb"}, /* XXX what is 'rgba'? */
-    /* rgb=1  */ {CAIRO_SUBPIXEL_ORDER_RGB,  "rgb"},
-    /* bgr=2  */ {CAIRO_SUBPIXEL_ORDER_BGR,  "bgr"},
-    /* vrgb=3 */ {CAIRO_SUBPIXEL_ORDER_VRGB, "vrgb"},
-    /* vbgr=4 */ {CAIRO_SUBPIXEL_ORDER_VBGR, "vbgr"},
-  };
-  guint i;
-
-  i = g_settings_get_enum (xsettings, "hinting");
-  if (i < G_N_ELEMENTS (hintings))
-    {
-      output->cairo_hint_style = hintings[i].cairo_hint_style;
-      output->clutter_font_hint_style = hintings[i].clutter_font_hint_style;
-    }
-  else
-    {
-      output->cairo_hint_style = CAIRO_HINT_STYLE_DEFAULT;
-      output->clutter_font_hint_style = NULL;
-    }
-
-  i = g_settings_get_enum (xsettings, "antialiasing");
-  if (i < G_N_ELEMENTS (antialiasings))
-    {
-      output->cairo_antialias = antialiasings[i].cairo_antialias;
-      output->clutter_font_antialias = antialiasings[i].clutter_font_antialias;
-    }
-  else
-    {
-      output->cairo_antialias = CAIRO_ANTIALIAS_DEFAULT;
-      output->clutter_font_antialias = -1;
-    }
-
-  i = g_settings_get_enum (xsettings, "rgba-order");
-  if (i < G_N_ELEMENTS (rgba_orders))
-    {
-      output->cairo_subpixel_order = rgba_orders[i].cairo_subpixel_order;
-      output->clutter_font_subpixel_order = rgba_orders[i].clutter_font_subpixel_order;
-    }
-  else
-    {
-      output->cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
-      output->clutter_font_subpixel_order = NULL;
-    }
-
-  if (output->cairo_antialias == CAIRO_ANTIALIAS_GRAY)
-    output->clutter_font_subpixel_order = "none";
-}
-
-static void
-init_font_options (ClutterSettings *self)
-{
-  GSettings *xsettings = self->xsettings;
-  cairo_font_options_t *options = cairo_font_options_create ();
-  FontSettings fs;
-
-  get_font_gsettings (xsettings, &fs);
-
-  cairo_font_options_set_hint_style (options, fs.cairo_hint_style);
-  cairo_font_options_set_antialias (options, fs.cairo_antialias);
-  cairo_font_options_set_subpixel_order (options, fs.cairo_subpixel_order);
-
-  clutter_backend_set_font_options (self->backend, options);
-
-  cairo_font_options_destroy (options);
-}
-
-static gboolean
-on_xsettings_change_event (GSettings *xsettings,
-                           gpointer   keys,
-                           gint       n_keys,
-                           gpointer   user_data)
-{
-  ClutterSettings *self = CLUTTER_SETTINGS (user_data);
-  FontSettings fs;
-  gint hinting;
-
-  get_font_gsettings (xsettings, &fs);
-  hinting = fs.cairo_hint_style == CAIRO_HINT_STYLE_NONE ? 0 : 1;
-  g_object_set (self,
-                "font-hinting",        hinting,
-                "font-hint-style",     fs.clutter_font_hint_style,
-                "font-antialias",      fs.clutter_font_antialias,
-                "font-subpixel-order", fs.clutter_font_subpixel_order,
-                NULL);
-
-  return FALSE;
-}
-
-static void
-load_initial_settings (ClutterSettings *self)
-{
-  static const gchar xsettings_path[] =
-    "org.gnome.settings-daemon.plugins.xsettings";
-  GSettingsSchemaSource *source = g_settings_schema_source_get_default ();
-  GSettingsSchema *schema;
-
-  schema = g_settings_schema_source_lookup (source, xsettings_path, TRUE);
-  if (!schema)
-    {
-      g_warning ("Failed to find schema: %s", xsettings_path);
-    }
-  else
-    {
-      self->xsettings = g_settings_new_full (schema, NULL, NULL);
-      if (self->xsettings)
-        {
-          init_font_options (self);
-          g_signal_connect (self->xsettings, "change-event",
-                            G_CALLBACK (on_xsettings_change_event),
-                            self);
-        }
-    }
-}
-
 static void
 clutter_settings_finalize (GObject *gobject)
 {
@@ -442,8 +276,6 @@ clutter_settings_finalize (GObject *gobject)
  g_free (self->xft_hint_style);
  g_free (self->xft_rgba);

-  g_clear_object (&self->xsettings);
-
  G_OBJECT_CLASS (clutter_settings_parent_class)->finalize (gobject);
 }

@@ -908,8 +740,6 @@ _clutter_settings_set_backend (ClutterSettings *settings,
  g_assert (CLUTTER_IS_BACKEND (backend));

  settings->backend = backend;
-
-  load_initial_settings (settings);
 }

 #define SETTINGS_GROUP  "Settings"
--- a/clutter/clutter/clutter-stage-private.h
+++ b/clutter/clutter/clutter-stage-private.h
@@ -36,18 +36,11 @@ typedef struct _ClutterStageQueueRedrawEntry ClutterStageQueueRedrawEntry;
 /* stage */
 ClutterStageWindow *_clutter_stage_get_default_window    (void);

-void                clutter_stage_paint_view             (ClutterStage          *stage,
-                                                          ClutterStageView      *view,
-                                                          const cairo_region_t  *redraw_clip);
+void                _clutter_stage_paint_view            (ClutterStage                *stage,
+                                                          ClutterStageView            *view,
+                                                          const cairo_rectangle_int_t *clip);

-void                clutter_stage_emit_before_update     (ClutterStage          *stage,
-                                                          ClutterStageView      *view);
-void                clutter_stage_emit_before_paint      (ClutterStage          *stage,
-                                                          ClutterStageView      *view);
-void                clutter_stage_emit_after_paint       (ClutterStage          *stage,
-                                                          ClutterStageView      *view);
-void                clutter_stage_emit_after_update      (ClutterStage          *stage,
-                                                          ClutterStageView      *view);
+void                _clutter_stage_emit_after_paint      (ClutterStage          *stage);

 CLUTTER_EXPORT
 void                _clutter_stage_set_window            (ClutterStage          *stage,
@@ -57,6 +50,11 @@ ClutterStageWindow *_clutter_stage_get_window            (ClutterStage
 void                _clutter_stage_get_projection_matrix (ClutterStage          *stage,
                                                          CoglMatrix            *projection);
 void                _clutter_stage_dirty_projection      (ClutterStage          *stage);
+void                _clutter_stage_set_viewport          (ClutterStage          *stage,
+                                                          float                  x,
+                                                          float                  y,
+                                                          float                  width,
+                                                          float                  height);
 void                _clutter_stage_get_viewport          (ClutterStage          *stage,
                                                          float                 *x,
                                                          float                 *y,
@@ -65,12 +63,9 @@ void                _clutter_stage_get_viewport          (ClutterStage
 void                _clutter_stage_dirty_viewport        (ClutterStage          *stage);
 void                _clutter_stage_maybe_setup_viewport  (ClutterStage          *stage,
                                                          ClutterStageView      *view);
-void                clutter_stage_maybe_relayout         (ClutterActor          *stage);
-void                clutter_stage_maybe_finish_queue_redraws (ClutterStage      *stage);
-GSList *            clutter_stage_find_updated_devices   (ClutterStage          *stage);
-void                clutter_stage_update_devices         (ClutterStage          *stage,
-                                                          GSList                *devices);
-void                clutter_stage_update_actor_stage_views (ClutterStage        *stage);
+void                _clutter_stage_maybe_relayout        (ClutterActor          *stage);
+gboolean            _clutter_stage_needs_update          (ClutterStage          *stage);
+gboolean            _clutter_stage_do_update             (ClutterStage          *stage);

 CLUTTER_EXPORT
 void     _clutter_stage_queue_event                       (ClutterStage *stage,
@@ -79,6 +74,9 @@ void     _clutter_stage_queue_event                       (ClutterStage *stage,
 gboolean _clutter_stage_has_queued_events                 (ClutterStage *stage);
 void     _clutter_stage_process_queued_events             (ClutterStage *stage);
 void     _clutter_stage_update_input_devices              (ClutterStage *stage);
+void     _clutter_stage_schedule_update                   (ClutterStage *stage);
+gint64    _clutter_stage_get_update_time                  (ClutterStage *stage);
+void     _clutter_stage_clear_update_time                 (ClutterStage *stage);
 gboolean _clutter_stage_has_full_redraw_queued            (ClutterStage *stage);

 void clutter_stage_log_pick (ClutterStage           *stage,
@@ -133,22 +131,19 @@ gboolean                _clutter_stage_update_state     (ClutterStage      *stag

 void                    _clutter_stage_set_scale_factor (ClutterStage      *stage,
                                                         int                factor);
+gboolean                _clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage    *stage,
+                                                                           graphene_rect_t *rect,
+                                                                           float           *view_scale);

-void            clutter_stage_presented                 (ClutterStage      *stage,
-                                                         ClutterStageView  *view,
+void            _clutter_stage_presented                (ClutterStage      *stage,
+                                                         CoglFrameEvent     frame_event,
                                                         ClutterFrameInfo  *frame_info);

+GList *         _clutter_stage_peek_stage_views         (ClutterStage *stage);
+
 void            clutter_stage_queue_actor_relayout      (ClutterStage *stage,
                                                         ClutterActor *actor);

-void clutter_stage_dequeue_actor_relayout (ClutterStage *stage,
-                                           ClutterActor *actor);
-
-GList * clutter_stage_get_views_for_rect (ClutterStage          *stage,
-                                          const graphene_rect_t *rect);
-
-void clutter_stage_set_actor_needs_immediate_relayout (ClutterStage *stage);
-
 G_END_DECLS

 #endif /* __CLUTTER_STAGE_PRIVATE_H__ */
--- a/clutter/clutter/clutter-stage-view-private.h
+++ b/clutter/clutter/clutter-stage-view-private.h
@@ -19,56 +19,21 @@
 #define __CLUTTER_STAGE_VIEW_PRIVATE_H__

 #include "clutter/clutter-stage-view.h"
-#include "clutter/clutter-types.h"

-void clutter_stage_view_after_paint (ClutterStageView *view,
-                                     cairo_region_t   *redraw_clip);
-
-void clutter_stage_view_before_swap_buffer (ClutterStageView     *view,
-                                            const cairo_region_t *swap_region);
+void clutter_stage_view_after_paint (ClutterStageView            *view,
+                                     const cairo_rectangle_int_t *clip);

 gboolean clutter_stage_view_is_dirty_viewport (ClutterStageView *view);

-void clutter_stage_view_invalidate_viewport (ClutterStageView *view);
-
-void clutter_stage_view_set_viewport (ClutterStageView *view,
-                                      float             x,
-                                      float             y,
-                                      float             width,
-                                      float             height);
+void clutter_stage_view_set_dirty_viewport (ClutterStageView *view,
+                                            gboolean          dirty);

 gboolean clutter_stage_view_is_dirty_projection (ClutterStageView *view);

-void clutter_stage_view_invalidate_projection (ClutterStageView *view);
+void clutter_stage_view_set_dirty_projection (ClutterStageView *view,
+                                              gboolean          dirty);

-void clutter_stage_view_set_projection (ClutterStageView *view,
-                                        const CoglMatrix *matrix);
-
-void clutter_stage_view_add_redraw_clip (ClutterStageView            *view,
-                                         const cairo_rectangle_int_t *clip);
-
-gboolean clutter_stage_view_has_full_redraw_clip (ClutterStageView *view);
-
-gboolean clutter_stage_view_has_redraw_clip (ClutterStageView *view);
-
-const cairo_region_t * clutter_stage_view_peek_redraw_clip (ClutterStageView *view);
-
-cairo_region_t * clutter_stage_view_take_redraw_clip (ClutterStageView *view);
-
-CoglScanout * clutter_stage_view_take_scanout (ClutterStageView *view);
-
-void clutter_stage_view_transform_rect_to_onscreen (ClutterStageView            *view,
-                                                    const cairo_rectangle_int_t *src_rect,
-                                                    int                          dst_width,
-                                                    int                          dst_height,
-                                                    cairo_rectangle_int_t       *dst_rect);
-
-void clutter_stage_view_schedule_update (ClutterStageView *view);
-
-CLUTTER_EXPORT
-float clutter_stage_view_get_refresh_rate (ClutterStageView *view);
-
-void clutter_stage_view_notify_presented (ClutterStageView *view,
-                                          ClutterFrameInfo *frame_info);
+void clutter_stage_view_add_redraw_clip (ClutterStageView      *view,
+                                         cairo_rectangle_int_t *clip);

 #endif /* __CLUTTER_STAGE_VIEW_PRIVATE_H__ */
--- a/clutter/clutter/clutter-stage-view.c
+++ b/clutter/clutter/clutter-stage-view.c
--- a/clutter/clutter/clutter-stage-view.h
+++ b/clutter/clutter/clutter-stage-view.h
@@ -27,7 +27,6 @@
 #include <cogl/cogl.h>

 #include "clutter-macros.h"
-#include "clutter-frame-clock.h"

 #define CLUTTER_TYPE_STAGE_VIEW (clutter_stage_view_get_type ())
 CLUTTER_EXPORT
@@ -44,17 +43,8 @@ struct _ClutterStageViewClass

  void (* get_offscreen_transformation_matrix) (ClutterStageView *view,
                                                CoglMatrix       *matrix);
-
-  void (* transform_rect_to_onscreen) (ClutterStageView            *view,
-                                       const cairo_rectangle_int_t *src_rect,
-                                       int                          dst_width,
-                                       int                          dst_height,
-                                       cairo_rectangle_int_t       *dst_rect);
 };

-CLUTTER_EXPORT
-void clutter_stage_view_destroy (ClutterStageView *view);
-
 CLUTTER_EXPORT
 void clutter_stage_view_get_layout (ClutterStageView      *view,
                                    cairo_rectangle_int_t *rect);
@@ -66,6 +56,11 @@ CoglFramebuffer *clutter_stage_view_get_onscreen (ClutterStageView *view);
 CLUTTER_EXPORT
 void             clutter_stage_view_invalidate_offscreen_blit_pipeline (ClutterStageView *view);

+CLUTTER_EXPORT
+void             clutter_stage_view_transform_to_onscreen (ClutterStageView *view,
+                                                           gfloat           *x,
+                                                           gfloat           *y);
+
 CLUTTER_EXPORT
 float clutter_stage_view_get_scale (ClutterStageView *view);

@@ -73,7 +68,4 @@ CLUTTER_EXPORT
 void clutter_stage_view_get_offscreen_transformation_matrix (ClutterStageView *view,
                                                             CoglMatrix       *matrix);

-CLUTTER_EXPORT
-ClutterFrameClock * clutter_stage_view_get_frame_clock (ClutterStageView *view);
-
 #endif /* __CLUTTER_STAGE_VIEW_H__ */
--- a/clutter/clutter/clutter-stage-window.c
+++ b/clutter/clutter/clutter-stage-window.c
@@ -62,6 +62,16 @@ _clutter_stage_window_set_title (ClutterStageWindow *window,
    iface->set_title (window, title);
 }

+void
+_clutter_stage_window_set_cursor_visible (ClutterStageWindow *window,
+                                          gboolean            is_visible)
+{
+  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+
+  if (iface->set_cursor_visible)
+    iface->set_cursor_visible (window, is_visible);
+}
+
 gboolean
 _clutter_stage_window_realize (ClutterStageWindow *window)
 {
@@ -103,12 +113,165 @@ _clutter_stage_window_get_geometry (ClutterStageWindow    *window,
 }

 void
-_clutter_stage_window_redraw_view (ClutterStageWindow *window,
-                                   ClutterStageView   *view)
+_clutter_stage_window_schedule_update  (ClutterStageWindow *window,
+                                        int                 sync_delay)
 {
+  ClutterStageWindowInterface *iface;
+
  g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));

-  CLUTTER_STAGE_WINDOW_GET_IFACE (window)->redraw_view (window, view);
+  iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  if (iface->schedule_update == NULL)
+    {
+      g_assert (!clutter_feature_available (CLUTTER_FEATURE_SWAP_EVENTS));
+      return;
+    }
+
+  iface->schedule_update (window, sync_delay);
+}
+
+/**
+ * _clutter_stage_window_get_update_time:
+ * @window: a #ClutterStageWindow object
+ *
+ * See _clutter_stage_get_update_time() for more info.
+ *
+ * Returns: The timestamp of the update time
+ */
+gint64
+_clutter_stage_window_get_update_time (ClutterStageWindow *window)
+{
+  ClutterStageWindowInterface *iface;
+
+  g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), 0);
+
+  iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  if (iface->get_update_time == NULL)
+    {
+      g_assert (!clutter_feature_available (CLUTTER_FEATURE_SWAP_EVENTS));
+      return 0;
+    }
+
+  return iface->get_update_time (window);
+}
+
+/**
+ * _clutter_stage_window_clear_update_time:
+ * @window: a #ClutterStageWindow object
+ *
+ * Clears the update time. See _clutter_stage_clear_update_time() for more info.
+ */
+void
+_clutter_stage_window_clear_update_time (ClutterStageWindow *window)
+{
+  ClutterStageWindowInterface *iface;
+
+  g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));
+
+  iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  if (iface->clear_update_time == NULL)
+    {
+      g_assert (!clutter_feature_available (CLUTTER_FEATURE_SWAP_EVENTS));
+      return;
+    }
+
+  iface->clear_update_time (window);
+}
+
+void
+_clutter_stage_window_add_redraw_clip (ClutterStageWindow    *window,
+                                       cairo_rectangle_int_t *stage_clip)
+{
+  ClutterStageWindowInterface *iface;
+
+  g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));
+
+  iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  if (iface->add_redraw_clip != NULL)
+    iface->add_redraw_clip (window, stage_clip);
+}
+
+/* Determines if the backend will clip the rendering of the next
+ * frame.
+ *
+ * Note: at the start of each new frame there is an implied clip that
+ * clips everything (i.e. nothing would be drawn) so this function
+ * will return True at the start of a new frame if the backend
+ * supports clipped redraws.
+ */
+gboolean
+_clutter_stage_window_has_redraw_clips (ClutterStageWindow *window)
+{
+  ClutterStageWindowInterface *iface;
+
+  g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);
+
+  iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  if (iface->has_redraw_clips != NULL)
+    return iface->has_redraw_clips (window);
+
+  return FALSE;
+}
+
+/* Determines if the backend will discard any additional redraw clips
+ * and instead promote them to a full stage redraw.
+ *
+ * The ideas is that backend may have some heuristics that cause it to
+ * give up tracking redraw clips so this can be used to avoid the cost
+ * of calculating a redraw clip when we know it's going to be ignored
+ * anyway.
+ */
+gboolean
+_clutter_stage_window_ignoring_redraw_clips (ClutterStageWindow *window)
+{
+  ClutterStageWindowInterface *iface;
+
+  g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);
+
+  iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  if (iface->ignoring_redraw_clips != NULL)
+    return iface->ignoring_redraw_clips (window);
+
+  return TRUE;
+}
+
+cairo_region_t *
+_clutter_stage_window_get_redraw_clip (ClutterStageWindow *window)
+{
+  ClutterStageWindowInterface *iface;
+
+  g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);
+
+  iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  if (iface->get_redraw_clip != NULL)
+    return iface->get_redraw_clip (window);
+
+  return NULL;
+}
+
+void
+_clutter_stage_window_set_accept_focus (ClutterStageWindow *window,
+                                        gboolean            accept_focus)
+{
+  ClutterStageWindowInterface *iface;
+
+  g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));
+
+  iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  if (iface->set_accept_focus)
+    iface->set_accept_focus (window, accept_focus);
+}
+
+void
+_clutter_stage_window_redraw (ClutterStageWindow *window)
+{
+  ClutterStageWindowInterface *iface;
+
+  g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));
+
+  iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  if (iface->redraw)
+    iface->redraw (window);
 }

 gboolean
--- a/clutter/clutter/clutter-stage-window.h
+++ b/clutter/clutter/clutter-stage-window.h
@@ -30,6 +30,8 @@ struct _ClutterStageWindowInterface

  void              (* set_title)               (ClutterStageWindow *stage_window,
                                                 const gchar        *title);
+  void              (* set_cursor_visible)      (ClutterStageWindow *stage_window,
+                                                 gboolean            cursor_visible);

  gboolean          (* realize)                 (ClutterStageWindow *stage_window);
  void              (* unrealize)               (ClutterStageWindow *stage_window);
@@ -44,8 +46,21 @@ struct _ClutterStageWindowInterface
  void              (* get_geometry)            (ClutterStageWindow *stage_window,
                                                 cairo_rectangle_int_t *geometry);

-  void              (* redraw_view)             (ClutterStageWindow *stage_window,
-                                                 ClutterStageView   *view);
+  void              (* schedule_update)         (ClutterStageWindow *stage_window,
+                                                 int                 sync_delay);
+  gint64            (* get_update_time)         (ClutterStageWindow *stage_window);
+  void              (* clear_update_time)       (ClutterStageWindow *stage_window);
+
+  void              (* add_redraw_clip)         (ClutterStageWindow    *stage_window,
+                                                 cairo_rectangle_int_t *stage_rectangle);
+  gboolean          (* has_redraw_clips)        (ClutterStageWindow    *stage_window);
+  gboolean          (* ignoring_redraw_clips)   (ClutterStageWindow    *stage_window);
+  cairo_region_t *  (* get_redraw_clip)         (ClutterStageWindow    *stage_window);
+
+  void              (* set_accept_focus)        (ClutterStageWindow *stage_window,
+                                                 gboolean            accept_focus);
+
+  void              (* redraw)                  (ClutterStageWindow *stage_window);

  gboolean          (* can_clip_redraws)        (ClutterStageWindow *stage_window);

@@ -74,12 +89,21 @@ void              _clutter_stage_window_resize                  (ClutterStageWin
 CLUTTER_EXPORT
 void              _clutter_stage_window_get_geometry            (ClutterStageWindow *window,
                                                                 cairo_rectangle_int_t *geometry);
+void              _clutter_stage_window_schedule_update         (ClutterStageWindow *window,
+                                                                 int                 sync_delay);
+gint64            _clutter_stage_window_get_update_time         (ClutterStageWindow *window);
+void              _clutter_stage_window_clear_update_time       (ClutterStageWindow *window);
+
+void              _clutter_stage_window_add_redraw_clip         (ClutterStageWindow    *window,
+                                                                 cairo_rectangle_int_t *stage_clip);
+gboolean          _clutter_stage_window_has_redraw_clips        (ClutterStageWindow    *window);
+gboolean          _clutter_stage_window_ignoring_redraw_clips   (ClutterStageWindow    *window);
+cairo_region_t *  _clutter_stage_window_get_redraw_clip         (ClutterStageWindow    *window);

 void              _clutter_stage_window_set_accept_focus        (ClutterStageWindow *window,
                                                                 gboolean            accept_focus);

-void               _clutter_stage_window_redraw_view            (ClutterStageWindow *window,
-                                                                 ClutterStageView   *view);
+void              _clutter_stage_window_redraw                  (ClutterStageWindow *window);

 gboolean          _clutter_stage_window_can_clip_redraws        (ClutterStageWindow *window);

--- a/clutter/clutter/clutter-stage.c
+++ b/clutter/clutter/clutter-stage.c
--- a/Show More
+++ b/Show More