wayland/subsurface: Add check for parent surface

Just as we do in similar places. This avoids crashes under certain circumstances. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1411 (cherry picked from commit 8cbcd35fdf)
meson_options: Use libGLESv2.so.2 for COGL_DRIVER=gles2, not libGLESv2.so
2020-08-23 21:17:48 +00:00 · 2020-08-21 11:55:12 +00:00 · 2020-08-11 21:41:41 +02:00 · 2020-08-07 13:19:16 +02:00 · 2020-08-07 13:18:58 +02:00 · 2020-08-07 13:18:41 +02:00
525 changed files with 37482 additions and 19149 deletions
--- 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
@@ -36,8 +35,9 @@ build-without-opengl-and-glx:
    - ninja -C build
    - ninja -C build install
  artifacts:
+    expire_in: 1 day
    paths:
-      - build/meson-logs
+      - build
  only:
    - merge_requests
    - /^.*$/
@@ -49,8 +49,9 @@ build-without-native-backend-and-wayland:
    - ninja -C build
    - ninja -C build install
  artifacts:
+    expire_in: 1 day
    paths:
-      - build/meson-logs
+      - build
  only:
    - merge_requests
    - /^.*$/
@@ -65,6 +66,7 @@ test-mutter:
    G_SLICE: "always-malloc"
    MALLOC_CHECK_: "3"
    NO_AT_BRIDGE: "1"
+    MALLOC_PERTURB_: "123"
  script:
    - dconf update
    - mkdir -m 700 $XDG_RUNTIME_DIR
@@ -72,31 +74,10 @@ 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
-  script:
-    - meson . coverage-build -Dbuildtype=debugoptimized -Db_coverage=true -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
-    - ninja -C coverage-build coverage
-    - cat coverage-build/meson-logs/coverage.txt
-  artifacts:
-    paths:
-      - coverage-build/meson-logs
-  when: manual
-  except:
-    refs:
-      - tags
-      - master
-
 can-build-gnome-shell:
  stage: test
  dependencies:
--- a/.gitlab-ci/Dockerfile
+++ b/.gitlab-ci/Dockerfile
@@ -1,27 +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 \
-        --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/146
+++ b/146
@@ -1,90 +1,120 @@
-3.37.3
+3.36.5
+======
+* Screencast fixes and improvements [Jonas; !1351, !1365]
+* Fix glitches when subsurfaces extend outside the toplevel [Robert; #1316]
+* Mipmap background texture rendering [Daniel; !1347]
+* Fix wine copy & paste [Sebastian; !1369]
+* Plugged memory leaks [Marco, Thomas; !1195]
+
+Contributors:
+  Jonas Ådahl, Thomas Hindoe Paaboel Andersen, Sebastian Keller, Robert Mader,
+  Marco Trevisan (Treviño), Daniel van Vugt
+
+Translators:
+  Rafael Fontenelle [pt_BR]
+
+3.36.4
 ======
-* 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]
+* Turn off CRTCs as well when enabling DPMS [Michel; !1240]
+* Improve selection support
+  [Robert, Carlos, Sebastian; !1330, !1193, !1253, !1255, !1293, !1350]
 * 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]
+* Fix popovers disappearing on wayland and HiDPI [Robert; #1312]
+* Fixed crashes [Jonas Å.; !1317]
+* Plugged memory leaks [Jonas Å.; !1283]
+* Misc. bug fixes and cleanups
+  [Corentin, Sebastian, Jonas Å., Jonas D.; !1314, !1321, !1295, !1333]

 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
+  Sebastian Keller, Robert Mader, Corentin Noël, Daniel van Vugt, Jonas Ådahl

-3.37.2
+
+3.36.3
 ======
-* 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]
+* Broadcast clipboard/primary offers [Carlos; !1262]
 * 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]
+* Fix leaked DMA buffers in screencasts [Jonas; !1283]
+* Fixed crashes [Daniel, Carlos, Jonas D.; !1256, !1258, !1280]

 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
+  Carlos Garnacho, Daniel van Vugt, Jonas Ådahl

-3.37.1
+3.36.2
 ======
-* Fix screencasting non-maximized windows [Jonas Å.; !1174]
-* Make window-aliveness checks less aggressive [Jonas Å.; !1182]
+* Sync timelines to hardware vsync [Daniel; !724]
+* 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]
+* Fix tiled monitor support [Jonas Å.; !1199]
+* Fix various clipboard issues [Carlos; !1198, !1203, !1204, !1186, !1206]
 * 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]
+* Fix capturing with multiple stage views [Jonas Å.; !1222]
+* Fixed crashes [Jonas D., Carlos; !1173, !1183]
+* Misc. bug fixes and cleanups [Andre, Georges, Simon, Christian, Carlos, Marco,
+  Pekka, Laurent, Jonas D.; !1169, !1170, !1172, !1168, !1184, !1200, !1209,
+  #1074, !1208]

 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,
+  Marco Trevisan (Treviño), Laurent Bigonville, Jonas Dreßler, Olivier Fourdan,
+  Carlos Garnacho, Andre Moreira Magalhaes, Simon McVittie,
  Georges Basile Stavracas Neto, Pekka Paalanen, Christian Rauch, Jonas Troeger,
-  Phillip Wood, Jonas Ådahl
+  Daniel van Vugt, Phillip Wood, Jonas Ådahl

 Translators:
  Dušan Kazik [sk], Christian Kirbach [de]

+3.36.1
+======
+* Fix hardware cursor on GPU hotplpug [Pekka; !1097]
+* Fix black areas around XWayland windows when resizing [Robert, Olivier; !1091]
+* Fix applying wrong scale to monitors on X11 [Jonas; !1118]
+* Fix moving/resizing windows via keyboard on wayland [Alynx; !997]
+* Fix locate-pointer feature interfering with keybindings [Carlos; !1014]
+* Add support for middle-click emulation [Andrew; !256]
+* Fix freeze when moving cursor between scaled monitors [Robert; !1125]
+* Fix popup misplacement with focus-follows-mouse [Jonas Å.; !1122]
+* Fix misplaced cursor in preedit strings [Carlos; !1132]
+* Support mirroring with proprietary Nvidia driver [Jonas Å.; !1098]
+* Support tablets with multiple mode switch buttons in a group [Carlos; !970]
+* Ignore foreground color for color glyphs (emojis) [Carlos; !1148]
+* Allow pad mode switches while showing OSD [Carlos; !975]
+* Fix positioning of OSD for display-attached tablets [Carlos; !971]
+* Respect configured RANDR panning on X11 [Jonas Å.; !1085]
+* Use correct texture filtering with scaled displays [Jonas; !1124]
+* Fix cursor hotspots in virtual machines [Jonas Å.; !1136]
+* Fix build with GLES and no GL [Georges; !1151]
+* Work around Firefox bug when copying images on wayland [Robert; !1141]
+* Fix wrong cursor rotation on rotated displays [Hans; !1153]
+* Fix glitches in window screencasts [Georges; !1129]
+* Fix IM support for deleting surrounding text [Takao, Carlos; #539]
+* Fix map animation of maximized windows [Robert; !1164]
+* Fixed crashes [Jonas Å., Carlos, Florian, Robert; !1120, !1121,
+  #917, #1132, #1083, !1147, #1147]
+* Misc. bug fixes and cleanups [Jonas Å., Olivier, Mart, Sebastian, Corentin,
+  Andre, Daniel, Robert, Carlos, Peter, Georges, Jonas D., Florian, Christian;
+  !1115, !1102, !1104, !1106, !1117, !1119, !1101, !1123, #1124, !1130, !1131,
+  !1133, #1065, !1108, !1144, !1145, !1109, !1059, !1107, !999, !1152, #1128,
+  !1155, !1156, !1158, !1157, #1146, !1161, !1163]
+
+Contributors:
+  Jonas Dreßler, Olivier Fourdan, Takao Fujiwara, Carlos Garnacho, Andrew Gaul,
+  Hans de Goede, Peter Hutterer, Sebastian Keller, Robert Mader,
+  Andre Moreira Magalhaes, Florian Müllner, Georges Basile Stavracas Neto,
+  Corentin Noël, Pekka Paalanen, Christian Rauch, Mart Raudsepp,
+  Daniel van Vugt, Alynx Zhou, Jonas Ådahl
+
+Translators:
+  Марко Костић [sr], Daniel Șerbănescu [ro]
+
 3.36.0
 ======
 * Fix placement of popup windows in multi-monitor setups [Jonas; !1110]
--- 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);
@@ -924,15 +926,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);
-
-CLUTTER_EXPORT
-ClutterFrameClock * clutter_actor_pick_frame_clock (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;
@@ -136,12 +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);
-
 G_END_DECLS

 #endif /* __CLUTTER_BACKEND_PRIVATE_H__ */
--- a/clutter/clutter/clutter-backend.c
+++ b/clutter/clutter/clutter-backend.c
@@ -601,8 +601,6 @@ clutter_backend_init (ClutterBackend *self)
  self->units_serial = 1;

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

 void
@@ -1033,16 +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;
-}
--- 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,12 +341,17 @@ 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;

+  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (action)))
+    {
+      clutter_click_action_release (action);
+      return CLUTTER_EVENT_PROPAGATE;
+    }
+
  actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (action));

  switch (clutter_event_type (event))
@@ -441,8 +439,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 +473,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 +503,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 +532,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 +552,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 +689,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 +731,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 +757,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 +775,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 +795,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">
@@ -554,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
@@ -1317,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().
 *
@@ -1326,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;

 /**
--- 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.c
+++ b/clutter/clutter/clutter-input-device.c
@@ -692,6 +692,20 @@ _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
 _clutter_input_device_associate_actor (ClutterInputDevice   *device,
                                       ClutterEventSequence *sequence,
@@ -801,7 +815,7 @@ _clutter_input_device_set_actor (ClutterInputDevice   *device,
                                 ClutterActor         *actor,
                                 gboolean              emit_crossing)
 {
-  ClutterActor *old_actor = clutter_input_device_get_actor (device, sequence);
+  ClutterActor *old_actor = _clutter_input_device_get_actor (device, sequence);

  if (old_actor == actor)
    return;
@@ -836,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);
@@ -1040,7 +1054,7 @@ clutter_input_device_update (ClutterInputDevice   *device,

  clutter_input_device_get_coords (device, sequence, &point);

-  old_cursor_actor = clutter_input_device_get_actor (device, sequence);
+  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);

@@ -1071,33 +1085,22 @@ clutter_input_device_update (ClutterInputDevice   *device,
 }

 /**
- * 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)
 {
-  ClutterTouchInfo *info;
-
  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;
-
-  info = g_hash_table_lookup (device->touch_sequences_info, sequence);
-
-  g_return_val_if_fail (info != NULL, NULL);
-
-  return info->actor;
+  return device->cursor_actor;
 }

 /**
--- a/clutter/clutter/clutter-input-device.h
+++ b/clutter/clutter/clutter-input-device.h
@@ -92,8 +92,7 @@ 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
--- 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,6 +61,7 @@
 #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"
@@ -82,6 +83,10 @@

 /* 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;
@@ -140,6 +145,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"

@@ -508,7 +519,11 @@ clutter_main (void)
  main_loops = g_slist_prepend (main_loops, loop);

  if (g_main_loop_is_running (main_loops->data))
-    g_main_loop_run (loop);
+    {
+      _clutter_threads_release_lock ();
+      g_main_loop_run (loop);
+      _clutter_threads_acquire_lock ();
+    }

  main_loops = g_slist_remove (main_loops, loop);

@@ -525,9 +540,13 @@ _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;
 }

@@ -752,6 +771,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)
 {
@@ -761,8 +814,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))
    {
@@ -793,6 +846,20 @@ _clutter_context_get_default (void)
  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,
@@ -1982,8 +2049,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;
@@ -2018,8 +2084,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;
@@ -2089,6 +2154,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)
 {
@@ -2103,6 +2189,9 @@ clutter_base_init (void)
      g_type_init ();
 #endif

+      /* initialise the Big Clutter Lock™ if necessary */
+      clutter_threads_init_default ();
+
      clutter_graphene_init ();
    }
 }
@@ -2170,7 +2259,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)
    {
@@ -2193,6 +2284,8 @@ clutter_threads_remove_repaint_func (guint handle_id)

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

 /**
@@ -2291,13 +2384,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;
@@ -2305,6 +2401,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;
 }

--- a/clutter/clutter/clutter-master-clock-default.c
+++ b/clutter/clutter/clutter-master-clock-default.c
@@ -0,0 +1,642 @@
+/*
+ * 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 <cogl/cogl.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 int64_t
+master_clock_get_next_presentation_time (ClutterMasterClockDefault *master_clock)
+{
+  ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+  const GSList *stages, *l;
+  int64_t earliest = -1;
+
+  stages = clutter_stage_manager_peek_stages (stage_manager);
+
+  for (l = stages; l != NULL; l = l->next)
+    {
+      gint64 t = _clutter_stage_get_next_presentation_time (l->data);
+
+      if (earliest == -1 || (t != -1 && t < earliest))
+        earliest = t;
+    }
+
+  return earliest;
+}
+
+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 ();
+
+  COGL_TRACE_BEGIN (ClutterMasterClockTick, "Master Clock (tick)");
+
+  /* Get the time to use for this frame */
+  master_clock->cur_tick = master_clock_get_next_presentation_time (master_clock);
+
+  /* On the first frame the backend might not have an answer */
+  if (master_clock->cur_tick <= 0)
+    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);
+
+  COGL_TRACE_END (ClutterMasterClockTick);
+
+  _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
@@ -30,19 +30,13 @@
 #include "clutter-input-device-private.h"
 #include "clutter-input-pointer-a11y-private.h"
 #include "clutter-macros.h"
+#include "clutter-paint-context-private.h"
 #include "clutter-private.h"
 #include "clutter-stage-private.h"
 #include "clutter-stage-view.h"
 #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));

@@ -73,18 +67,17 @@ gboolean clutter_stage_paint_to_buffer (ClutterStage                 *stage,
                                        GError                      **error);

 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);
-
 #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;
@@ -140,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
@@ -154,7 +154,7 @@ 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);
 }

@@ -185,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);
    }

@@ -202,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;
@@ -212,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;
@@ -238,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];

@@ -254,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
@@ -374,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,
@@ -386,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),
@@ -411,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);
@@ -441,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);
@@ -496,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
@@ -517,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);
 }
@@ -533,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
@@ -599,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,6 +20,13 @@

 #include "clutter-paint-context.h"

+typedef enum _ClutterPaintFlag
+{
+  CLUTTER_PAINT_FLAG_NONE = 0,
+  CLUTTER_PAINT_FLAG_NO_CURSORS = 1 << 0,
+  CLUTTER_PAINT_FLAG_NO_PAINT_SIGNAL = 1 << 1,
+} ClutterPaintFlag;
+
 ClutterPaintContext * clutter_paint_context_new_for_view (ClutterStageView     *view,
                                                          const cairo_region_t *redraw_clip,
                                                          ClutterPaintFlag      paint_flags);
@@ -28,4 +35,7 @@ gboolean clutter_paint_context_is_drawing_off_stage (ClutterPaintContext *paint_

 CoglFramebuffer * clutter_paint_context_get_base_framebuffer (ClutterPaintContext *paint_context);

+CLUTTER_EXPORT
+ClutterPaintFlag clutter_paint_context_get_paint_flags (ClutterPaintContext *paint_context);
+
 #endif /* CLUTTER_PAINT_CONTEXT_PRIVATE_H */
--- a/clutter/clutter/clutter-paint-context.c
+++ b/clutter/clutter/clutter-paint-context.c
@@ -60,16 +60,14 @@ 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;
+  paint_context->paint_flags = (CLUTTER_PAINT_FLAG_NO_CURSORS |
+                                CLUTTER_PAINT_FLAG_NO_PAINT_SIGNAL);

  clutter_paint_context_push_framebuffer (paint_context, framebuffer);

--- a/clutter/clutter/clutter-paint-context.h
+++ b/clutter/clutter/clutter-paint-context.h
@@ -29,21 +29,13 @@

 typedef struct _ClutterPaintContext ClutterPaintContext;

-typedef enum _ClutterPaintFlag
-{
-  CLUTTER_PAINT_FLAG_NONE = 0,
-  CLUTTER_PAINT_FLAG_NO_CURSORS = 1 << 0,
-} 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);
@@ -70,7 +62,4 @@ 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);
--- 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,6 +124,9 @@ 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 */
  GQueue *events_queue;

@@ -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);
@@ -307,30 +318,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 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
@@ -354,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
@@ -381,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
@@ -645,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)
 {
--- a/clutter/clutter/clutter-seat.h
+++ b/clutter/clutter/clutter-seat.h
@@ -96,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);

@@ -133,7 +133,6 @@ 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);

--- a/clutter/clutter/clutter-stage-private.h
+++ b/clutter/clutter/clutter-stage-private.h
@@ -40,14 +40,7 @@ void                clutter_stage_paint_view             (ClutterStage
                                                          ClutterStageView      *view,
                                                          const cairo_region_t  *redraw_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,7 +74,11 @@ 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);
+int64_t  _clutter_stage_get_next_presentation_time        (ClutterStage *stage);

 void clutter_stage_log_pick (ClutterStage           *stage,
                             const graphene_point_t *vertices,
@@ -133,22 +132,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,30 +19,18 @@
 #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);

 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_projection (ClutterStageView *view,
-                                        const CoglMatrix *matrix);
+void clutter_stage_view_set_dirty_projection (ClutterStageView *view,
+                                              gboolean          dirty);

 void clutter_stage_view_add_redraw_clip (ClutterStageView            *view,
                                         const cairo_rectangle_int_t *clip);
@@ -55,20 +43,4 @@ const cairo_region_t * clutter_stage_view_peek_redraw_clip (ClutterStageView *vi

 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);
-
 #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,12 +43,6 @@ 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
@@ -63,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);

@@ -70,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,110 @@ _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);
+}
+
+int64_t
+_clutter_stage_window_get_next_presentation_time (ClutterStageWindow *window)
+{
+  ClutterStageWindowInterface *iface;
+
+  g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), 0);
+
+  iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+
+  /* If not implemented then just revert to the old behaviour... */
+  if (iface->get_next_presentation_time == NULL)
+    return _clutter_stage_window_get_update_time (window);
+
+  return iface->get_next_presentation_time (window);
+}
+
+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,14 +46,23 @@ 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              (* set_accept_focus)        (ClutterStageWindow *stage_window,
+                                                 gboolean            accept_focus);
+
+  void              (* redraw)                  (ClutterStageWindow *stage_window);

  gboolean          (* can_clip_redraws)        (ClutterStageWindow *stage_window);

  GList            *(* get_views)               (ClutterStageWindow *stage_window);
  int64_t           (* get_frame_counter)       (ClutterStageWindow *stage_window);
  void              (* finish_frame)            (ClutterStageWindow *stage_window);
+
+  int64_t           (* get_next_presentation_time) (ClutterStageWindow *stage_window);
 };

 ClutterActor *    _clutter_stage_window_get_wrapper        (ClutterStageWindow *window);
@@ -74,12 +85,15 @@ 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_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);

@@ -89,6 +103,8 @@ void              _clutter_stage_window_finish_frame            (ClutterStageWin

 int64_t           _clutter_stage_window_get_frame_counter       (ClutterStageWindow *window);

+int64_t           _clutter_stage_window_get_next_presentation_time (ClutterStageWindow *window);
+
 G_END_DECLS

 #endif /* __CLUTTER_STAGE_WINDOW_H__ */
--- a/clutter/clutter/clutter-stage.c
+++ b/clutter/clutter/clutter-stage.c
--- a/clutter/clutter/clutter-stage.h
+++ b/clutter/clutter/clutter-stage.h
@@ -28,8 +28,8 @@
 #error "Only <clutter/clutter.h> can be included directly."
 #endif

-#include <clutter/clutter-actor.h>
 #include <clutter/clutter-types.h>
+#include <clutter/clutter-group.h>
 #include <clutter/clutter-stage-view.h>

 G_BEGIN_DECLS
@@ -56,7 +56,7 @@ typedef struct _ClutterStagePrivate ClutterStagePrivate;
 struct _ClutterStage
 {
  /*< private >*/
-  ClutterActor parent_instance;
+  ClutterGroup parent_instance;

  ClutterStagePrivate *priv;
 };
@@ -74,7 +74,7 @@ struct _ClutterStage
 struct _ClutterStageClass
 {
  /*< private >*/
-  ClutterActorClass parent_class;
+  ClutterGroupClass parent_class;

  /*< public >*/
  /* signals */
@@ -103,7 +103,8 @@ struct _ClutterStageClass
 * @z_far: the distance from the viewer to the far clipping
 *   plane (always positive)
 *
- * Stage perspective definition.
+ * Stage perspective definition. #ClutterPerspective is only used by
+ * the fixed point version of clutter_stage_set_perspective().
 *
 * Since: 0.4
 */
@@ -139,10 +140,17 @@ GType clutter_stage_get_type (void) G_GNUC_CONST;
 CLUTTER_EXPORT
 ClutterActor *  clutter_stage_new                               (void);

+CLUTTER_EXPORT
+void            clutter_stage_set_perspective                   (ClutterStage          *stage,
+			                                         ClutterPerspective    *perspective);
 CLUTTER_EXPORT
 void            clutter_stage_get_perspective                   (ClutterStage          *stage,
 			                                         ClutterPerspective    *perspective);
 CLUTTER_EXPORT
+void            clutter_stage_show_cursor                       (ClutterStage          *stage);
+CLUTTER_EXPORT
+void            clutter_stage_hide_cursor                       (ClutterStage          *stage);
+CLUTTER_EXPORT
 void            clutter_stage_set_title                         (ClutterStage          *stage,
                                                                 const gchar           *title);
 CLUTTER_EXPORT
@@ -178,6 +186,11 @@ void            clutter_stage_set_motion_events_enabled         (ClutterStage
 CLUTTER_EXPORT
 gboolean        clutter_stage_get_motion_events_enabled         (ClutterStage          *stage);
 CLUTTER_EXPORT
+void            clutter_stage_set_accept_focus                  (ClutterStage          *stage,
+                                                                 gboolean               accept_focus);
+CLUTTER_EXPORT
+gboolean        clutter_stage_get_accept_focus                  (ClutterStage          *stage);
+CLUTTER_EXPORT
 gboolean        clutter_stage_event                             (ClutterStage          *stage,
                                                                 ClutterEvent          *event);

@@ -195,10 +208,11 @@ guchar *        clutter_stage_read_pixels                       (ClutterStage

 CLUTTER_EXPORT
 void            clutter_stage_ensure_viewport                   (ClutterStage          *stage);
+CLUTTER_EXPORT
+void            clutter_stage_ensure_redraw                     (ClutterStage          *stage);

 CLUTTER_EXPORT
-gboolean        clutter_stage_is_redraw_queued_on_view          (ClutterStage          *stage,
-                                                                 ClutterStageView      *view);
+gboolean        clutter_stage_is_redraw_queued                  (ClutterStage          *stage);

 #ifdef CLUTTER_ENABLE_EXPERIMENTAL_API
 CLUTTER_EXPORT
@@ -208,9 +222,6 @@ CLUTTER_EXPORT
 void            clutter_stage_skip_sync_delay                   (ClutterStage          *stage);
 #endif

-CLUTTER_EXPORT
-void clutter_stage_schedule_update (ClutterStage *stage);
-
 CLUTTER_EXPORT
 gboolean clutter_stage_get_capture_final_size (ClutterStage          *stage,
                                               cairo_rectangle_int_t *rect,
--- a/clutter/clutter/clutter-text.c
+++ b/clutter/clutter/clutter-text.c
@@ -187,6 +187,9 @@ struct _ClutterTextPrivate
  ClutterInputContentHintFlags input_hints;
  ClutterInputContentPurpose input_purpose;

+  /* Signal handler for when the :resource-scale changes */
+  gulong resource_scale_changed_id;
+
  /* bitfields */
  guint alignment               : 2;
  guint wrap                    : 1;
@@ -595,7 +598,9 @@ ensure_effective_pango_scale_attribute (ClutterText *self)
  float resource_scale;
  ClutterTextPrivate *priv = self->priv;

-  resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (self));
+  if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale) ||
+      resource_scale == 1.0)
+    return;

  if (priv->effective_attrs != NULL)
    {
@@ -917,6 +922,18 @@ clutter_text_direction_changed_cb (GObject    *gobject,
  /* no need to queue a relayout: set_text_direction() will do that for us */
 }

+static void
+clutter_text_resource_scale_changed_cb (GObject    *gobject,
+                                        GParamSpec *pspec)
+{
+  ClutterText *self = CLUTTER_TEXT (gobject);
+  ClutterTextPrivate *priv = self->priv;
+
+  g_clear_pointer (&priv->effective_attrs, pango_attr_list_unref);
+  clutter_text_dirty_cache (self);
+  clutter_actor_queue_relayout (CLUTTER_ACTOR (gobject));
+}
+
 /*
 * clutter_text_create_layout:
 * @text: a #ClutterText
@@ -1120,7 +1137,8 @@ maybe_create_text_layout_with_resource_scale (ClutterText *text,
 {
  float resource_scale;

-  resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (text));
+  if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (text), &resource_scale))
+    return NULL;

  return create_text_layout_with_scale (text,
                                        allocation_width,
@@ -1152,7 +1170,8 @@ clutter_text_coords_to_position (ClutterText *self,

  g_return_val_if_fail (CLUTTER_IS_TEXT (self), 0);

-  resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (self));
+  if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale))
+    return 0;

  /* Take any offset due to scrolling into account, and normalize
   * the coordinates to PangoScale units
@@ -1280,7 +1299,8 @@ clutter_text_position_to_coords (ClutterText *self,

  g_return_val_if_fail (CLUTTER_IS_TEXT (self), FALSE);

-  resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (self));
+  if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale))
+    return FALSE;

  ret = clutter_text_position_to_coords_internal (self, position,
                                                  x, y, line_height);
@@ -1756,6 +1776,7 @@ clutter_text_dispose (GObject *gobject)
  clutter_text_dirty_cache (self);

  g_clear_signal_handler (&priv->direction_changed_id, self);
+  g_clear_signal_handler (&priv->resource_scale_changed_id, self);
  g_clear_signal_handler (&priv->settings_changed_id,
                          clutter_get_default_backend ());

@@ -1886,6 +1907,14 @@ clutter_text_foreach_selection_rectangle (ClutterText              *self,
  g_free (utf8);
 }

+static void
+add_selection_rectangle_to_path (ClutterText           *text,
+                                 const ClutterActorBox *box,
+                                 gpointer               user_data)
+{
+  cogl_path_rectangle (user_data, box->x1, box->y1, box->x2, box->y2);
+}
+
 static void
 clutter_text_foreach_selection_rectangle_prescaled (ClutterText              *self,
                                                    ClutterTextSelectionFunc  func,
@@ -1894,60 +1923,6 @@ clutter_text_foreach_selection_rectangle_prescaled (ClutterText              *se
  clutter_text_foreach_selection_rectangle (self, 1.0f, func, user_data);
 }

-static void
-paint_selection_rectangle (ClutterText           *self,
-                           const ClutterActorBox *box,
-                           gpointer               user_data)
-{
-  CoglFramebuffer *fb = user_data;
-  ClutterTextPrivate *priv = self->priv;
-  ClutterActor *actor = CLUTTER_ACTOR (self);
-  guint8 paint_opacity = clutter_actor_get_paint_opacity (actor);
-  CoglPipeline *color_pipeline = cogl_pipeline_copy (default_color_pipeline);
-  PangoLayout *layout = clutter_text_get_layout (self);
-  CoglColor cogl_color = { 0, };
-  const ClutterColor *color;
-
-  /* Paint selection background */
-  if (priv->selection_color_set)
-    color = &priv->selection_color;
-  else if (priv->cursor_color_set)
-    color = &priv->cursor_color;
-  else
-    color = &priv->text_color;
-
-  cogl_color_init_from_4ub (&cogl_color,
-                            color->red,
-                            color->green,
-                            color->blue,
-                            paint_opacity * color->alpha / 255);
-  cogl_color_premultiply (&cogl_color);
-  cogl_pipeline_set_color (color_pipeline, &cogl_color);
-
-  cogl_framebuffer_push_rectangle_clip (fb,
-                                        box->x1, box->y1,
-                                        box->x2, box->y2);
-  cogl_framebuffer_draw_rectangle (fb, color_pipeline,
-                                   box->x1, box->y1,
-                                   box->x2, box->y2);
-
-  if (priv->selected_text_color_set)
-    color = &priv->selected_text_color;
-  else
-    color = &priv->text_color;
-
-  cogl_color_init_from_4ub (&cogl_color,
-                            color->red,
-                            color->green,
-                            color->blue,
-                            paint_opacity * color->alpha / 255);
-
-  cogl_pango_show_layout (fb, layout, priv->text_x, 0, &cogl_color);
-
-  cogl_framebuffer_pop_clip (fb);
-  cogl_object_unref (color_pipeline);
-}
-
 /* Draws the selected text, its background, and the cursor */
 static void
 selection_paint (ClutterText     *self,
@@ -1990,9 +1965,52 @@ selection_paint (ClutterText     *self,
    }
  else
    {
+      /* Paint selection background first */
+      CoglPipeline *color_pipeline = cogl_pipeline_copy (default_color_pipeline);
+      PangoLayout *layout = clutter_text_get_layout (self);
+      CoglPath *selection_path = cogl_path_new ();
+      CoglColor cogl_color = { 0, };
+
+      /* Paint selection background */
+      if (priv->selection_color_set)
+        color = &priv->selection_color;
+      else if (priv->cursor_color_set)
+        color = &priv->cursor_color;
+      else
+        color = &priv->text_color;
+
+      cogl_color_init_from_4ub (&cogl_color,
+                                color->red,
+                                color->green,
+                                color->blue,
+                                paint_opacity * color->alpha / 255);
+      cogl_color_premultiply (&cogl_color);
+      cogl_pipeline_set_color (color_pipeline, &cogl_color);
+
      clutter_text_foreach_selection_rectangle_prescaled (self,
-                                                          paint_selection_rectangle,
-                                                          fb);
+                                                          add_selection_rectangle_to_path,
+                                                          selection_path);
+
+      cogl_framebuffer_fill_path (fb, color_pipeline, selection_path);
+
+      /* Paint selected text */
+      cogl_framebuffer_push_path_clip (fb, selection_path);
+      cogl_object_unref (selection_path);
+
+      if (priv->selected_text_color_set)
+        color = &priv->selected_text_color;
+      else
+        color = &priv->text_color;
+
+      cogl_color_init_from_4ub (&cogl_color,
+                                color->red,
+                                color->green,
+                                color->blue,
+                                paint_opacity * color->alpha / 255);
+
+      cogl_pango_show_layout (fb, layout, priv->text_x, 0, &cogl_color);
+
+      cogl_framebuffer_pop_clip (fb);
    }
 }

@@ -2620,7 +2638,8 @@ clutter_text_paint (ClutterActor        *self,
      !clutter_text_should_draw_cursor (text))
    return;

-  resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (self));
+  if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale))
+    return;

  clutter_actor_box_scale (&alloc, resource_scale);
  clutter_actor_box_get_size (&alloc, &alloc_width, &alloc_height);
@@ -2852,7 +2871,8 @@ clutter_text_get_paint_volume (ClutterActor       *self,
      if (!clutter_actor_has_allocation (self))
        return FALSE;

-      resource_scale = clutter_actor_get_resource_scale (self);
+      if (!clutter_actor_get_resource_scale (self, &resource_scale))
+        return FALSE;

      _clutter_paint_volume_init_static (&priv->paint_volume, self);

@@ -2909,7 +2929,8 @@ clutter_text_get_preferred_width (ClutterActor *self,
  gfloat layout_width;
  gfloat resource_scale;

-  resource_scale = clutter_actor_get_resource_scale (self);
+  if (!clutter_actor_get_resource_scale (self, &resource_scale))
+    resource_scale = 1;

  layout = clutter_text_create_layout (text, -1, -1);
  pango_layout_get_extents (layout, NULL, &logical_rect);
@@ -2965,7 +2986,8 @@ clutter_text_get_preferred_height (ClutterActor *self,
      gfloat layout_height;
      gfloat resource_scale;

-      resource_scale = clutter_actor_get_resource_scale (self);
+      if (!clutter_actor_get_resource_scale (self, &resource_scale))
+        resource_scale = 1;

      if (priv->single_line_mode)
        for_width = -1;
@@ -3012,7 +3034,8 @@ clutter_text_get_preferred_height (ClutterActor *self,

 static void
 clutter_text_allocate (ClutterActor           *self,
-                       const ClutterActorBox  *box)
+                       const ClutterActorBox  *box,
+                       ClutterAllocationFlags  flags)
 {
  ClutterText *text = CLUTTER_TEXT (self);
  ClutterActorClass *parent_class;
@@ -3032,7 +3055,7 @@ clutter_text_allocate (ClutterActor           *self,
                                                  box->y2 - box->y1);

  parent_class = CLUTTER_ACTOR_CLASS (clutter_text_parent_class);
-  parent_class->allocate (self, box);
+  parent_class->allocate (self, box, flags);
 }

 static gboolean
@@ -3041,33 +3064,6 @@ clutter_text_has_overlaps (ClutterActor *self)
  return clutter_text_should_draw_cursor ((ClutterText *) self);
 }

-static float
-clutter_text_calculate_resource_scale (ClutterActor *actor,
-                                       int           phase)
-{
-  ClutterActorClass *parent_class = CLUTTER_ACTOR_CLASS (clutter_text_parent_class);
-  float new_resource_scale;
-
-  new_resource_scale = parent_class->calculate_resource_scale (actor, phase);
-
-  if (phase == 1)
-    return MAX (new_resource_scale, clutter_actor_get_real_resource_scale (actor));
-
-  return new_resource_scale;
-}
-
-static void
-clutter_text_resource_scale_changed (ClutterActor *actor)
-{
-  ClutterText *text = CLUTTER_TEXT (actor);
-  ClutterTextPrivate *priv = text->priv;
-
-  g_clear_pointer (&priv->effective_attrs, pango_attr_list_unref);
-  clutter_text_dirty_cache (text);
-
-  clutter_actor_queue_immediate_relayout (actor);
-}
-
 static void
 clutter_text_im_focus (ClutterText *text)
 {
@@ -3816,8 +3812,6 @@ clutter_text_class_init (ClutterTextClass *klass)
  actor_class->key_focus_in = clutter_text_key_focus_in;
  actor_class->key_focus_out = clutter_text_key_focus_out;
  actor_class->has_overlaps = clutter_text_has_overlaps;
-  actor_class->calculate_resource_scale = clutter_text_calculate_resource_scale;
-  actor_class->resource_scale_changed = clutter_text_resource_scale_changed;

  /**
   * ClutterText:buffer:
@@ -4625,6 +4619,11 @@ clutter_text_init (ClutterText *self)
                      NULL);

  priv->input_focus = clutter_text_input_focus_new (self);
+
+  priv->resource_scale_changed_id =
+    g_signal_connect (self, "notify::resource-scale",
+                      G_CALLBACK (clutter_text_resource_scale_changed_cb),
+                      NULL);
 }

 /**
@@ -4785,11 +4784,11 @@ clutter_text_queue_redraw_or_relayout (ClutterText *self)
  clutter_text_get_preferred_height (actor, preferred_width, NULL, &preferred_height);

  if (clutter_actor_has_allocation (actor) &&
-      fabsf (preferred_width - clutter_actor_get_width (actor)) <= 0.001 &&
-      fabsf (preferred_height - clutter_actor_get_height (actor)) <= 0.001)
-    clutter_text_queue_redraw (actor);
-  else
+      (fabsf (preferred_width - clutter_actor_get_width (actor)) > 0.001 ||
+       fabsf (preferred_height - clutter_actor_get_height (actor)) > 0.001))
    clutter_actor_queue_relayout (actor);
+  else
+    clutter_text_queue_redraw (actor);
 }

 static void
--- a/clutter/clutter/clutter-timeline-private.h
+++ b/clutter/clutter/clutter-timeline-private.h
@@ -1,33 +0,0 @@
-/*
- * 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_TIMELINE_PRIVATE_H
-#define CLUTTER_TIMELINE_PRIVATE_H
-
-void                    _clutter_timeline_advance                       (ClutterTimeline    *timeline,
-                                                                         int64_t             tick_time);
-int64_t                 _clutter_timeline_get_delta                     (ClutterTimeline    *timeline);
-void                    _clutter_timeline_do_tick                       (ClutterTimeline    *timeline,
-                                                                         int64_t             tick_time);
-
-#endif /* CLUTTER_TIMELINE_PRIVATE_H */
--- a/clutter/clutter/clutter-timeline.c
+++ b/clutter/clutter/clutter-timeline.c
@@ -24,6 +24,7 @@
 /**
 * SECTION:clutter-timeline
 * @short_description: A class for time-based events
+ * @see_also: #ClutterAnimation, #ClutterAnimator, #ClutterState
 *
 * #ClutterTimeline is a base class for managing time-based event that cause
 * Clutter to redraw a stage, such as animations.
@@ -70,7 +71,7 @@
 * when reaching completion by using the #ClutterTimeline:auto-reverse property.
 *
 * Timelines are used in the Clutter animation framework by classes like
- * #ClutterTransition.
+ * #ClutterAnimation, #ClutterAnimator, and #ClutterState.
 *
 * ## Defining Timelines in ClutterScript
 *
@@ -95,31 +96,22 @@
 #include "clutter-build-config.h"

 #include "clutter-timeline.h"
-#include "deprecated/clutter-timeline.h"

 #include "clutter-debug.h"
 #include "clutter-easing.h"
 #include "clutter-enum-types.h"
-#include "clutter-frame-clock.h"
 #include "clutter-main.h"
 #include "clutter-marshal.h"
+#include "clutter-master-clock.h"
 #include "clutter-private.h"
 #include "clutter-scriptable.h"
-#include "clutter-timeline-private.h"
+
+#include "deprecated/clutter-timeline.h"

 struct _ClutterTimelinePrivate
 {
  ClutterTimelineDirection direction;

-  ClutterFrameClock *custom_frame_clock;
-  ClutterFrameClock *frame_clock;
-
-  ClutterActor *actor;
-  gulong actor_destroy_handler_id;
-  gulong actor_stage_views_handler_id;
-  gulong stage_stage_views_handler_id;
-  ClutterActor *stage;
-
  guint delay_id;

  /* The total length in milliseconds of this timeline */
@@ -181,14 +173,13 @@ enum
 {
  PROP_0,

-  PROP_ACTOR,
+  PROP_LOOP,
  PROP_DELAY,
  PROP_DURATION,
  PROP_DIRECTION,
  PROP_AUTO_REVERSE,
  PROP_REPEAT_COUNT,
  PROP_PROGRESS_MODE,
-  PROP_FRAME_CLOCK,

  PROP_LAST
 };
@@ -209,8 +200,6 @@ enum

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

-static void update_frame_clock (ClutterTimeline *timeline);
-
 static void clutter_scriptable_iface_init (ClutterScriptableIface *iface);

 G_DEFINE_TYPE_WITH_CODE (ClutterTimeline, clutter_timeline, G_TYPE_OBJECT,
@@ -302,175 +291,21 @@ clutter_timeline_add_marker_internal (ClutterTimeline *timeline,
  g_hash_table_insert (priv->markers_by_name, marker->name, marker);
 }

-static void
-on_actor_destroyed (ClutterActor    *actor,
-                    ClutterTimeline *timeline)
+static inline void
+clutter_timeline_set_loop_internal (ClutterTimeline *timeline,
+                                    gboolean         loop)
 {
-  ClutterTimelinePrivate *priv = timeline->priv;
+  gint old_repeat_count;

-  priv->actor = NULL;
-}
+  old_repeat_count = timeline->priv->repeat_count;

-/**
- * clutter_timeline_get_actor:
- * @timeline: a #ClutterTimeline
- *
- * Get the actor the timeline is associated with.
- *
- * Returns: (transfer none): the associated #ClutterActor
- */
-ClutterActor *
-clutter_timeline_get_actor (ClutterTimeline *timeline)
-{
-  ClutterTimelinePrivate *priv = timeline->priv;
+  if (loop)
+    clutter_timeline_set_repeat_count (timeline, -1);
+  else
+    clutter_timeline_set_repeat_count (timeline, 0);

-  return priv->actor;
-}
-
-static void
-maybe_add_timeline (ClutterTimeline *timeline)
-{
-  ClutterTimelinePrivate *priv = timeline->priv;
-
-  if (!priv->frame_clock)
-    return;
-
-  clutter_frame_clock_add_timeline (priv->frame_clock, timeline);
-}
-
-static void
-maybe_remove_timeline (ClutterTimeline *timeline)
-{
-  ClutterTimelinePrivate *priv = timeline->priv;
-
-  if (!priv->frame_clock)
-    return;
-
-  clutter_frame_clock_remove_timeline (priv->frame_clock, timeline);
-}
-
-static void
-set_frame_clock_internal (ClutterTimeline   *timeline,
-                          ClutterFrameClock *frame_clock)
-{
-  ClutterTimelinePrivate *priv = timeline->priv;
-
-  if (priv->frame_clock == frame_clock)
-    return;
-
-  if (priv->frame_clock && priv->is_playing)
-    maybe_remove_timeline (timeline);
-
-  g_set_object (&priv->frame_clock, frame_clock);
-
-  g_object_notify_by_pspec (G_OBJECT (timeline),
-                            obj_props[PROP_FRAME_CLOCK]);
-
-  if (priv->is_playing)
-    maybe_add_timeline (timeline);
-}
-
-static void
-on_stage_stage_views_changed (ClutterActor    *stage,
-                              ClutterTimeline *timeline)
-{
-  ClutterTimelinePrivate *priv = timeline->priv;
-
-  g_clear_signal_handler (&priv->stage_stage_views_handler_id, priv->stage);
-  priv->stage = NULL;
-
-  update_frame_clock (timeline);
-}
-
-static void
-update_frame_clock (ClutterTimeline *timeline)
-{
-  ClutterTimelinePrivate *priv = timeline->priv;
-  ClutterFrameClock *frame_clock = NULL;
-  ClutterActor *stage;
-
-  if (!priv->actor)
-    goto out;
-
-  frame_clock = clutter_actor_pick_frame_clock (priv->actor);
-  if (frame_clock)
-    {
-      g_clear_signal_handler (&priv->stage_stage_views_handler_id, priv->stage);
-      goto out;
-    }
-
-  stage = clutter_actor_get_stage (priv->actor);
-  if (!stage)
-    {
-      if (priv->is_playing)
-        g_warning ("Timelines with detached actors are not supported");
-      goto out;
-    }
-
-  if (priv->stage_stage_views_handler_id > 0)
-    goto out;
-
-  priv->stage_stage_views_handler_id =
-    g_signal_connect (stage, "stage-views-changed",
-                      G_CALLBACK (on_stage_stage_views_changed),
-                      timeline);
-  priv->stage = stage;
-
-out:
-  set_frame_clock_internal (timeline, frame_clock);
-}
-
-static void
-on_actor_stage_views_changed (ClutterActor    *actor,
-                              ClutterTimeline *timeline)
-{
-  update_frame_clock (timeline);
-}
-
-/**
- * clutter_timeline_set_actor:
- * @timeline: a #ClutterTimeline
- * @actor: (nullable): a #ClutterActor
- *
- * Set the actor the timeline is associated with.
- */
-void
-clutter_timeline_set_actor (ClutterTimeline *timeline,
-                            ClutterActor    *actor)
-{
-  ClutterTimelinePrivate *priv = timeline->priv;
-
-  g_return_if_fail (!actor || (actor && !priv->custom_frame_clock));
-
-  if (priv->actor)
-    {
-      g_clear_signal_handler (&priv->actor_destroy_handler_id, priv->actor);
-      g_clear_signal_handler (&priv->actor_stage_views_handler_id, priv->actor);
-      g_clear_signal_handler (&priv->stage_stage_views_handler_id, priv->stage);
-      priv->stage = NULL;
-      priv->actor = NULL;
-
-      if (priv->is_playing)
-        maybe_remove_timeline (timeline);
-
-      priv->frame_clock = NULL;
-    }
-
-  priv->actor = actor;
-
-  if (priv->actor)
-    {
-      priv->actor_destroy_handler_id =
-        g_signal_connect (priv->actor, "destroy",
-                          G_CALLBACK (on_actor_destroyed),
-                          timeline);
-      priv->actor_stage_views_handler_id =
-        g_signal_connect (priv->actor, "stage-views-changed",
-                          G_CALLBACK (on_actor_stage_views_changed),
-                          timeline);
-    }
-
-  update_frame_clock (timeline);
+  if (old_repeat_count != timeline->priv->repeat_count)
+    g_object_notify_by_pspec (G_OBJECT (timeline), obj_props[PROP_LOOP]);
 }

 /* Scriptable */
@@ -614,8 +449,8 @@ clutter_timeline_set_property (GObject      *object,

  switch (prop_id)
    {
-    case PROP_ACTOR:
-      clutter_timeline_set_actor (timeline, g_value_get_object (value));
+    case PROP_LOOP:
+      clutter_timeline_set_loop_internal (timeline, g_value_get_boolean (value));
      break;

    case PROP_DELAY:
@@ -642,10 +477,6 @@ clutter_timeline_set_property (GObject      *object,
      clutter_timeline_set_progress_mode (timeline, g_value_get_enum (value));
      break;

-    case PROP_FRAME_CLOCK:
-      clutter_timeline_set_frame_clock (timeline, g_value_get_object (value));
-      break;
-
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
@@ -663,8 +494,8 @@ clutter_timeline_get_property (GObject    *object,

  switch (prop_id)
    {
-    case PROP_ACTOR:
-      g_value_set_object (value, priv->actor);
+    case PROP_LOOP:
+      g_value_set_boolean (value, priv->repeat_count != 0);
      break;

    case PROP_DELAY:
@@ -691,10 +522,6 @@ clutter_timeline_get_property (GObject    *object,
      g_value_set_enum (value, priv->progress_mode);
      break;

-    case PROP_FRAME_CLOCK:
-      g_value_set_object (value, priv->frame_clock);
-      break;
-
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
@@ -706,14 +533,16 @@ clutter_timeline_finalize (GObject *object)
 {
  ClutterTimeline *self = CLUTTER_TIMELINE (object);
  ClutterTimelinePrivate *priv = self->priv;
+  ClutterMasterClock *master_clock;

  if (priv->markers_by_name)
    g_hash_table_destroy (priv->markers_by_name);

  if (priv->is_playing)
-    maybe_remove_timeline (self);
-
-  g_clear_object (&priv->frame_clock);
+    {
+      master_clock = _clutter_master_clock_get_default ();
+      _clutter_master_clock_remove_timeline (master_clock, self);
+    }

  G_OBJECT_CLASS (clutter_timeline_parent_class)->finalize (object);
 }
@@ -728,14 +557,6 @@ clutter_timeline_dispose (GObject *object)

  clutter_timeline_cancel_delay (self);

-  if (priv->actor)
-    {
-      g_clear_signal_handler (&priv->actor_destroy_handler_id, priv->actor);
-      g_clear_signal_handler (&priv->actor_stage_views_handler_id, priv->actor);
-      g_clear_signal_handler (&priv->stage_stage_views_handler_id, priv->stage);
-      priv->actor = NULL;
-    }
-
  if (priv->progress_notify != NULL)
    {
      priv->progress_notify (priv->progress_data);
@@ -753,17 +574,24 @@ clutter_timeline_class_init (ClutterTimelineClass *klass)
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  /**
-   * ClutterTimeline::actor:
+   * ClutterTimeline:loop:
   *
-   * The actor the timeline is associated with. This will determine what frame
-   * clock will drive it.
+   * Whether the timeline should automatically rewind and restart.
+   *
+   * As a side effect, setting this property to %TRUE will set the
+   * #ClutterTimeline:repeat-count property to -1, while setting this
+   * property to %FALSE will set the #ClutterTimeline:repeat-count
+   * property to 0.
+   *
+   * Deprecated: 1.10: Use the #ClutterTimeline:repeat-count property instead.
   */
-  obj_props[PROP_ACTOR] =
-    g_param_spec_object ("actor",
-                         P_("Actor"),
-                         P_("Associated ClutterActor"),
-                         CLUTTER_TYPE_ACTOR,
-                         G_PARAM_CONSTRUCT | CLUTTER_PARAM_READWRITE);
+  obj_props[PROP_LOOP] =
+    g_param_spec_boolean ("loop",
+                          P_("Loop"),
+                          P_("Should the timeline automatically restart"),
+                          FALSE,
+                          CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
+
  /**
   * ClutterTimeline:delay:
   *
@@ -862,18 +690,6 @@ clutter_timeline_class_init (ClutterTimelineClass *klass)
                       CLUTTER_LINEAR,
                       CLUTTER_PARAM_READWRITE);

-  /**
-   * ClutterTimeline:frame-clock:
-   *
-   * The frame clock driving the timeline.
-   */
-  obj_props[PROP_FRAME_CLOCK] =
-    g_param_spec_object ("frame-clock",
-                         "Frame clock",
-                         "Frame clock driving the timeline",
-                         CLUTTER_TYPE_FRAME_CLOCK,
-                         G_PARAM_CONSTRUCT | CLUTTER_PARAM_READWRITE);
-
  object_class->dispose = clutter_timeline_dispose;
  object_class->finalize = clutter_timeline_finalize;
  object_class->set_property = clutter_timeline_set_property;
@@ -1156,6 +972,7 @@ set_is_playing (ClutterTimeline *timeline,
                gboolean         is_playing)
 {
  ClutterTimelinePrivate *priv = timeline->priv;
+  ClutterMasterClock *master_clock;

  is_playing = !!is_playing;

@@ -1164,17 +981,15 @@ set_is_playing (ClutterTimeline *timeline,

  priv->is_playing = is_playing;

+  master_clock = _clutter_master_clock_get_default ();
  if (priv->is_playing)
    {
      priv->waiting_first_tick = TRUE;
      priv->current_repeat = 0;
-
-      maybe_add_timeline (timeline);
+      _clutter_master_clock_add_timeline (master_clock, timeline);
    }
  else
-    {
-      maybe_remove_timeline (timeline);
-    }
+    _clutter_master_clock_remove_timeline (master_clock, timeline);
 }

 static gboolean
@@ -1371,9 +1186,6 @@ clutter_timeline_start (ClutterTimeline *timeline)
  if (priv->duration == 0)
    return;

-  g_warn_if_fail ((priv->actor && clutter_actor_get_stage (priv->actor)) ||
-                  priv->frame_clock);
-
  if (priv->delay)
    priv->delay_id = clutter_threads_add_timeout (priv->delay,
                                                  delay_timeout_func,
@@ -1440,6 +1252,45 @@ clutter_timeline_stop (ClutterTimeline *timeline)
    g_signal_emit (timeline, timeline_signals[STOPPED], 0, FALSE);
 }

+/**
+ * clutter_timeline_set_loop:
+ * @timeline: a #ClutterTimeline
+ * @loop: %TRUE for enable looping
+ *
+ * Sets whether @timeline should loop.
+ *
+ * This function is equivalent to calling clutter_timeline_set_repeat_count()
+ * with -1 if @loop is %TRUE, and with 0 if @loop is %FALSE.
+ *
+ * Deprecated: 1.10: Use clutter_timeline_set_repeat_count() instead.
+ */
+void
+clutter_timeline_set_loop (ClutterTimeline *timeline,
+			   gboolean         loop)
+{
+  g_return_if_fail (CLUTTER_IS_TIMELINE (timeline));
+
+  clutter_timeline_set_loop_internal (timeline, loop);
+}
+
+/**
+ * clutter_timeline_get_loop:
+ * @timeline: a #ClutterTimeline
+ *
+ * Gets whether @timeline is looping
+ *
+ * Return value: %TRUE if the timeline is looping
+ *
+ * Deprecated: 1.10: Use clutter_timeline_get_repeat_count() instead.
+ */
+gboolean
+clutter_timeline_get_loop (ClutterTimeline *timeline)
+{
+  g_return_val_if_fail (CLUTTER_IS_TIMELINE (timeline), FALSE);
+
+  return timeline->priv->repeat_count != 0;
+}
+
 /**
 * clutter_timeline_rewind:
 * @timeline: A #ClutterTimeline
@@ -1556,10 +1407,48 @@ clutter_timeline_is_playing (ClutterTimeline *timeline)
 }

 /**
- * clutter_timeline_new:
- * @duration_ms: Duration of the timeline in milliseconds
+ * clutter_timeline_clone:
+ * @timeline: #ClutterTimeline to duplicate.
 *
- * Creates a new #ClutterTimeline with a duration of @duration_ms milli seconds.
+ * Create a new #ClutterTimeline instance which has property values
+ * matching that of supplied timeline. The cloned timeline will not
+ * be started and will not be positioned to the current position of
+ * the original @timeline: you will have to start it with
+ * clutter_timeline_start().
+ *
+ * The only cloned properties are:
+ *
+ *  - #ClutterTimeline:duration
+ *  - #ClutterTimeline:loop
+ *  - #ClutterTimeline:delay
+ *  - #ClutterTimeline:direction
+ *
+ * Return value: (transfer full): a new #ClutterTimeline, cloned
+ *   from @timeline
+ *
+ * Since: 0.4
+ *
+ * Deprecated: 1.10: Use clutter_timeline_new() or g_object_new()
+ *   instead
+ */
+ClutterTimeline *
+clutter_timeline_clone (ClutterTimeline *timeline)
+{
+  g_return_val_if_fail (CLUTTER_IS_TIMELINE (timeline), NULL);
+
+  return g_object_new (CLUTTER_TYPE_TIMELINE,
+                       "duration", timeline->priv->duration,
+                       "loop", timeline->priv->repeat_count != 0,
+                       "delay", timeline->priv->delay,
+                       "direction", timeline->priv->direction,
+                       NULL);
+}
+
+/**
+ * clutter_timeline_new:
+ * @msecs: Duration of the timeline in milliseconds
+ *
+ * Creates a new #ClutterTimeline with a duration of @msecs.
 *
 * Return value: the newly created #ClutterTimeline instance. Use
 *   g_object_unref() when done using it
@@ -1567,50 +1456,10 @@ clutter_timeline_is_playing (ClutterTimeline *timeline)
 * Since: 0.6
 */
 ClutterTimeline *
-clutter_timeline_new (guint duration_ms)
+clutter_timeline_new (guint msecs)
 {
  return g_object_new (CLUTTER_TYPE_TIMELINE,
-                       "duration", duration_ms,
-                       NULL);
-}
-
-/**
- * clutter_timeline_new_for_actor:
- * @actor: The #ClutterActor the timeline is associated with
- * @duration_ms: Duration of the timeline in milliseconds
- *
- * Creates a new #ClutterTimeline with a duration of @duration milli seconds.
- *
- * Return value: the newly created #ClutterTimeline instance. Use
- *   g_object_unref() when done using it
- */
-ClutterTimeline *
-clutter_timeline_new_for_actor (ClutterActor *actor,
-                                unsigned int  duration_ms)
-{
-  return g_object_new (CLUTTER_TYPE_TIMELINE,
-                       "duration", duration_ms,
-                       "actor", actor,
-                       NULL);
-}
-
-/**
- * clutter_timeline_new_for_frame_clock:
- * @frame_clock: The #ClutterFrameClock the timeline is driven by
- * @duration_ms: Duration of the timeline in milliseconds
- *
- * Creates a new #ClutterTimeline with a duration of @duration_ms milli seconds.
- *
- * Return value: the newly created #ClutterTimeline instance. Use
- *   g_object_unref() when done using it
- */
-ClutterTimeline *
-clutter_timeline_new_for_frame_clock (ClutterFrameClock *frame_clock,
-                                      unsigned int       duration_ms)
-{
-  return g_object_new (CLUTTER_TYPE_TIMELINE,
-                       "duration", duration_ms,
-                       "frame-clock", frame_clock,
+                       "duration", msecs,
                       NULL);
 }

@@ -1876,7 +1725,7 @@ _clutter_timeline_do_tick (ClutterTimeline *timeline,

  /* Check the is_playing variable before performing the timeline tick.
   * This is necessary, as if a timeline is stopped in response to a
-   * frame clock generated signal of a different timeline, this code can
+   * master-clock generated signal of a different timeline, this code can
   * still be reached.
   */
  if (!priv->is_playing)
@@ -2694,32 +2543,3 @@ clutter_timeline_get_cubic_bezier_progress (ClutterTimeline  *timeline,

  return TRUE;
 }
-
-/**
- * clutter_timeline_get_frame_clock: (skip)
- */
-ClutterFrameClock *
-clutter_timeline_get_frame_clock (ClutterTimeline *timeline)
-{
-  g_return_val_if_fail (CLUTTER_IS_TIMELINE (timeline), NULL);
-
-  return timeline->priv->frame_clock;
-}
-
-void
-clutter_timeline_set_frame_clock (ClutterTimeline   *timeline,
-                                  ClutterFrameClock *frame_clock)
-{
-  ClutterTimelinePrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_TIMELINE (timeline));
-
-  priv = timeline->priv;
-
-  g_assert (!frame_clock || (frame_clock && !priv->actor));
-  g_return_if_fail (!frame_clock || (frame_clock && !priv->actor));
-
-  priv->custom_frame_clock = frame_clock;
-  if (!priv->actor)
-    set_frame_clock_internal (timeline, frame_clock);
-}
--- a/clutter/clutter/clutter-timeline.h
+++ b/clutter/clutter/clutter-timeline.h
@@ -119,19 +119,7 @@ CLUTTER_EXPORT
 GType clutter_timeline_get_type (void) G_GNUC_CONST;

 CLUTTER_EXPORT
-ClutterTimeline *               clutter_timeline_new_for_actor                  (ClutterActor             *actor,
-                                                                                 unsigned int              duration_ms);
-
-CLUTTER_EXPORT
-ClutterTimeline *               clutter_timeline_new_for_frame_clock            (ClutterFrameClock        *frame_clock,
-                                                                                 unsigned int              duration_ms);
-
-CLUTTER_EXPORT
-ClutterActor *                  clutter_timeline_get_actor                      (ClutterTimeline          *timeline);
-
-CLUTTER_EXPORT
-void                            clutter_timeline_set_actor                      (ClutterTimeline          *timeline,
-                                                                                 ClutterActor             *actor);
+ClutterTimeline *               clutter_timeline_new                            (guint                     msecs);

 CLUTTER_EXPORT
 guint                           clutter_timeline_get_duration                   (ClutterTimeline          *timeline);
@@ -233,13 +221,6 @@ gint64                          clutter_timeline_get_duration_hint
 CLUTTER_EXPORT
 gint                            clutter_timeline_get_current_repeat             (ClutterTimeline          *timeline);

-CLUTTER_EXPORT
-ClutterFrameClock *             clutter_timeline_get_frame_clock                (ClutterTimeline           *timeline);
-
-CLUTTER_EXPORT
-void                            clutter_timeline_set_frame_clock                (ClutterTimeline           *timeline,
-                                                                                 ClutterFrameClock         *frame_clock);
-
 G_END_DECLS

 #endif /* _CLUTTER_TIMELINE_H__ */
--- a/clutter/clutter/clutter-transition-group.c
+++ b/clutter/clutter/clutter-transition-group.c
@@ -43,7 +43,6 @@

 #include "clutter-debug.h"
 #include "clutter-private.h"
-#include "clutter-timeline-private.h"

 struct _ClutterTransitionGroupPrivate
 {
--- a/clutter/clutter/clutter-transition.c
+++ b/clutter/clutter/clutter-transition.c
@@ -364,7 +364,6 @@ clutter_transition_set_animatable (ClutterTransition *transition,
                                   ClutterAnimatable *animatable)
 {
  ClutterTransitionPrivate *priv;
-  ClutterActor *actor;

  g_return_if_fail (CLUTTER_IS_TRANSITION (transition));
  g_return_if_fail (animatable == NULL || CLUTTER_IS_ANIMATABLE (animatable));
@@ -384,9 +383,6 @@ clutter_transition_set_animatable (ClutterTransition *transition,
      priv->animatable = g_object_ref (animatable);
      clutter_transition_attach (transition, priv->animatable);
    }
-
-  actor = clutter_animatable_get_actor (animatable);
-  clutter_timeline_set_actor (CLUTTER_TIMELINE (transition), actor);
 }

 /**
--- a/clutter/clutter/clutter-types.h
+++ b/clutter/clutter/clutter-types.h
@@ -57,7 +57,6 @@ typedef struct _ClutterActorIter                ClutterActorIter;
 typedef struct _ClutterPaintNode                ClutterPaintNode;
 typedef struct _ClutterContent                  ClutterContent; /* dummy */
 typedef struct _ClutterScrollActor	        ClutterScrollActor;
-typedef struct _ClutterFrameClock               ClutterFrameClock;

 typedef struct _ClutterInterval         	ClutterInterval;
 typedef struct _ClutterAnimatable       	ClutterAnimatable; /* dummy */
@@ -80,6 +79,10 @@ typedef struct _ClutterKnot                     ClutterKnot;
 typedef struct _ClutterMargin                   ClutterMargin;
 typedef struct _ClutterPerspective              ClutterPerspective;

+typedef struct _ClutterAlpha            	ClutterAlpha;
+typedef struct _ClutterAnimation                ClutterAnimation;
+typedef struct _ClutterState            	ClutterState;
+
 typedef struct _ClutterInputDeviceTool          ClutterInputDeviceTool;
 typedef struct _ClutterInputDevice              ClutterInputDevice;
 typedef struct _ClutterVirtualInputDevice       ClutterVirtualInputDevice;
@@ -175,20 +178,6 @@ struct _ClutterActorBox
 */
 #define CLUTTER_ACTOR_BOX_INIT_ZERO                     CLUTTER_ACTOR_BOX_INIT (0.f, 0.f, 0.f, 0.f)

-/**
- * CLUTTER_ACTOR_BOX_UNINITIALIZED:
- *
- * A simple macro for creating a #ClutterActorBox with a size of -1 when
- * declaring it, e.g.:
- *
- * |[
- *   ClutterActorBox box = CLUTTER_ACTOR_BOX_UNINITIALIZED;
- * ]|
- */
-
-
-#define CLUTTER_ACTOR_BOX_UNINITIALIZED { .x1 = INFINITY, .y1 = INFINITY, .x2 = -INFINITY, .y2 = -INFINITY }
-
 CLUTTER_EXPORT
 GType            clutter_actor_box_get_type      (void) G_GNUC_CONST;
 CLUTTER_EXPORT
@@ -267,9 +256,6 @@ CLUTTER_EXPORT
 void             clutter_actor_box_scale          (ClutterActorBox       *box,
                                                   gfloat                 scale);

-CLUTTER_EXPORT
-gboolean         clutter_actor_box_is_initialized (ClutterActorBox       *box);
-
 /**
 * ClutterKnot:
 * @x: X coordinate of the knot
--- a/clutter/clutter/clutter.h
+++ b/clutter/clutter/clutter.h
@@ -56,6 +56,8 @@
 #include "clutter-content.h"
 #include "clutter-deform-effect.h"
 #include "clutter-desaturate-effect.h"
+#include "clutter-drag-action.h"
+#include "clutter-drop-action.h"
 #include "clutter-effect.h"
 #include "clutter-enums.h"
 #include "clutter-enum-types.h"
@@ -63,9 +65,9 @@
 #include "clutter-feature.h"
 #include "clutter-fixed-layout.h"
 #include "clutter-flow-layout.h"
-#include "clutter-frame-clock.h"
 #include "clutter-gesture-action.h"
 #include "clutter-grid-layout.h"
+#include "clutter-group.h"
 #include "clutter-image.h"
 #include "clutter-input-device.h"
 #include "clutter-input-device-tool.h"
--- a/clutter/clutter/cogl/clutter-stage-cogl.c
+++ b/clutter/clutter/cogl/clutter-stage-cogl.c
--- a/clutter/clutter/cogl/clutter-stage-cogl.h
+++ b/clutter/clutter/cogl/clutter-stage-cogl.h
@@ -41,6 +41,21 @@ struct _ClutterStageCogl

  /* back pointer to the backend */
  ClutterBackend *backend;
+
+  float refresh_rate;
+  int pending_swaps;
+
+  gint64 last_presentation_time;
+  gint64 update_time;
+  int64_t last_update_time;
+  int64_t next_presentation_time;
+
+  /* We only enable clipped redraws after 2 frames, since we've seen
+   * a lot of drivers can struggle to get going and may output some
+   * junk frames to start with. */
+  unsigned int frame_count;
+
+  gint last_sync_delay;
 };

 struct _ClutterStageCoglClass
--- a/clutter/clutter/deprecated/clutter-actor.h
+++ b/clutter/clutter/deprecated/clutter-actor.h
@@ -0,0 +1,114 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Matthew Allum  <mallum@openedhand.com>
+ *
+ * Copyright (C) 2006, 2007, 2008 OpenedHand Ltd
+ * Copyright (C) 2009, 2010 Intel Corp
+ *
+ * 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/>.
+ */
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#ifndef __CLUTTER_ACTOR_DEPRECATED_H__
+#define __CLUTTER_ACTOR_DEPRECATED_H__
+
+#include <clutter/clutter-types.h>
+
+G_BEGIN_DECLS
+
+CLUTTER_DEPRECATED
+ClutterActor *  clutter_get_actor_by_gid                        (guint32                id_);
+
+CLUTTER_DEPRECATED_FOR(clutter_actor_add_child)
+void            clutter_actor_set_parent                        (ClutterActor          *self,
+                                                                 ClutterActor          *parent);
+
+CLUTTER_DEPRECATED_FOR(clutter_actor_remove_child)
+void            clutter_actor_unparent                          (ClutterActor          *self);
+
+CLUTTER_DEPRECATED
+void            clutter_actor_push_internal                     (ClutterActor          *self);
+
+CLUTTER_DEPRECATED
+void            clutter_actor_pop_internal                      (ClutterActor          *self);
+
+CLUTTER_DEPRECATED
+void            clutter_actor_show_all                          (ClutterActor          *self);
+
+CLUTTER_DEPRECATED_FOR(clutter_actor_set_z_position)
+void            clutter_actor_set_depth                         (ClutterActor          *self,
+                                                                 gfloat                 depth);
+
+CLUTTER_DEPRECATED_FOR(clutter_actor_get_z_position)
+gfloat          clutter_actor_get_depth                         (ClutterActor          *self);
+
+CLUTTER_DEPRECATED_FOR(clutter_actor_set_rotation_angle)
+void            clutter_actor_set_rotation                      (ClutterActor          *self,
+                                                                 ClutterRotateAxis      axis,
+                                                                 gdouble                angle,
+                                                                 gfloat                 x,
+                                                                 gfloat                 y,
+                                                                 gfloat                 z);
+CLUTTER_DEPRECATED_FOR(clutter_actor_set_rotation_angle and clutter_actor_set_pivot_point)
+void            clutter_actor_set_z_rotation_from_gravity       (ClutterActor          *self,
+                                                                 gdouble                angle,
+                                                                 ClutterGravity         gravity);
+CLUTTER_DEPRECATED_FOR(clutter_actor_get_rotation_angle)
+gdouble         clutter_actor_get_rotation                      (ClutterActor          *self,
+                                                                 ClutterRotateAxis      axis,
+                                                                 gfloat                *x,
+                                                                 gfloat                *y,
+                                                                 gfloat                *z);
+CLUTTER_DEPRECATED
+ClutterGravity  clutter_actor_get_z_rotation_gravity            (ClutterActor          *self);
+
+CLUTTER_DEPRECATED_FOR(clutter_actor_set_scale and clutter_actor_set_pivot_point)
+void            clutter_actor_set_scale_full                    (ClutterActor          *self,
+                                                                 gdouble                scale_x,
+                                                                 gdouble                scale_y,
+                                                                 gfloat                 center_x,
+                                                                 gfloat                 center_y);
+CLUTTER_DEPRECATED_FOR(clutter_actor_get_pivot_point)
+void            clutter_actor_get_scale_center                  (ClutterActor          *self,
+                                                                 gfloat                *center_x,
+                                                                 gfloat                *center_y);
+CLUTTER_DEPRECATED_FOR(clutter_actor_get_pivot_point)
+ClutterGravity  clutter_actor_get_scale_gravity                 (ClutterActor          *self);
+
+CLUTTER_DEPRECATED
+void            clutter_actor_set_anchor_point                  (ClutterActor          *self,
+                                                                 gfloat                 anchor_x,
+                                                                 gfloat                 anchor_y);
+CLUTTER_DEPRECATED
+void            clutter_actor_move_anchor_point                 (ClutterActor          *self,
+                                                                 gfloat                 anchor_x,
+                                                                 gfloat                 anchor_y);
+CLUTTER_DEPRECATED
+ClutterGravity  clutter_actor_get_anchor_point_gravity          (ClutterActor          *self);
+CLUTTER_DEPRECATED
+void            clutter_actor_set_anchor_point_from_gravity     (ClutterActor          *self,
+                                                                 ClutterGravity         gravity);
+CLUTTER_DEPRECATED
+void            clutter_actor_move_anchor_point_from_gravity    (ClutterActor          *self,
+                                                                 ClutterGravity         gravity);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_ACTOR_DEPRECATED_H__ */
--- a/Show More
+++ b/Show More