clutter/actor: avoid transform node for identity matrix

If the transform matrix is an identity, then positioning wont change and
we can avoid creating the transform node altogether. This is based on
a similar find in GTK today while reducing temporary allocations.

This cuts the number of transforms created in clutter_actor_paint() by
about half under light testing of GNOME Shell from 6.8% to 2.4% of
allocations.

Before:

    ALLOCATED      TOTAL    FUNCTION
[   20.4 MiB] [  21.20%]    clutter_actor_paint
[   11.0 MiB] [  11.45%]      clutter_paint_node_paint
[    6.6 MiB] [   6.84%]      clutter_transform_node_new
[    2.5 MiB] [   2.61%]      clutter_actor_node_new

After:

    ALLOCATED      TOTAL    FUNCTION
[   33.4 MiB] [  24.12%]    clutter_actor_paint
[   26.2 MiB] [  18.91%]      clutter_paint_node_paint
[    3.4 MiB] [   2.43%]      clutter_actor_node_new
[    3.3 MiB] [   2.41%]      clutter_transform_node_new

Allocation amounts will have differed due to different amounts of running
time, but the % of allocations has now dropped below
clutter_actor_node_new() which should be expected.

https://gitlab.gnome.org/GNOME/mutter/issues/1056

.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
@@ -18,7 +17,7 @@ check-commit-log:
 build-mutter:
   stage: build
   script:
-    - meson . build -Dbuildtype=debugoptimized -Db_coverage=true -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
+    - meson . build -Dbuildtype=debugoptimized -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
     - ninja -C build
     - ninja -C build install
   artifacts:
@@ -29,19 +28,6 @@ build-mutter:
     - merge_requests
     - /^.*$/
 
-build-without-opengl-and-glx:
-  stage: build
-  script:
-    - meson . build -Dbuildtype=debugoptimized -Dopengl=false -Dglx=false -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
-    - ninja -C build
-    - ninja -C build install
-  artifacts:
-    paths:
-      - build/meson-logs
-  only:
-    - merge_requests
-    - /^.*$/
-
 build-without-native-backend-and-wayland:
   stage: build
   script:
@@ -49,8 +35,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 +52,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,30 +60,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:
-    - ninja -C build coverage
-    - cat build/meson-logs/coverage.txt
-  artifacts:
-    paths:
-      - build/meson-logs
-  when: manual
-  except:
-    refs:
-      - tags
-      - master
-
 can-build-gnome-shell:
   stage: test
   dependencies:

.gitlab-ci/Dockerfile

@@ -1,27 +1,29 @@
 # 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 jadahl/mutter-ci && \
+    dnf copr enable -y fmuellner/gnome-shell-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 clean all

.gitlab-ci/check-commit-log.sh

@@ -19,7 +19,7 @@ fi
 function commit_message_has_url() {
   commit=$1
   commit_message=$(git show -s --format='format:%b' $commit)
-  echo "$commit_message" | grep -qe "\($CI_MERGE_REQUEST_PROJECT_URL/\(-/\)\?\(issues\|merge_requests\)/[0-9]\+\|https://bugzilla.gnome.org/show_bug.cgi?id=[0-9]\+\)"
+  echo "$commit_message" | grep -qe "\($CI_MERGE_REQUEST_PROJECT_URL/\(issues\|merge_requests\)/[0-9]\+\|https://bugzilla.gnome.org/show_bug.cgi?id=[0-9]\+\)"
   return $?
 }
 

NEWS

@@ -1,115 +1,3 @@
-3.37.2
-======
-* Fix move-to-center keybinding with multiple monitors [Sergey; #1073]
-* Fix stuck buttons when a virtual device is destroyed [Carlos; !1239]
-* Use workarea when centering new windows [Akatsuki; #964]
-* Limit mipmap levels when rendering background [Daniel; !1003]
-* Broadcast clipboard/primary offers [Carlos; !1253]
-* Support primary-selection protocol from wayland-protocols [Carlos; !1255]
-* Fix monitor screen cast on X11 [Jonas Å.; !1251]
-* Support a "blank" cursor type [Florian; !1244]
-* Improve stage view damage tracking [Jonas Å.; !1237]
-* Implement touch-mode detecation for the X11 backend [Carlos; !1278]
-* Drop external keyboard detection from touch-mode heuristics [Carlos; !1277]
-* Optimize actor allocations [Jonas D.; !1247]
-* Fixed crashes [Daniel, Carlos, Jonas Å., Jonas D.; !1256, !1258, !1217, !1280]
-* Misc. bug fixes and cleanups [Christian, Jonas D., Olivier, Ting-Wei,
-  Jonas Å., Marco, Corentin, Daniel, Robert, Niels, Florian, Simon; !1231,
-  !1228, !1238, !1229, !1192, !1236, !1171, !1134, #1126, !1234, !1230, !1210,
-  !1242, !1243, !1252, !1113, !1232, !1259, !1245, !1265, !1180, !1261, !788,
-  !1264, !1235, !1218, !1150, !1274, !1271, !1279, !1283, !1272]
-
-Contributors:
-  Marco Trevisan (Treviño), Akatsuki, Jonas Dreßler, Olivier Fourdan,
-  Carlos Garnacho, Niels De Graef, Ting-Wei Lan, Robert Mader, Simon McVittie,
-  Florian Müllner, Corentin Noël, Christian Rauch, Daniel van Vugt,
-  Sergey Zigachev, Jonas Ådahl
-
-3.37.1
-======
-* Fix screencasting non-maximized windows [Jonas Å.; !1174]
-* Make window-aliveness checks less aggressive [Jonas Å.; !1182]
-* Fix stylus coordinates when using screen rotation [Jonas T.; #1118]
-* Preserve keyboard state on VT switch [Olivier; !1185]
-* Remove Clutter's drag and drop actions [Jonas D.; !789]
-* Cancel clicks/gestures actions on disable [Georges; !1188]
-* Fix various clipboard issues [Carlos; !1186, !1198, !1203, !1204, !1206]
-* Fix trackball button scrolling [Phillip; #1120]
-* Fix tiled monitor support [Jonas; !1199]
-* Support unredirecting fullscreen wayland surfaces [Jonas Å.; !798]
-* Support area screencasts [Jonas Å.; !1207]
-* Synchronize shadows to server-side decorations [Olivier; !1214]
-* Allow inhibiting remote access [Jonas Å.; !1212]
-* Fix overview key on X11 when using multiple keyboard layouts [Olivier; !1219]
-* Fixed crashes [Jonas, D., Carlos; !1173, !1183, !1012]
-* Misc. bug fixes and cleanups [Andre, Georges, Christian, Jonas Å., Andre,
-  Simon, Florian, Carlos, Adam, Marco, Thomas, Elias, Pekka, Jonas D.,
-  Laurent; !1169, !1168, !1166, !1170, !1167, !1172, !1175, !1176, !1184,
-  !1126, !1187, !1191, !1195, !1179, !1200, !1193, !1209, !1213, !1208,
-  #1074, !1223]
-
-Contributors:
-  Marco Trevisan (Treviño), Elias Aebi, Thomas Hindoe Paaboel Andersen,
-  Laurent Bigonville, Jonas Dreßler, Olivier Fourdan, Carlos Garnacho,
-  Adam Jackson, Andre Moreira Magalhaes, Simon McVittie, Florian Müllner,
-  Georges Basile Stavracas Neto, Pekka Paalanen, Christian Rauch, Jonas Troeger,
-  Phillip Wood, Jonas Ådahl
-
-Translators:
-  Dušan Kazik [sk], Christian Kirbach [de]
-
-3.36.0
-======
-* Fix placement of popup windows in multi-monitor setups [Jonas; !1110]
-* Fix invisible mouse cursor on some hardware [Jonas; !1079]
-
-Contributors:
-  Jonas Ådahl
-
-Translators:
-  Aurimas Černius [lt], Goran Vidović [hr], Anders Jonsson [sv],
-  Guillaume Bernard [fr], Milo Casagrande [it], Daniel Korostil [uk],
-  Andre Klapper [cy], Aman Alam [pa], Nathan Follens [nl]
-
-3.35.92
-=======
-* Fix visibility of initially hidden windows [Jonas Å.; !1066]
-* Avoid flicker when (un)redirecting windows [Sebastian; #997]
-* Let BindConstraints update the preferred size [Emmanuele; !1070]
-* Learn about GLES3 [Adam; !882]
-* Ping windows on every window focus [Jonas D.; !891]
-* Remove overhead from hot code paths [Christian;
-  #1056, !1081, !1083, !1071, !1087]
-* Allow remote desktop services to inhibit animations [Jonas Å.; !838]
-* Update screen-cast code to PipeWire 0.3 API [Wim; !1062]
-* Make check-alive timeouts configurable [Jonas Å.; !1080]
-* Make each stage view correspond to a single CRTC [Jonas Å.; !1042]
-* Implement scaled/transformed hardware cursors [Robert; !526]
-* Use DMA buffers for screencasting if possible [Georges; !1086]
-* Make Xwayland startup asynchronous [Carlos; !944]
-* Fix clipping glitches in long text entries [Jonas D.; !1096]
-* Add side channel for starting required X11 services [Carlos; !945]
-* Support synchronized wayland popup moving [Jonas Å.; !705]
-* Fixed crashes [Olivier, Jonas Å.; !1073, !1093]
-* Plugged memory leaks [Sebastian, Jonas Å.; !1089, !1095]
-* Misc. bug fixes and cleanups [Jonas Å, Olivier, Florian, Daniel, Jonas D.,
-  Robert, Sebastian, Christian, Arun, Carlos, worldofpeace; !1061, #1043,
-  !1067, !1068, !1065, !835, !1058, !1069, !1075, #1060, !1077, !423, !1090,
-  !1088, !1094, #1067, !1064, !1099, !957, !1000, !1082]
-
-Contributors:
-  Emmanuele Bassi, Jonas Dreßler, Olivier Fourdan, Carlos Garnacho,
-  Christian Hergert, Adam Jackson, Sebastian Keller, Robert Mader,
-  Florian Müllner, Georges Basile Stavracas Neto, Arun Raghavan, Wim Taymans,
-  Daniel van Vugt, worldofpeace, Jonas Ådahl
-
-Translators:
-  Yi-Jyun Pan [zh_TW], Asier Sarasua Garmendia [eu], Rafael Fontenelle [pt_BR],
-  Emin Tufan Çetin [tr], Daniel Mustieles [es], Balázs Úr [hu],
-  Gwan-gyeong Mun [ko], Marek Černocký [cs], Fran Dieguez [gl],
-  Kukuh Syafaat [id], Alan Mortensen [da], Piotr Drąg [pl], sicklylife [ja],
-  Matej Urbančič [sl]
-
 3.35.91
 =======
 * Honor accelerometer orientation on monitor config changes [Hans; !959]

clutter/clutter/cally/cally-actor.c

@@ -600,11 +600,10 @@ cally_actor_real_remove_actor (ClutterActor *container,
   g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), 0);
 
   atk_parent = ATK_OBJECT (data);
+  atk_child = clutter_actor_get_accessible (actor);
 
-  if (clutter_actor_has_accessible (actor))
+  if (atk_child)
     {
-      atk_child = clutter_actor_get_accessible (actor);
-
       g_value_init (&values.old_value, G_TYPE_POINTER);
       g_value_set_pointer (&values.old_value, atk_parent);
 

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;
+}

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__ */

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;
+}

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__ */

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));

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];

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 */

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"

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,

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,

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);
 }

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);

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__ */

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,
@@ -298,14 +299,10 @@ 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 */
-  gpointer _padding_dummy[25];
+  gpointer _padding_dummy[26];
 };
 
 /**
@@ -383,8 +380,6 @@ CLUTTER_EXPORT
 const gchar *                   clutter_actor_get_name                          (ClutterActor                *self);
 CLUTTER_EXPORT
 AtkObject *                     clutter_actor_get_accessible                    (ClutterActor                *self);
-CLUTTER_EXPORT
-gboolean                        clutter_actor_has_accessible                    (ClutterActor                *self);
 
 CLUTTER_EXPORT
 gboolean                        clutter_actor_is_visible                        (ClutterActor                *self);
@@ -417,29 +412,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);
+void                            clutter_actor_allocate_preferred_size           (ClutterActor                *self,
+                                                                                 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,
@@ -593,7 +597,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);
@@ -876,11 +881,6 @@ void                            clutter_actor_set_opacity_override
 CLUTTER_EXPORT
 gint                            clutter_actor_get_opacity_override              (ClutterActor               *self);
 
-CLUTTER_EXPORT
-void                            clutter_actor_inhibit_culling                   (ClutterActor               *actor);
-CLUTTER_EXPORT
-void                            clutter_actor_uninhibit_culling                 (ClutterActor               *actor);
-
 /**
  * ClutterActorCreateChildFunc:
  * @item: (type GObject): the item in the model
@@ -918,15 +918,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__ */

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

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

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);
-}

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__ */

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)

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__ */

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;
-}

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);
     }
 }
 

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:

clutter/clutter/clutter-blur-effect.c

@@ -81,6 +81,9 @@ struct _ClutterBlurEffect
 
   gint pixel_step_uniform;
 
+  gint tex_width;
+  gint tex_height;
+
   CoglPipeline *pipeline;
 };
 
@@ -95,42 +98,20 @@ G_DEFINE_TYPE (ClutterBlurEffect,
                clutter_blur_effect,
                CLUTTER_TYPE_OFFSCREEN_EFFECT);
 
-static CoglPipeline *
-clutter_blur_effect_create_pipeline (ClutterOffscreenEffect *effect,
-                                     CoglTexture            *texture)
-{
-  ClutterBlurEffect *blur_effect = CLUTTER_BLUR_EFFECT (effect);
-
-  if (blur_effect->pixel_step_uniform > -1)
-    {
-      float pixel_step[2];
-      int tex_width, tex_height;
-
-      tex_width = cogl_texture_get_width (texture);
-      tex_height = cogl_texture_get_height (texture);
-
-      pixel_step[0] = 1.0f / tex_width;
-      pixel_step[1] = 1.0f / tex_height;
-
-      cogl_pipeline_set_uniform_float (blur_effect->pipeline,
-                                       blur_effect->pixel_step_uniform,
-                                       2, /* n_components */
-                                       1, /* count */
-                                       pixel_step);
-    }
-
-  cogl_pipeline_set_layer_texture (blur_effect->pipeline, 0, texture);
-
-  return cogl_object_ref (blur_effect->pipeline);
-}
-
 static gboolean
 clutter_blur_effect_pre_paint (ClutterEffect       *effect,
-                               ClutterPaintNode    *node,
                                ClutterPaintContext *paint_context)
 {
+  ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (effect);
   ClutterEffectClass *parent_class;
 
+  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
+    return FALSE;
+
+  self->actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
+  if (self->actor == NULL)
+    return FALSE;
+
   if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
     {
       /* if we don't have support for GLSL shaders then we
@@ -144,7 +125,59 @@ clutter_blur_effect_pre_paint (ClutterEffect       *effect,
     }
 
   parent_class = CLUTTER_EFFECT_CLASS (clutter_blur_effect_parent_class);
-  return parent_class->pre_paint (effect, node, paint_context);
+  if (parent_class->pre_paint (effect, paint_context))
+    {
+      ClutterOffscreenEffect *offscreen_effect =
+        CLUTTER_OFFSCREEN_EFFECT (effect);
+      CoglHandle texture;
+
+      texture = clutter_offscreen_effect_get_texture (offscreen_effect);
+      self->tex_width = cogl_texture_get_width (texture);
+      self->tex_height = cogl_texture_get_height (texture);
+
+      if (self->pixel_step_uniform > -1)
+        {
+          gfloat pixel_step[2];
+
+          pixel_step[0] = 1.0f / self->tex_width;
+          pixel_step[1] = 1.0f / self->tex_height;
+
+          cogl_pipeline_set_uniform_float (self->pipeline,
+                                           self->pixel_step_uniform,
+                                           2, /* n_components */
+                                           1, /* count */
+                                           pixel_step);
+        }
+
+      cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
+
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+static void
+clutter_blur_effect_paint_target (ClutterOffscreenEffect *effect,
+                                  ClutterPaintContext    *paint_context)
+{
+  ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (effect);
+  CoglFramebuffer *framebuffer =
+    clutter_paint_context_get_framebuffer (paint_context);
+  guint8 paint_opacity;
+
+  paint_opacity = clutter_actor_get_paint_opacity (self->actor);
+
+  cogl_pipeline_set_color4ub (self->pipeline,
+                              paint_opacity,
+                              paint_opacity,
+                              paint_opacity,
+                              paint_opacity);
+
+  cogl_framebuffer_draw_rectangle (framebuffer,
+                                   self->pipeline,
+                                   0, 0,
+                                   self->tex_width, self->tex_height);
 }
 
 static gboolean
@@ -196,7 +229,7 @@ clutter_blur_effect_class_init (ClutterBlurEffectClass *klass)
   effect_class->modify_paint_volume = clutter_blur_effect_modify_paint_volume;
 
   offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
-  offscreen_class->create_pipeline = clutter_blur_effect_create_pipeline;
+  offscreen_class->paint_target = clutter_blur_effect_paint_target;
 }
 
 static void

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__ */

clutter/clutter/clutter-brightness-contrast-effect.c

@@ -69,6 +69,9 @@ struct _ClutterBrightnessContrastEffect
   gint brightness_offset_uniform;
   gint contrast_uniform;
 
+  gint tex_width;
+  gint tex_height;
+
   CoglPipeline *pipeline;
 };
 
@@ -126,26 +129,16 @@ will_have_no_effect (ClutterBrightnessContrastEffect *self)
           G_APPROX_VALUE (self->contrast_blue, no_change, FLT_EPSILON));
 }
 
-static CoglPipeline *
-clutter_brightness_contrast_effect_create_pipeline (ClutterOffscreenEffect *effect,
-                                                    CoglTexture            *texture)
-{
-  ClutterBrightnessContrastEffect *self =
-    CLUTTER_BRIGHTNESS_CONTRAST_EFFECT (effect);
-
-  cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
-
-  return cogl_object_ref (self->pipeline);
-}
-
 static gboolean
 clutter_brightness_contrast_effect_pre_paint (ClutterEffect       *effect,
-                                              ClutterPaintNode    *node,
                                               ClutterPaintContext *paint_context)
 {
   ClutterBrightnessContrastEffect *self = CLUTTER_BRIGHTNESS_CONTRAST_EFFECT (effect);
   ClutterEffectClass *parent_class;
 
+  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
+    return FALSE;
+
   if (will_have_no_effect (self))
     return FALSE;
 
@@ -164,8 +157,47 @@ clutter_brightness_contrast_effect_pre_paint (ClutterEffect       *effect,
 
   parent_class =
     CLUTTER_EFFECT_CLASS (clutter_brightness_contrast_effect_parent_class);
+  if (parent_class->pre_paint (effect, paint_context))
+    {
+      ClutterOffscreenEffect *offscreen_effect =
+        CLUTTER_OFFSCREEN_EFFECT (effect);
+      CoglHandle texture;
 
-  return parent_class->pre_paint (effect, node, paint_context);
+      texture = clutter_offscreen_effect_get_texture (offscreen_effect);
+      self->tex_width = cogl_texture_get_width (texture);
+      self->tex_height = cogl_texture_get_height (texture);
+
+      cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
+
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+static void
+clutter_brightness_contrast_effect_paint_target (ClutterOffscreenEffect *effect,
+                                                 ClutterPaintContext    *paint_context)
+{
+  ClutterBrightnessContrastEffect *self = CLUTTER_BRIGHTNESS_CONTRAST_EFFECT (effect);
+  CoglFramebuffer *framebuffer =
+   clutter_paint_context_get_framebuffer (paint_context);
+  ClutterActor *actor;
+  guint8 paint_opacity;
+
+  actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
+  paint_opacity = clutter_actor_get_paint_opacity (actor);
+
+  cogl_pipeline_set_color4ub (self->pipeline,
+                              paint_opacity,
+                              paint_opacity,
+                              paint_opacity,
+                              paint_opacity);
+
+  cogl_framebuffer_draw_rectangle (framebuffer,
+                                   self->pipeline,
+                                   0, 0,
+                                   self->tex_width, self->tex_height);
 }
 
 static void
@@ -265,7 +297,7 @@ clutter_brightness_contrast_effect_class_init (ClutterBrightnessContrastEffectCl
   ClutterOffscreenEffectClass *offscreen_class;
 
   offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
-  offscreen_class->create_pipeline = clutter_brightness_contrast_effect_create_pipeline;
+  offscreen_class->paint_target = clutter_brightness_contrast_effect_paint_target;
 
   effect_class->pre_paint = clutter_brightness_contrast_effect_pre_paint;
 

clutter/clutter/clutter-canvas.c

@@ -352,7 +352,7 @@ clutter_canvas_paint_content (ClutterContent      *content,
     return;
 
   node = clutter_actor_create_texture_paint_node (actor, priv->texture);
-  clutter_paint_node_set_static_name (node, "Canvas Content");
+  clutter_paint_node_set_name (node, "Canvas Content");
   clutter_paint_node_add_child (root, node);
   clutter_paint_node_unref (node);
 

clutter/clutter/clutter-click-action.c

@@ -159,8 +159,7 @@ static inline void
 click_action_set_pressed (ClutterClickAction *action,
                           gboolean            is_pressed)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
 
   is_pressed = !!is_pressed;
 
@@ -175,8 +174,7 @@ static inline void
 click_action_set_held (ClutterClickAction *action,
                        gboolean            is_held)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
 
   is_held = !!is_held;
 
@@ -191,8 +189,7 @@ static gboolean
 click_action_emit_long_press (gpointer data)
 {
   ClutterClickAction *action = data;
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
   ClutterActor *actor;
   gboolean result;
 
@@ -216,8 +213,7 @@ click_action_emit_long_press (gpointer data)
 static inline void
 click_action_query_long_press (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
   ClutterActor *actor;
   gboolean result = FALSE;
   gint timeout;
@@ -242,7 +238,6 @@ click_action_query_long_press (ClutterClickAction *action)
 
   if (result)
     {
-      g_clear_handle_id (&priv->long_press_id, g_source_remove);
       priv->long_press_id =
         clutter_threads_add_timeout (timeout,
                                      click_action_emit_long_press,
@@ -253,8 +248,7 @@ click_action_query_long_press (ClutterClickAction *action)
 static inline void
 click_action_cancel_long_press (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
 
   if (priv->long_press_id != 0)
     {
@@ -277,8 +271,7 @@ on_event (ClutterActor       *actor,
           ClutterEvent       *event,
           ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
   gboolean has_button = TRUE;
 
   if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (action)))
@@ -348,8 +341,7 @@ on_captured_event (ClutterActor       *stage,
                    ClutterEvent       *event,
                    ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
   ClutterActor *actor;
   ClutterModifierType modifier_state;
   gboolean has_button = TRUE;
@@ -441,8 +433,7 @@ clutter_click_action_set_actor (ClutterActorMeta *meta,
                                 ClutterActor     *actor)
 {
   ClutterClickAction *action = CLUTTER_CLICK_ACTION (meta);
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (action);
+  ClutterClickActionPrivate *priv = action->priv;
 
   if (priv->event_id != 0)
     {
@@ -476,28 +467,13 @@ clutter_click_action_set_actor (ClutterActorMeta *meta,
   CLUTTER_ACTOR_META_CLASS (clutter_click_action_parent_class)->set_actor (meta, actor);
 }
 
-static void
-clutter_click_action_set_enabled (ClutterActorMeta *meta,
-                                  gboolean          is_enabled)
-{
-  ClutterClickAction *click_action = CLUTTER_CLICK_ACTION (meta);
-  ClutterActorMetaClass *parent_class =
-    CLUTTER_ACTOR_META_CLASS (clutter_click_action_parent_class);
-
-  if (!is_enabled)
-    clutter_click_action_release (click_action);
-
-  parent_class->set_enabled (meta, is_enabled);
-}
-
 static void
 clutter_click_action_set_property (GObject      *gobject,
                                    guint         prop_id,
                                    const GValue *value,
                                    GParamSpec   *pspec)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
 
   switch (prop_id)
     {
@@ -521,8 +497,7 @@ clutter_click_action_get_property (GObject    *gobject,
                                    GValue     *value,
                                    GParamSpec *pspec)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
 
   switch (prop_id)
     {
@@ -551,8 +526,7 @@ clutter_click_action_get_property (GObject    *gobject,
 static void
 clutter_click_action_dispose (GObject *gobject)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
 
   g_clear_signal_handler (&priv->event_id,
                           clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (gobject)));
@@ -572,7 +546,6 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
   ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
 
   meta_class->set_actor = clutter_click_action_set_actor;
-  meta_class->set_enabled = clutter_click_action_set_enabled;
 
   gobject_class->dispose = clutter_click_action_dispose;
   gobject_class->set_property = clutter_click_action_set_property;
@@ -710,11 +683,9 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
 static void
 clutter_click_action_init (ClutterClickAction *self)
 {
-  ClutterClickActionPrivate *priv =
-    clutter_click_action_get_instance_private (self);
-
-  priv->long_press_threshold = -1;
-  priv->long_press_duration = -1;
+  self->priv = clutter_click_action_get_instance_private (self);
+  self->priv->long_press_threshold = -1;
+  self->priv->long_press_duration = -1;
 }
 
 /**
@@ -754,7 +725,7 @@ clutter_click_action_release (ClutterClickAction *action)
 
   g_return_if_fail (CLUTTER_IS_CLICK_ACTION (action));
 
-  priv = clutter_click_action_get_instance_private (action);
+  priv = action->priv;
 
   if (!priv->is_held)
     return;
@@ -780,13 +751,9 @@ clutter_click_action_release (ClutterClickAction *action)
 guint
 clutter_click_action_get_button (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv;
-
   g_return_val_if_fail (CLUTTER_IS_CLICK_ACTION (action), 0);
 
-  priv = clutter_click_action_get_instance_private (action);
-
-  return priv->press_button;
+  return action->priv->press_button;
 }
 
 /**
@@ -802,13 +769,9 @@ clutter_click_action_get_button (ClutterClickAction *action)
 ClutterModifierType
 clutter_click_action_get_state (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv;
-
   g_return_val_if_fail (CLUTTER_IS_CLICK_ACTION (action), 0);
 
-  priv = clutter_click_action_get_instance_private (action);
-
-  return priv->modifier_state;
+  return action->priv->modifier_state;
 }
 
 /**
@@ -826,15 +789,11 @@ clutter_click_action_get_coords (ClutterClickAction *action,
                                  gfloat             *press_x,
                                  gfloat             *press_y)
 {
-  ClutterClickActionPrivate *priv;
-
   g_return_if_fail (CLUTTER_IS_ACTION (action));
 
-  priv = clutter_click_action_get_instance_private (action);
-
   if (press_x != NULL)
-    *press_x = priv->press_x;
+    *press_x = action->priv->press_x;
 
   if (press_y != NULL)
-    *press_y = priv->press_y;
+    *press_y = action->priv->press_y;
 }

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);
 

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,25 +258,7 @@ clutter_clone_allocate (ClutterActor           *self,
    */
   if (clutter_actor_get_parent (priv->clone_source) != NULL &&
       !clutter_actor_has_allocation (priv->clone_source))
-    clutter_actor_allocate_preferred_size (priv->clone_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);
-
-  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
@@ -278,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
 }
 
@@ -370,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;
 }
 
 /**

clutter/clutter/clutter-colorize-effect.c

@@ -59,6 +59,9 @@ struct _ClutterColorizeEffect
 
   gint tint_uniform;
 
+  gint tex_width;
+  gint tex_height;
+
   CoglPipeline *pipeline;
 };
 
@@ -101,24 +104,16 @@ G_DEFINE_TYPE (ClutterColorizeEffect,
                clutter_colorize_effect,
                CLUTTER_TYPE_OFFSCREEN_EFFECT);
 
-static CoglPipeline *
-clutter_colorize_effect_create_pipeline (ClutterOffscreenEffect *effect,
-                                         CoglTexture            *texture)
-{
-  ClutterColorizeEffect *colorize_effect = CLUTTER_COLORIZE_EFFECT (effect);
-
-  cogl_pipeline_set_layer_texture (colorize_effect->pipeline, 0, texture);
-
-  return cogl_object_ref (colorize_effect->pipeline);
-}
-
 static gboolean
 clutter_colorize_effect_pre_paint (ClutterEffect       *effect,
-                                   ClutterPaintNode    *node,
                                    ClutterPaintContext *paint_context)
 {
+  ClutterColorizeEffect *self = CLUTTER_COLORIZE_EFFECT (effect);
   ClutterEffectClass *parent_class;
 
+  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
+    return FALSE;
+
   if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
     {
       /* if we don't have support for GLSL shaders then we
@@ -132,7 +127,47 @@ clutter_colorize_effect_pre_paint (ClutterEffect       *effect,
     }
 
   parent_class = CLUTTER_EFFECT_CLASS (clutter_colorize_effect_parent_class);
-  return parent_class->pre_paint (effect, node, paint_context);
+  if (parent_class->pre_paint (effect, paint_context))
+    {
+      ClutterOffscreenEffect *offscreen_effect =
+        CLUTTER_OFFSCREEN_EFFECT (effect);
+      CoglHandle texture;
+
+      texture = clutter_offscreen_effect_get_texture (offscreen_effect);
+      self->tex_width = cogl_texture_get_width (texture);
+      self->tex_height = cogl_texture_get_height (texture);
+
+      cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
+
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+static void
+clutter_colorize_effect_paint_target (ClutterOffscreenEffect *effect,
+                                      ClutterPaintContext    *paint_context)
+{
+  ClutterColorizeEffect *self = CLUTTER_COLORIZE_EFFECT (effect);
+  CoglFramebuffer *framebuffer =
+    clutter_paint_context_get_framebuffer (paint_context);
+  ClutterActor *actor;
+  guint8 paint_opacity;
+
+  actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
+  paint_opacity = clutter_actor_get_paint_opacity (actor);
+
+  cogl_pipeline_set_color4ub (self->pipeline,
+                              paint_opacity,
+                              paint_opacity,
+                              paint_opacity,
+                              paint_opacity);
+
+  cogl_framebuffer_draw_rectangle (framebuffer,
+                                   self->pipeline,
+                                   0, 0,
+                                   self->tex_width, self->tex_height);
 }
 
 static void
@@ -198,7 +233,7 @@ clutter_colorize_effect_class_init (ClutterColorizeEffectClass *klass)
   ClutterOffscreenEffectClass *offscreen_class;
 
   offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
-  offscreen_class->create_pipeline = clutter_colorize_effect_create_pipeline;
+  offscreen_class->paint_target = clutter_colorize_effect_paint_target;
 
   effect_class->pre_paint = clutter_colorize_effect_pre_paint;
 

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
 

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;

clutter/clutter/clutter-container-private.h

@@ -1,36 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Copyright 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_CONTAINER_PRIVATE_H__
-#define __CLUTTER_CONTAINER_PRIVATE_H__
-
-#include <clutter/clutter-container.h>
-
-G_BEGIN_DECLS
-
-void _clutter_container_emit_actor_added   (ClutterContainer *container,
-                                            ClutterActor     *actor);
-void _clutter_container_emit_actor_removed (ClutterContainer *container,
-                                            ClutterActor     *actor);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_CONTAINER_PRIVATE_H__ */

clutter/clutter/clutter-container.c

@@ -37,7 +37,6 @@
 
 #include "clutter-actor-private.h"
 #include "clutter-child-meta.h"
-#include "clutter-container-private.h"
 #include "clutter-debug.h"
 #include "clutter-main.h"
 #include "clutter-marshal.h"
@@ -1251,23 +1250,3 @@ clutter_container_child_notify (ClutterContainer *container,
                                                          child,
                                                          pspec);
 }
-
-void
-_clutter_container_emit_actor_added (ClutterContainer *container,
-                                     ClutterActor     *actor)
-{
-  g_return_if_fail (CLUTTER_IS_CONTAINER (container));
-  g_return_if_fail (CLUTTER_IS_ACTOR (actor));
-
-  g_signal_emit (container, container_signals[ACTOR_ADDED], 0, actor);
-}
-
-void
-_clutter_container_emit_actor_removed (ClutterContainer *container,
-                                       ClutterActor     *actor)
-{
-  g_return_if_fail (CLUTTER_IS_CONTAINER (container));
-  g_return_if_fail (CLUTTER_IS_ACTOR (actor));
-
-  g_signal_emit (container, container_signals[ACTOR_REMOVED], 0, actor);
-}

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)];
-}

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 */

clutter/clutter/clutter-deform-effect.c

@@ -58,12 +58,9 @@
 
 #include <cogl/cogl.h>
 
-#include "clutter-color.h"
 #include "clutter-debug.h"
 #include "clutter-enum-types.h"
 #include "clutter-offscreen-effect-private.h"
-#include "clutter-paint-node.h"
-#include "clutter-paint-nodes.h"
 #include "clutter-private.h"
 
 #define DEFAULT_N_TILES         32
@@ -131,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;
 }
@@ -158,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);
 
@@ -169,16 +167,19 @@ clutter_deform_effect_set_actor (ClutterActorMeta *meta,
 
 static void
 clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect,
-                                    ClutterPaintNode       *node,
                                     ClutterPaintContext    *paint_context)
 {
   ClutterDeformEffect *self= CLUTTER_DEFORM_EFFECT (effect);
   ClutterDeformEffectPrivate *priv = self->priv;
+  CoglHandle material;
   CoglPipeline *pipeline;
   CoglDepthState depth_state;
+  CoglFramebuffer *fb =
+    clutter_paint_context_get_framebuffer (paint_context);
 
   if (priv->is_dirty)
     {
+      graphene_rect_t rect;
       gboolean mapped_buffer;
       CoglVertexP3T2C4 *verts;
       ClutterActor *actor;
@@ -192,7 +193,12 @@ clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect,
       /* if we don't have a target size, fall back to the actor's
        * allocation, though wrong it might be
        */
-      if (!clutter_offscreen_effect_get_target_size (effect, &width, &height))
+      if (clutter_offscreen_effect_get_target_rect (effect, &rect))
+        {
+          width = graphene_rect_get_width (&rect);
+          height = graphene_rect_get_height (&rect);
+        }
+      else
         clutter_actor_get_size (actor, &width, &height);
 
       /* XXX ideally, the sub-classes should tell us what they
@@ -272,7 +278,8 @@ clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect,
       priv->is_dirty = FALSE;
     }
 
-  pipeline = clutter_offscreen_effect_get_pipeline (effect);
+  material = clutter_offscreen_effect_get_target (effect);
+  pipeline = COGL_PIPELINE (material);
 
   /* enable depth testing */
   cogl_depth_state_init (&depth_state);
@@ -286,22 +293,12 @@ clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect,
                                       COGL_PIPELINE_CULL_FACE_MODE_BACK);
 
   /* draw the front */
-  if (pipeline != NULL)
-    {
-      ClutterPaintNode *front_node;
-
-      front_node = clutter_pipeline_node_new (pipeline);
-      clutter_paint_node_set_static_name (front_node,
-                                          "ClutterDeformEffect (front)");
-      clutter_paint_node_add_child (node, front_node);
-      clutter_paint_node_add_primitive (front_node, priv->primitive);
-      clutter_paint_node_unref (front_node);
-    }
+  if (material != NULL)
+    cogl_framebuffer_draw_primitive (fb, pipeline, priv->primitive);
 
   /* draw the back */
   if (priv->back_pipeline != NULL)
     {
-      ClutterPaintNode *back_node;
       CoglPipeline *back_pipeline;
 
       /* We probably shouldn't be modifying the user's material so
@@ -311,30 +308,20 @@ clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect,
       cogl_pipeline_set_cull_face_mode (back_pipeline,
                                         COGL_PIPELINE_CULL_FACE_MODE_FRONT);
 
+      cogl_framebuffer_draw_primitive (fb, back_pipeline, priv->primitive);
 
-      back_node = clutter_pipeline_node_new (back_pipeline);
-      clutter_paint_node_set_static_name (back_node,
-                                          "ClutterDeformEffect (back)");
-      clutter_paint_node_add_child (node, back_node);
-      clutter_paint_node_add_primitive (back_node, priv->primitive);
-
-      clutter_paint_node_unref (back_node);
       cogl_object_unref (back_pipeline);
     }
 
   if (G_UNLIKELY (priv->lines_primitive != NULL))
     {
-      const ClutterColor *red;
-      ClutterPaintNode *lines_node;
-
-      red = clutter_color_get_static (CLUTTER_COLOR_RED);
-
-      lines_node = clutter_color_node_new (red);
-      clutter_paint_node_set_static_name (lines_node,
-                                          "ClutterDeformEffect (lines)");
-      clutter_paint_node_add_child (node, lines_node);
-      clutter_paint_node_add_primitive (lines_node, priv->lines_primitive);
-      clutter_paint_node_unref (lines_node);
+      CoglContext *ctx =
+        clutter_backend_get_cogl_context (clutter_get_default_backend ());
+      CoglPipeline *lines_pipeline = cogl_pipeline_new (ctx);
+      cogl_pipeline_set_color4f (lines_pipeline, 1.0, 0, 0, 1.0);
+      cogl_framebuffer_draw_primitive (fb, lines_pipeline,
+                                       priv->lines_primitive);
+      cogl_object_unref (lines_pipeline);
     }
 }
 

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__
 

clutter/clutter/clutter-desaturate-effect.c

@@ -111,25 +111,16 @@ G_DEFINE_TYPE (ClutterDesaturateEffect,
                clutter_desaturate_effect,
                CLUTTER_TYPE_OFFSCREEN_EFFECT);
 
-static CoglPipeline *
-clutter_desaturate_effect_create_pipeline (ClutterOffscreenEffect *effect,
-                                           CoglTexture            *texture)
-{
-  ClutterDesaturateEffect *desaturate_effect =
-    CLUTTER_DESATURATE_EFFECT (effect);
-
-  cogl_pipeline_set_layer_texture (desaturate_effect->pipeline, 0, texture);
-
-  return cogl_object_ref (desaturate_effect->pipeline);
-}
-
 static gboolean
 clutter_desaturate_effect_pre_paint (ClutterEffect       *effect,
-                                     ClutterPaintNode    *node,
                                      ClutterPaintContext *paint_context)
 {
+  ClutterDesaturateEffect *self = CLUTTER_DESATURATE_EFFECT (effect);
   ClutterEffectClass *parent_class;
 
+  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
+    return FALSE;
+
   if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
     {
       /* if we don't have support for GLSL shaders then we
@@ -143,7 +134,52 @@ clutter_desaturate_effect_pre_paint (ClutterEffect       *effect,
     }
 
   parent_class = CLUTTER_EFFECT_CLASS (clutter_desaturate_effect_parent_class);
-  return parent_class->pre_paint (effect, node, paint_context);
+  if (parent_class->pre_paint (effect, paint_context))
+    {
+      ClutterOffscreenEffect *offscreen_effect =
+        CLUTTER_OFFSCREEN_EFFECT (effect);
+      CoglHandle texture;
+
+      texture = clutter_offscreen_effect_get_texture (offscreen_effect);
+      self->tex_width = cogl_texture_get_width (texture);
+      self->tex_height = cogl_texture_get_height (texture);
+
+      cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
+
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+static void
+clutter_desaturate_effect_paint_target (ClutterOffscreenEffect *effect,
+                                        ClutterPaintContext    *paint_context)
+{
+  ClutterDesaturateEffect *self = CLUTTER_DESATURATE_EFFECT (effect);
+  CoglFramebuffer *framebuffer =
+   clutter_paint_context_get_framebuffer (paint_context);
+  ClutterActor *actor;
+  CoglHandle texture;
+  guint8 paint_opacity;
+
+  texture = clutter_offscreen_effect_get_texture (effect);
+  cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
+
+  actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
+  paint_opacity = clutter_actor_get_paint_opacity (actor);
+
+  cogl_pipeline_set_color4ub (self->pipeline,
+                              paint_opacity,
+                              paint_opacity,
+                              paint_opacity,
+                              paint_opacity);
+
+  cogl_framebuffer_draw_rectangle (framebuffer,
+                                   self->pipeline,
+                                   0, 0,
+                                   cogl_texture_get_width (texture),
+                                   cogl_texture_get_height (texture));
 }
 
 static void
@@ -218,7 +254,7 @@ clutter_desaturate_effect_class_init (ClutterDesaturateEffectClass *klass)
   ClutterOffscreenEffectClass *offscreen_class;
 
   offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
-  offscreen_class->create_pipeline = clutter_desaturate_effect_create_pipeline;
+  offscreen_class->paint_target = clutter_desaturate_effect_paint_target;
 
   effect_class->pre_paint = clutter_desaturate_effect_pre_paint;
 

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__ */

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);
+}

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__ */

clutter/clutter/clutter-effect-private.h

@@ -5,11 +5,14 @@
 
 G_BEGIN_DECLS
 
+gboolean        _clutter_effect_pre_paint               (ClutterEffect           *effect,
+                                                         ClutterPaintContext     *paint_context);
+void            _clutter_effect_post_paint              (ClutterEffect           *effect,
+                                                         ClutterPaintContext     *paint_context);
 gboolean        _clutter_effect_modify_paint_volume     (ClutterEffect           *effect,
                                                          ClutterPaintVolume      *volume);
 gboolean        _clutter_effect_has_custom_paint_volume (ClutterEffect           *effect);
 void            _clutter_effect_paint                   (ClutterEffect           *effect,
-                                                         ClutterPaintNode        *node,
                                                          ClutterPaintContext     *paint_context,
                                                          ClutterEffectPaintFlags  flags);
 void            _clutter_effect_pick                    (ClutterEffect           *effect,

clutter/clutter/clutter-effect.c

@@ -169,8 +169,6 @@
 #include "clutter-effect-private.h"
 #include "clutter-enum-types.h"
 #include "clutter-marshal.h"
-#include "clutter-paint-node-private.h"
-#include "clutter-paint-nodes.h"
 #include "clutter-private.h"
 #include "clutter-actor-private.h"
 
@@ -180,7 +178,6 @@ G_DEFINE_ABSTRACT_TYPE (ClutterEffect,
 
 static gboolean
 clutter_effect_real_pre_paint (ClutterEffect       *effect,
-                               ClutterPaintNode    *node,
                                ClutterPaintContext *paint_context)
 {
   return TRUE;
@@ -188,7 +185,6 @@ clutter_effect_real_pre_paint (ClutterEffect       *effect,
 
 static void
 clutter_effect_real_post_paint (ClutterEffect       *effect,
-                                ClutterPaintNode    *node,
                                 ClutterPaintContext *paint_context)
 {
 }
@@ -200,41 +196,26 @@ clutter_effect_real_modify_paint_volume (ClutterEffect      *effect,
   return TRUE;
 }
 
-static void
-clutter_effect_real_paint_node (ClutterEffect           *effect,
-                                ClutterPaintNode        *node,
-                                ClutterPaintContext     *paint_context,
-                                ClutterEffectPaintFlags  flags)
-{
-  ClutterPaintNode *actor_node;
-  ClutterActor *actor;
-
-  actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
-
-  actor_node = clutter_actor_node_new (actor, -1);
-  clutter_paint_node_add_child (node, actor_node);
-  clutter_paint_node_unref (actor_node);
-}
-
 static void
 clutter_effect_real_paint (ClutterEffect           *effect,
-                           ClutterPaintNode        *node,
                            ClutterPaintContext     *paint_context,
                            ClutterEffectPaintFlags  flags)
 {
-  ClutterEffectClass *effect_class = CLUTTER_EFFECT_GET_CLASS (effect);
+  ClutterActorMeta *actor_meta = CLUTTER_ACTOR_META (effect);
+  ClutterActor *actor;
   gboolean pre_paint_succeeded;
 
   /* The default implementation provides a compatibility wrapper for
      effects that haven't migrated to use the 'paint' virtual yet. This
      just calls the old pre and post virtuals before chaining on */
 
-  pre_paint_succeeded = effect_class->pre_paint (effect, node,paint_context);
+  pre_paint_succeeded = _clutter_effect_pre_paint (effect, paint_context);
 
-  effect_class->paint_node (effect, node, paint_context, flags);
+  actor = clutter_actor_meta_get_actor (actor_meta);
+  clutter_actor_continue_paint (actor, paint_context);
 
   if (pre_paint_succeeded)
-    effect_class->post_paint (effect, node, paint_context);
+    _clutter_effect_post_paint (effect, paint_context);
 }
 
 static void
@@ -249,32 +230,33 @@ 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;
   klass->modify_paint_volume = clutter_effect_real_modify_paint_volume;
   klass->paint = clutter_effect_real_paint;
-  klass->paint_node = clutter_effect_real_paint_node;
   klass->pick = clutter_effect_real_pick;
 }
 
@@ -283,18 +265,32 @@ clutter_effect_init (ClutterEffect *self)
 {
 }
 
+gboolean
+_clutter_effect_pre_paint (ClutterEffect       *effect,
+                           ClutterPaintContext *paint_context)
+{
+  g_return_val_if_fail (CLUTTER_IS_EFFECT (effect), FALSE);
+
+  return CLUTTER_EFFECT_GET_CLASS (effect)->pre_paint (effect, paint_context);
+}
+
+void
+_clutter_effect_post_paint (ClutterEffect       *effect,
+                            ClutterPaintContext *paint_context)
+{
+  g_return_if_fail (CLUTTER_IS_EFFECT (effect));
+
+  CLUTTER_EFFECT_GET_CLASS (effect)->post_paint (effect, paint_context);
+}
+
 void
 _clutter_effect_paint (ClutterEffect           *effect,
-                       ClutterPaintNode        *node,
                        ClutterPaintContext     *paint_context,
                        ClutterEffectPaintFlags  flags)
 {
   g_return_if_fail (CLUTTER_IS_EFFECT (effect));
 
-  CLUTTER_EFFECT_GET_CLASS (effect)->paint (effect,
-                                            node,
-                                            paint_context,
-                                            flags);
+  CLUTTER_EFFECT_GET_CLASS (effect)->paint (effect, paint_context, flags);
 }
 
 void

clutter/clutter/clutter-effect.h

@@ -77,21 +77,14 @@ struct _ClutterEffectClass
 
   /*< public >*/
   gboolean (* pre_paint)           (ClutterEffect           *effect,
-                                    ClutterPaintNode        *node,
                                     ClutterPaintContext     *paint_context);
   void     (* post_paint)          (ClutterEffect           *effect,
-                                    ClutterPaintNode        *node,
                                     ClutterPaintContext     *paint_context);
 
   gboolean (* modify_paint_volume) (ClutterEffect           *effect,
                                     ClutterPaintVolume      *volume);
 
   void     (* paint)               (ClutterEffect           *effect,
-                                    ClutterPaintNode        *node,
-                                    ClutterPaintContext     *paint_context,
-                                    ClutterEffectPaintFlags  flags);
-  void     (* paint_node)          (ClutterEffect           *effect,
-                                    ClutterPaintNode        *node,
                                     ClutterPaintContext     *paint_context,
                                     ClutterEffectPaintFlags  flags);
   void     (* pick)                (ClutterEffect           *effect,

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">
@@ -538,10 +538,6 @@ typedef enum /*< prefix=CLUTTER_ACTOR >*/
  *   virtual returns %TRUE.
  * @CLUTTER_OFFSCREEN_REDIRECT_ALWAYS: Always redirect the actor to an
  *   offscreen buffer even if it is fully opaque.
- * @CLUTTER_OFFSCREEN_REDIRECT_ON_IDLE: Only redirect the actor if it is the
- *   most efficient thing to do based on its recent repaint behaviour. That
- *   means when its contents are changing less frequently than it's being used
- *   on stage.
  *
  * Possible flags to pass to clutter_actor_set_offscreen_redirect().
  *
@@ -549,11 +545,36 @@ typedef enum /*< prefix=CLUTTER_ACTOR >*/
  */
 typedef enum /*< prefix=CLUTTER_OFFSCREEN_REDIRECT >*/
 {
-  CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY = 1 << 0,
-  CLUTTER_OFFSCREEN_REDIRECT_ALWAYS                = 1 << 1,
-  CLUTTER_OFFSCREEN_REDIRECT_ON_IDLE               = 1 << 2
+  CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY = 1<<0,
+  CLUTTER_OFFSCREEN_REDIRECT_ALWAYS = 1<<1
 } 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
@@ -652,15 +673,12 @@ typedef enum /*< prefix=CLUTTER_BIND >*/
  *   has queued a redraw before this paint. This implies that the effect
  *   should call clutter_actor_continue_paint() to chain to the next
  *   effect and can not cache any results from a previous paint.
- * @CLUTTER_EFFECT_PAINT_BYPASS_EFFECT: The effect should not be used
- *   on this frame, but it will be asked to paint the actor still.
  *
  * Flags passed to the ‘paint’ or ‘pick’ method of #ClutterEffect.
  */
 typedef enum /*< prefix=CLUTTER_EFFECT_PAINT >*/
 {
-  CLUTTER_EFFECT_PAINT_ACTOR_DIRTY   = (1 << 0),
-  CLUTTER_EFFECT_PAINT_BYPASS_EFFECT = (1 << 1)
+  CLUTTER_EFFECT_PAINT_ACTOR_DIRTY = (1 << 0)
 } ClutterEffectPaintFlags;
 
 /**
@@ -1317,6 +1335,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 +1346,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;
 
 /**

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,7 +140,7 @@ clutter_fixed_layout_allocate (ClutterLayoutManager   *manager,
        child != NULL;
        child = clutter_actor_get_next_sibling (child))
     {
-      clutter_actor_allocate_preferred_size (child);
+      clutter_actor_allocate_preferred_size (child, flags);
     }
 }
 

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;

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);
-}

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 */

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 ();
     }

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);
 

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);
     }
 }
 

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__ */

clutter/clutter/clutter-image.c

@@ -130,7 +130,7 @@ clutter_image_paint_content (ClutterContent      *content,
     return;
 
   node = clutter_actor_create_texture_paint_node (actor, priv->texture);
-  clutter_paint_node_set_static_name (node, "Image Content");
+  clutter_paint_node_set_name (node, "Image Content");
   clutter_paint_node_add_child (root, node);
   clutter_paint_node_unref (node);
 }

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;
 }
 
 /**

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

clutter/clutter/clutter-input-focus-private.h

@@ -29,7 +29,7 @@ void clutter_input_focus_focus_out (ClutterInputFocus  *focus);
 void clutter_input_focus_commit (ClutterInputFocus *focus,
                                  const gchar       *text);
 void clutter_input_focus_delete_surrounding (ClutterInputFocus *focus,
-                                             int                offset,
+                                             guint              offset,
                                              guint              len);
 void clutter_input_focus_request_surrounding (ClutterInputFocus *focus);
 

clutter/clutter/clutter-input-focus.c

@@ -217,7 +217,7 @@ clutter_input_focus_commit (ClutterInputFocus *focus,
 
 void
 clutter_input_focus_delete_surrounding (ClutterInputFocus *focus,
-                                        int                offset,
+                                        guint              offset,
                                         guint              len)
 {
   g_return_if_fail (CLUTTER_IS_INPUT_FOCUS (focus));

clutter/clutter/clutter-input-focus.h

@@ -41,7 +41,7 @@ struct _ClutterInputFocusClass
 
   void (* request_surrounding) (ClutterInputFocus *focus);
   void (* delete_surrounding)  (ClutterInputFocus *focus,
-                                int                offset,
+                                guint              offset,
                                 guint              len);
   void (* commit_text) (ClutterInputFocus *focus,
                         const gchar       *text);

clutter/clutter/clutter-input-method.c

@@ -168,7 +168,7 @@ clutter_input_method_class_init (ClutterInputMethodClass *klass)
                   G_TYPE_FROM_CLASS (object_class),
                   G_SIGNAL_RUN_LAST,
                   0, NULL, NULL, NULL,
-                  G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_UINT);
+                  G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);
   signals[REQUEST_SURROUNDING] =
     g_signal_new ("request-surrounding",
                   G_TYPE_FROM_CLASS (object_class),
@@ -292,7 +292,7 @@ clutter_input_method_commit (ClutterInputMethod *im,
 
 void
 clutter_input_method_delete_surrounding (ClutterInputMethod *im,
-                                         int                 offset,
+                                         guint               offset,
                                          guint               len)
 {
   ClutterInputMethodPrivate *priv;

clutter/clutter/clutter-input-method.h

@@ -68,7 +68,7 @@ void clutter_input_method_commit (ClutterInputMethod *im,
                                   const gchar        *text);
 CLUTTER_EXPORT
 void clutter_input_method_delete_surrounding (ClutterInputMethod *im,
-                                              int                 offset,
+                                              guint               offset,
                                               guint               len);
 CLUTTER_EXPORT
 void clutter_input_method_request_surrounding (ClutterInputMethod *im);

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.
  *

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);
 }
 
 /**

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,

clutter/clutter/clutter-main.c

@@ -61,8 +61,8 @@
 #include "clutter-input-pointer-a11y-private.h"
 #include "clutter-graphene.h"
 #include "clutter-main.h"
+#include "clutter-master-clock.h"
 #include "clutter-mutter.h"
-#include "clutter-paint-node-private.h"
 #include "clutter-private.h"
 #include "clutter-settings-private.h"
 #include "clutter-stage-manager.h"
@@ -82,6 +82,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 +144,12 @@ static const GDebugKey clutter_paint_debug_keys[] = {
   { "damage-region", CLUTTER_DEBUG_PAINT_DAMAGE_REGION },
 };
 
+static inline void
+clutter_threads_init_default (void)
+{
+  g_mutex_init (&clutter_threads_mutex);
+}
+
 #define ENVIRONMENT_GROUP       "Environment"
 #define DEBUG_GROUP             "Debug"
 
@@ -508,7 +518,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 +539,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 +770,40 @@ clutter_threads_add_timeout (guint       interval,
                                            NULL);
 }
 
+void
+_clutter_threads_acquire_lock (void)
+{
+  g_mutex_lock (&clutter_threads_mutex);
+}
+
+void
+_clutter_threads_release_lock (void)
+{
+  /* we need to trylock here, in case the lock hasn't been acquired; on
+   * various systems trying to release a mutex that hasn't been acquired
+   * will cause a run-time error. trylock() will either fail, in which
+   * case we can release the lock we own; or it will succeeds, in which
+   * case we need to release the lock we just acquired. so we ignore the
+   * returned value.
+   *
+   * see: https://bugs.gnome.org/679439
+   */
+  g_mutex_trylock (&clutter_threads_mutex);
+  g_mutex_unlock (&clutter_threads_mutex);
+}
+
+void
+_clutter_context_lock (void)
+{
+  G_LOCK (ClutterCntx);
+}
+
+void
+_clutter_context_unlock (void)
+{
+  G_UNLOCK (ClutterCntx);
+}
+
 gboolean
 _clutter_context_is_initialized (void)
 {
@@ -761,8 +813,8 @@ _clutter_context_is_initialized (void)
   return ClutterCntx->is_initialized;
 }
 
-ClutterMainContext *
-_clutter_context_get_default (void)
+static ClutterMainContext *
+clutter_context_get_default_unlocked (void)
 {
   if (G_UNLIKELY (ClutterCntx == NULL))
     {
@@ -793,6 +845,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,
@@ -904,9 +970,6 @@ clutter_init_real (GError **error)
   if (clutter_enable_accessibility)
     cally_accessibility_init ();
 
-  /* Initialize types required for paint nodes */
-  _clutter_paint_node_init_types ();
-
   return CLUTTER_INIT_SUCCESS;
 }
 
@@ -1982,8 +2045,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 +2080,7 @@ _clutter_process_event_details (ClutterActor        *stage,
 
           emit_touch_event (event, device);
 
-          if (event->type == CLUTTER_TOUCH_END ||
-              event->type == CLUTTER_TOUCH_CANCEL)
+          if (event->type == CLUTTER_TOUCH_END)
             _clutter_input_device_remove_event_sequence (device, event);
 
           break;
@@ -2089,6 +2150,27 @@ _clutter_process_event (ClutterEvent *event)
   context->current_event = g_slist_delete_link (context->current_event, context->current_event);
 }
 
+/**
+ * clutter_get_actor_by_gid:
+ * @id_: a #ClutterActor unique id.
+ *
+ * Retrieves the #ClutterActor with @id_.
+ *
+ * Return value: (transfer none): the actor with the passed id or %NULL.
+ *   The returned actor does not have its reference count increased.
+ *
+ * Since: 0.6
+ *
+ * Deprecated: 1.8: The id is deprecated, and this function always returns
+ *   %NULL. Use the proper scene graph API in #ClutterActor to find a child
+ *   of the stage.
+ */
+ClutterActor *
+clutter_get_actor_by_gid (guint32 id_)
+{
+  return NULL;
+}
+
 void
 clutter_base_init (void)
 {
@@ -2103,6 +2185,9 @@ clutter_base_init (void)
       g_type_init ();
 #endif
 
+      /* initialise the Big Clutter Lock™ if necessary */
+      clutter_threads_init_default ();
+
       clutter_graphene_init ();
     }
 }
@@ -2170,7 +2255,9 @@ clutter_threads_remove_repaint_func (guint handle_id)
 
   g_return_if_fail (handle_id > 0);
 
-  context = _clutter_context_get_default ();
+  _clutter_context_lock ();
+
+  context = clutter_context_get_default_unlocked ();
   l = context->repaint_funcs;
   while (l != NULL)
     {
@@ -2193,6 +2280,8 @@ clutter_threads_remove_repaint_func (guint handle_id)
 
       l = l->next;
     }
+
+  _clutter_context_unlock ();
 }
 
 /**
@@ -2291,13 +2380,16 @@ clutter_threads_add_repaint_func_full (ClutterRepaintFlags flags,
 
   g_return_val_if_fail (func != NULL, 0);
 
-  context = _clutter_context_get_default ();
+  _clutter_context_lock ();
+
+  context = clutter_context_get_default_unlocked ();
 
   repaint_func = g_slice_new (ClutterRepaintFunction);
 
   repaint_func->id = context->last_repaint_id++;
 
-  repaint_func->flags = flags;
+  /* mask out QUEUE_REDRAW_ON_ADD, since we're going to consume it */
+  repaint_func->flags = flags & ~CLUTTER_REPAINT_FLAGS_QUEUE_REDRAW_ON_ADD;
   repaint_func->func = func;
   repaint_func->data = data;
   repaint_func->notify = notify;
@@ -2305,6 +2397,15 @@ clutter_threads_add_repaint_func_full (ClutterRepaintFlags flags,
   context->repaint_funcs = g_list_prepend (context->repaint_funcs,
                                            repaint_func);
 
+  _clutter_context_unlock ();
+
+  if ((flags & CLUTTER_REPAINT_FLAGS_QUEUE_REDRAW_ON_ADD) != 0)
+    {
+      ClutterMasterClock *master_clock = _clutter_master_clock_get_default ();
+
+      _clutter_master_clock_ensure_next_iteration (master_clock);
+    }
+
   return repaint_func->id;
 }
 

clutter/clutter/clutter-master-clock-default.c

@@ -0,0 +1,612 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By: Emmanuele Bassi <ebassi@linux.intel.com>
+ *
+ * Copyright (C) 2009  Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * SECTION:clutter-master-clock-default
+ * @short_description: The default master clock for all animations
+ *
+ * The #ClutterMasterClockDefault class is the default implementation
+ * of #ClutterMasterClock.
+ */
+
+#include "clutter-build-config.h"
+
+#include "clutter-master-clock.h"
+#include "clutter-master-clock-default.h"
+#include "clutter-debug.h"
+#include "clutter-private.h"
+#include "clutter-stage-manager-private.h"
+#include "clutter-stage-private.h"
+
+#ifdef CLUTTER_ENABLE_DEBUG
+#define clutter_warn_if_over_budget(master_clock,start_time,section)    G_STMT_START  { \
+  gint64 __delta = g_get_monotonic_time () - start_time;                                \
+  gint64 __budget = master_clock->remaining_budget;                                     \
+  if (__budget > 0 && __delta >= __budget) {                                            \
+    _clutter_diagnostic_message ("%s took %" G_GINT64_FORMAT " microseconds "           \
+                                 "more than the remaining budget of %" G_GINT64_FORMAT  \
+                                 " microseconds",                                       \
+                                 section, __delta - __budget, __budget);                \
+  }                                                                     } G_STMT_END
+#else
+#define clutter_warn_if_over_budget(master_clock,start_time,section)
+#endif
+
+typedef struct _ClutterClockSource              ClutterClockSource;
+
+struct _ClutterMasterClockDefault
+{
+  GObject parent_instance;
+
+  /* the list of timelines handled by the clock */
+  GSList *timelines;
+
+  /* the current state of the clock, in usecs */
+  gint64 cur_tick;
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  gint64 frame_budget;
+  gint64 remaining_budget;
+#endif
+
+  /* an idle source, used by the Master Clock to queue
+   * a redraw on the stage and drive the animations
+   */
+  GSource *source;
+
+  guint ensure_next_iteration : 1;
+
+  guint paused : 1;
+};
+
+struct _ClutterClockSource
+{
+  GSource source;
+
+  ClutterMasterClockDefault *master_clock;
+};
+
+static gboolean clutter_clock_prepare  (GSource     *source,
+                                        gint        *timeout);
+static gboolean clutter_clock_check    (GSource     *source);
+static gboolean clutter_clock_dispatch (GSource     *source,
+                                        GSourceFunc  callback,
+                                        gpointer     user_data);
+
+static GSourceFuncs clock_funcs = {
+  clutter_clock_prepare,
+  clutter_clock_check,
+  clutter_clock_dispatch,
+  NULL
+};
+
+static void
+clutter_master_clock_iface_init (ClutterMasterClockInterface *iface);
+
+#define clutter_master_clock_default_get_type   _clutter_master_clock_default_get_type
+
+G_DEFINE_TYPE_WITH_CODE (ClutterMasterClockDefault,
+                         clutter_master_clock_default,
+                         G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_MASTER_CLOCK,
+                                                clutter_master_clock_iface_init));
+
+/*
+ * master_clock_is_running:
+ * @master_clock: a #ClutterMasterClock
+ *
+ * Checks if we should currently be advancing timelines or redrawing
+ * stages.
+ *
+ * Return value: %TRUE if the #ClutterMasterClock has at least
+ *   one running timeline
+ */
+static gboolean
+master_clock_is_running (ClutterMasterClockDefault *master_clock)
+{
+  ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+  const GSList *stages, *l;
+
+  stages = clutter_stage_manager_peek_stages (stage_manager);
+
+  if (master_clock->paused)
+    return FALSE;
+
+  if (master_clock->timelines)
+    return TRUE;
+
+  for (l = stages; l; l = l->next)
+    {
+      if (clutter_actor_is_mapped (l->data) &&
+          (_clutter_stage_has_queued_events (l->data) ||
+           _clutter_stage_needs_update (l->data)))
+        return TRUE;
+    }
+
+  if (master_clock->ensure_next_iteration)
+    {
+      master_clock->ensure_next_iteration = FALSE;
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gint
+master_clock_get_swap_wait_time (ClutterMasterClockDefault *master_clock)
+{
+  ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+  const GSList *stages, *l;
+  gint64 min_update_time = -1;
+
+  stages = clutter_stage_manager_peek_stages (stage_manager);
+
+  for (l = stages; l != NULL; l = l->next)
+    {
+      gint64 update_time = _clutter_stage_get_update_time (l->data);
+      if (min_update_time == -1 ||
+          (update_time != -1 && update_time < min_update_time))
+        min_update_time = update_time;
+    }
+
+  if (min_update_time == -1)
+    {
+      return -1;
+    }
+  else
+    {
+      gint64 now = g_source_get_time (master_clock->source);
+      if (min_update_time < now)
+        {
+          return 0;
+        }
+      else
+        {
+          gint64 delay_us = min_update_time - now;
+          return (delay_us + 999) / 1000;
+        }
+    }
+}
+
+static void
+master_clock_schedule_stage_updates (ClutterMasterClockDefault *master_clock)
+{
+  ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+  const GSList *stages, *l;
+
+  stages = clutter_stage_manager_peek_stages (stage_manager);
+
+  for (l = stages; l != NULL; l = l->next)
+    _clutter_stage_schedule_update (l->data);
+}
+
+static GSList *
+master_clock_list_ready_stages (ClutterMasterClockDefault *master_clock)
+{
+  ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+  const GSList *stages, *l;
+  GSList *result;
+
+  stages = clutter_stage_manager_peek_stages (stage_manager);
+
+  result = NULL;
+  for (l = stages; l != NULL; l = l->next)
+    {
+      gint64 update_time = _clutter_stage_get_update_time (l->data);
+      /* We carefully avoid to update stages that aren't mapped, because
+       * they have nothing to render and this could cause a deadlock with
+       * some of the SwapBuffers implementations (in particular
+       * GLX_INTEL_swap_event is not emitted if nothing was rendered).
+       *
+       * Also, if a stage has a swap-buffers pending we don't want to draw
+       * to it in case the driver may block the CPU while it waits for the
+       * next backbuffer to become available.
+       *
+       * TODO: We should be able to identify if we are running triple or N
+       * buffered and in these cases we can still draw if there is 1 swap
+       * pending so we can hopefully always be ready to swap for the next
+       * vblank and really match the vsync frequency.
+       */
+      if (clutter_actor_is_mapped (l->data) &&
+          update_time != -1 && update_time <= master_clock->cur_tick)
+        result = g_slist_prepend (result, g_object_ref (l->data));
+    }
+
+  return g_slist_reverse (result);
+}
+
+static void
+master_clock_reschedule_stage_updates (ClutterMasterClockDefault *master_clock,
+                                       GSList                    *stages)
+{
+  const GSList *l;
+
+  for (l = stages; l != NULL; l = l->next)
+    {
+      /* Clear the old update time */
+      _clutter_stage_clear_update_time (l->data);
+
+      /* And if there is still work to be done, schedule a new one */
+      if (master_clock->timelines ||
+          _clutter_stage_has_queued_events (l->data) ||
+          _clutter_stage_needs_update (l->data))
+        _clutter_stage_schedule_update (l->data);
+    }
+}
+
+/*
+ * master_clock_next_frame_delay:
+ * @master_clock: a #ClutterMasterClock
+ *
+ * Computes the number of delay before we need to draw the next frame.
+ *
+ * Return value: -1 if there is no next frame pending, otherwise the
+ *  number of millseconds before the we need to draw the next frame
+ */
+static gint
+master_clock_next_frame_delay (ClutterMasterClockDefault *master_clock)
+{
+  if (!master_clock_is_running (master_clock))
+    return -1;
+
+  /* If all of the stages are busy waiting for a swap-buffers to complete
+   * then we wait for one to be ready.. */
+  return master_clock_get_swap_wait_time (master_clock);
+}
+
+static void
+master_clock_process_events (ClutterMasterClockDefault *master_clock,
+                             GSList                    *stages)
+{
+  GSList *l;
+#ifdef CLUTTER_ENABLE_DEBUG
+  gint64 start = g_get_monotonic_time ();
+#endif
+
+  /* Process queued events */
+  for (l = stages; l != NULL; l = l->next)
+    _clutter_stage_process_queued_events (l->data);
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  if (_clutter_diagnostic_enabled ())
+    clutter_warn_if_over_budget (master_clock, start, "Event processing");
+
+  master_clock->remaining_budget -= (g_get_monotonic_time () - start);
+#endif
+}
+
+/*
+ * master_clock_advance_timelines:
+ * @master_clock: a #ClutterMasterClock
+ *
+ * Advances all the timelines held by the master clock. This function
+ * should be called before calling _clutter_stage_do_update() to
+ * make sure that all the timelines are advanced and the scene is updated.
+ */
+static void
+master_clock_advance_timelines (ClutterMasterClockDefault *master_clock)
+{
+  GSList *timelines, *l;
+#ifdef CLUTTER_ENABLE_DEBUG
+  gint64 start = g_get_monotonic_time ();
+#endif
+
+  /* we protect ourselves from timelines being removed during
+   * the advancement by other timelines by copying the list of
+   * timelines, taking a reference on them, iterating over the
+   * copied list and then releasing the reference.
+   *
+   * we cannot simply take a reference on the timelines and still
+   * use the list held by the master clock because the do_tick()
+   * might result in the creation of a new timeline, which gets
+   * added at the end of the list with no reference increase and
+   * thus gets disposed at the end of the iteration.
+   *
+   * this implies that a newly added timeline will not be advanced
+   * by this clock iteration, which is perfectly fine since we're
+   * in its first cycle.
+   *
+   * we also cannot steal the master clock timelines list because
+   * a timeline might be removed as the direct result of do_tick()
+   * and remove_timeline() would not find the timeline, failing
+   * and leaving a dangling pointer behind.
+   */
+  timelines = g_slist_copy (master_clock->timelines);
+  g_slist_foreach (timelines, (GFunc) g_object_ref, NULL);
+
+  for (l = timelines; l != NULL; l = l->next)
+    _clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000);
+
+  g_slist_free_full (timelines, g_object_unref);
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  if (_clutter_diagnostic_enabled ())
+    clutter_warn_if_over_budget (master_clock, start, "Animations");
+
+  master_clock->remaining_budget -= (g_get_monotonic_time () - start);
+#endif
+}
+
+static gboolean
+master_clock_update_stages (ClutterMasterClockDefault *master_clock,
+                            GSList                    *stages)
+{
+  gboolean stages_updated = FALSE;
+  GSList *l;
+#ifdef CLUTTER_ENABLE_DEBUG
+  gint64 start = g_get_monotonic_time ();
+#endif
+
+  _clutter_run_repaint_functions (CLUTTER_REPAINT_FLAGS_PRE_PAINT);
+
+  /* Update any stage that needs redraw/relayout after the clock
+   * is advanced.
+   */
+  for (l = stages; l != NULL; l = l->next)
+    stages_updated |= _clutter_stage_do_update (l->data);
+
+  _clutter_run_repaint_functions (CLUTTER_REPAINT_FLAGS_POST_PAINT);
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  if (_clutter_diagnostic_enabled ())
+    clutter_warn_if_over_budget (master_clock, start, "Updating the stage");
+
+  master_clock->remaining_budget -= (g_get_monotonic_time () - start);
+#endif
+
+  return stages_updated;
+}
+
+/*
+ * clutter_clock_source_new:
+ * @master_clock: a #ClutterMasterClock for the source
+ *
+ * The #ClutterClockSource is an idle GSource that will queue a redraw
+ * if @master_clock has at least a running #ClutterTimeline. The redraw
+ * will cause @master_clock to advance all timelines, thus advancing all
+ * animations as well.
+ *
+ * Return value: the newly created #GSource
+ */
+static GSource *
+clutter_clock_source_new (ClutterMasterClockDefault *master_clock)
+{
+  GSource *source = g_source_new (&clock_funcs, sizeof (ClutterClockSource));
+  ClutterClockSource *clock_source = (ClutterClockSource *) source;
+
+  g_source_set_name (source, "Clutter master clock");
+  g_source_set_priority (source, CLUTTER_PRIORITY_REDRAW);
+  g_source_set_can_recurse (source, FALSE);
+  clock_source->master_clock = master_clock;
+
+  return source;
+}
+
+static gboolean
+clutter_clock_prepare (GSource *source,
+                       gint    *timeout)
+{
+  ClutterClockSource *clock_source = (ClutterClockSource *) source;
+  ClutterMasterClockDefault *master_clock = clock_source->master_clock;
+  int delay;
+
+  _clutter_threads_acquire_lock ();
+
+  if (G_UNLIKELY (clutter_paint_debug_flags &
+                  CLUTTER_DEBUG_CONTINUOUS_REDRAW))
+    {
+      ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
+      const GSList *stages, *l;
+
+      stages = clutter_stage_manager_peek_stages (stage_manager);
+
+      /* Queue a full redraw on all of the stages */
+      for (l = stages; l != NULL; l = l->next)
+        clutter_actor_queue_redraw (l->data);
+    }
+
+  delay = master_clock_next_frame_delay (master_clock);
+
+  _clutter_threads_release_lock ();
+
+  *timeout = delay;
+
+  return delay == 0;
+}
+
+static gboolean
+clutter_clock_check (GSource *source)
+{
+  ClutterClockSource *clock_source = (ClutterClockSource *) source;
+  ClutterMasterClockDefault *master_clock = clock_source->master_clock;
+  int delay;
+
+  _clutter_threads_acquire_lock ();
+  delay = master_clock_next_frame_delay (master_clock);
+  _clutter_threads_release_lock ();
+
+  return delay == 0;
+}
+
+static gboolean
+clutter_clock_dispatch (GSource     *source,
+                        GSourceFunc  callback,
+                        gpointer     user_data)
+{
+  ClutterClockSource *clock_source = (ClutterClockSource *) source;
+  ClutterMasterClockDefault *master_clock = clock_source->master_clock;
+  GSList *stages;
+
+  CLUTTER_NOTE (SCHEDULER, "Master clock [tick]");
+
+  _clutter_threads_acquire_lock ();
+
+  /* Get the time to use for this frame */
+  master_clock->cur_tick = g_source_get_time (source);
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  master_clock->remaining_budget = master_clock->frame_budget;
+#endif
+
+  /* We need to protect ourselves against stages being destroyed during
+   * event handling - master_clock_list_ready_stages() returns a
+   * list of referenced that we'll unref afterwards.
+   */
+  stages = master_clock_list_ready_stages (master_clock);
+
+  /* Each frame is split into three separate phases: */
+
+  /* 1. process all the events; each stage goes through its events queue
+   *    and processes each event according to its type, then emits the
+   *    various signals that are associated with the event
+   */
+  master_clock_process_events (master_clock, stages);
+
+  /* 2. advance the timelines */
+  master_clock_advance_timelines (master_clock);
+
+  /* 3. relayout and redraw the stages */
+  master_clock_update_stages (master_clock, stages);
+
+  master_clock_reschedule_stage_updates (master_clock, stages);
+
+  g_slist_free_full (stages, g_object_unref);
+
+  _clutter_threads_release_lock ();
+
+  return TRUE;
+}
+
+static void
+clutter_master_clock_default_finalize (GObject *gobject)
+{
+  ClutterMasterClockDefault *master_clock = CLUTTER_MASTER_CLOCK_DEFAULT (gobject);
+
+  g_slist_free (master_clock->timelines);
+
+  G_OBJECT_CLASS (clutter_master_clock_default_parent_class)->finalize (gobject);
+}
+
+static void
+clutter_master_clock_default_class_init (ClutterMasterClockDefaultClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->finalize = clutter_master_clock_default_finalize;
+}
+
+static void
+clutter_master_clock_default_init (ClutterMasterClockDefault *self)
+{
+  GSource *source;
+
+  source = clutter_clock_source_new (self);
+  self->source = source;
+
+  self->ensure_next_iteration = FALSE;
+  self->paused = FALSE;
+
+#ifdef CLUTTER_ENABLE_DEBUG
+  self->frame_budget = G_USEC_PER_SEC / 60;
+#endif
+
+  g_source_attach (source, NULL);
+}
+
+static void
+clutter_master_clock_default_add_timeline (ClutterMasterClock *clock,
+                                           ClutterTimeline    *timeline)
+{
+  ClutterMasterClockDefault *master_clock = (ClutterMasterClockDefault *) clock;
+  gboolean is_first;
+
+  if (g_slist_find (master_clock->timelines, timeline))
+    return;
+
+  is_first = master_clock->timelines == NULL;
+
+  master_clock->timelines = g_slist_prepend (master_clock->timelines,
+                                             timeline);
+
+  if (is_first)
+    {
+      master_clock_schedule_stage_updates (master_clock);
+      _clutter_master_clock_start_running (clock);
+    }
+}
+
+static void
+clutter_master_clock_default_remove_timeline (ClutterMasterClock *clock,
+                                              ClutterTimeline    *timeline)
+{
+  ClutterMasterClockDefault *master_clock = (ClutterMasterClockDefault *) clock;
+
+  master_clock->timelines = g_slist_remove (master_clock->timelines,
+                                            timeline);
+}
+
+static void
+clutter_master_clock_default_start_running (ClutterMasterClock *master_clock)
+{
+  /* If called from a different thread, we need to wake up the
+   * main loop to start running the timelines
+   */
+  g_main_context_wakeup (NULL);
+}
+
+static void
+clutter_master_clock_default_ensure_next_iteration (ClutterMasterClock *clock)
+{
+  ClutterMasterClockDefault *master_clock = (ClutterMasterClockDefault *) clock;
+
+  master_clock->ensure_next_iteration = TRUE;
+}
+
+static void
+clutter_master_clock_default_set_paused (ClutterMasterClock *clock,
+                                         gboolean            paused)
+{
+  ClutterMasterClockDefault *master_clock = (ClutterMasterClockDefault *) clock;
+
+  if (paused && !master_clock->paused)
+    {
+      g_clear_pointer (&master_clock->source, g_source_destroy);
+    }
+  else if (!paused && master_clock->paused)
+    {
+      master_clock->source = clutter_clock_source_new (master_clock);
+      g_source_attach (master_clock->source, NULL);
+    }
+
+  master_clock->paused = !!paused;
+}
+
+static void
+clutter_master_clock_iface_init (ClutterMasterClockInterface *iface)
+{
+  iface->add_timeline = clutter_master_clock_default_add_timeline;
+  iface->remove_timeline = clutter_master_clock_default_remove_timeline;
+  iface->start_running = clutter_master_clock_default_start_running;
+  iface->ensure_next_iteration = clutter_master_clock_default_ensure_next_iteration;
+  iface->set_paused = clutter_master_clock_default_set_paused;
+}

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__ */

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);
+}

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__ */

clutter/clutter/clutter-mutter.h

@@ -36,13 +36,6 @@
 #include "cogl/clutter-stage-cogl.h"
 #include "clutter/x11/clutter-backend-x11.h"
 
-CLUTTER_EXPORT
-GList * clutter_stage_peek_stage_views (ClutterStage *stage);
-
-CLUTTER_EXPORT
-gboolean clutter_actor_is_effectively_on_stage_view (ClutterActor     *self,
-                                                     ClutterStageView *view);
-
 CLUTTER_EXPORT
 void clutter_set_custom_backend_func (ClutterBackend *(* func) (void));
 
@@ -56,35 +49,17 @@ void clutter_stage_capture_into (ClutterStage          *stage,
                                  uint8_t               *data);
 
 CLUTTER_EXPORT
-void clutter_stage_paint_to_framebuffer (ClutterStage                *stage,
-                                         CoglFramebuffer             *framebuffer,
-                                         const cairo_rectangle_int_t *rect,
-                                         float                        scale,
-                                         ClutterPaintFlag             paint_flags);
+void clutter_stage_freeze_updates (ClutterStage *stage);
 
 CLUTTER_EXPORT
-gboolean clutter_stage_paint_to_buffer (ClutterStage                 *stage,
-                                        const cairo_rectangle_int_t  *rect,
-                                        float                         scale,
-                                        uint8_t                      *data,
-                                        int                           stride,
-                                        CoglPixelFormat               format,
-                                        ClutterPaintFlag              paint_flags,
-                                        GError                      **error);
+void clutter_stage_thaw_updates (ClutterStage *stage);
 
 CLUTTER_EXPORT
-void clutter_stage_clear_stage_views (ClutterStage *stage);
-
-CLUTTER_EXPORT
-void clutter_stage_view_assign_next_scanout (ClutterStageView *stage_view,
-                                             CoglScanout      *scanout);
+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__ */

clutter/clutter/clutter-offscreen-effect.c

@@ -60,30 +60,6 @@
  * #ClutterOffscreenEffectClass.create_texture() virtual function; no chain up
  * to the #ClutterOffscreenEffect implementation is required in this
  * case.
- *
- * ## Paint nodes
- *
- * #ClutterOffscreenEffect is generates the following paint node tree:
- *
- * |[<!-- language="plain" -->
- * Effect
- *  ├─────────┐
- * Layer   Pipeline
- *  │
- * Actor
- * ]|
- *
- * When the actor contents are cached, the generated paint node tree
- * looks like this:
- *
- * |[<!-- language="plain" -->
- * Effect
- *  │
- * Pipeline
- * ]|
- *
- * In both cases, the "Pipeline" node is created with the return value
- * of #ClutterOffscreenEffectClass.create_pipeline().
  */
 
 #include "clutter-build-config.h"
@@ -99,20 +75,20 @@
 #include "clutter-private.h"
 #include "clutter-stage-private.h"
 #include "clutter-paint-context-private.h"
-#include "clutter-paint-node-private.h"
-#include "clutter-paint-nodes.h"
 #include "clutter-paint-volume-private.h"
 #include "clutter-actor-box-private.h"
 
 struct _ClutterOffscreenEffectPrivate
 {
   CoglHandle offscreen;
-  CoglPipeline *pipeline;
+  CoglPipeline *target;
   CoglHandle texture;
 
   ClutterActor *actor;
   ClutterActor *stage;
 
+  graphene_point3d_t position;
+
   int fbo_offset_x;
   int fbo_offset_y;
 
@@ -164,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
@@ -178,29 +154,10 @@ ensure_pipeline_filter_for_scale (ClutterOffscreenEffect *self,
   else
     filter = COGL_PIPELINE_FILTER_LINEAR;
 
-  cogl_pipeline_set_layer_filters (self->priv->pipeline, 0 /* layer_index */,
+  cogl_pipeline_set_layer_filters (self->priv->target, 0 /* layer_index */,
                                    filter, filter);
 }
 
-static CoglPipeline *
-clutter_offscreen_effect_real_create_pipeline (ClutterOffscreenEffect *effect,
-                                               CoglTexture            *texture)
-{
-  ClutterOffscreenEffectPrivate *priv = effect->priv;
-  CoglContext *ctx =
-    clutter_backend_get_cogl_context (clutter_get_default_backend ());
-  CoglPipeline *pipeline;
-  float resource_scale;
-
-  resource_scale = clutter_actor_get_real_resource_scale (priv->actor);
-
-  pipeline = cogl_pipeline_new (ctx);
-  ensure_pipeline_filter_for_scale (effect, resource_scale);
-  cogl_pipeline_set_layer_texture (pipeline, 0, texture);
-
-  return pipeline;
-}
-
 static gboolean
 update_fbo (ClutterEffect *effect,
             int            target_width,
@@ -209,8 +166,6 @@ update_fbo (ClutterEffect *effect,
 {
   ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
   ClutterOffscreenEffectPrivate *priv = self->priv;
-  ClutterOffscreenEffectClass *offscreen_class =
-    CLUTTER_OFFSCREEN_EFFECT_GET_CLASS (effect);
 
   priv->stage = clutter_actor_get_stage (priv->actor);
   if (priv->stage == NULL)
@@ -230,6 +185,15 @@ update_fbo (ClutterEffect *effect,
     return TRUE;
   }
 
+  if (priv->target == NULL)
+    {
+      CoglContext *ctx =
+        clutter_backend_get_cogl_context (clutter_get_default_backend ());
+
+      priv->target = cogl_pipeline_new (ctx);
+      ensure_pipeline_filter_for_scale (self, resource_scale);
+    }
+
   g_clear_pointer (&priv->texture, cogl_object_unref);
   g_clear_pointer (&priv->offscreen, cogl_object_unref);
 
@@ -238,6 +202,8 @@ update_fbo (ClutterEffect *effect,
   if (priv->texture == NULL)
     return FALSE;
 
+  cogl_pipeline_set_layer_texture (priv->target, 0, priv->texture);
+
   priv->target_width = target_width;
   priv->target_height = target_height;
 
@@ -246,7 +212,8 @@ update_fbo (ClutterEffect *effect,
     {
       g_warning ("%s: Unable to create an Offscreen buffer", G_STRLOC);
 
-      cogl_clear_object (&priv->pipeline);
+      cogl_object_unref (priv->target);
+      priv->target = NULL;
 
       priv->target_width = 0;
       priv->target_height = 0;
@@ -254,42 +221,50 @@ update_fbo (ClutterEffect *effect,
       return FALSE;
     }
 
-  cogl_clear_object (&priv->pipeline);
-  priv->pipeline = offscreen_class->create_pipeline (self, priv->texture);
-
   return TRUE;
 }
 
 static gboolean
 clutter_offscreen_effect_pre_paint (ClutterEffect       *effect,
-                                    ClutterPaintNode    *node,
                                     ClutterPaintContext *paint_context)
 {
   ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
   ClutterOffscreenEffectPrivate *priv = self->priv;
   ClutterActorBox raw_box, box;
   ClutterActor *stage;
-  CoglMatrix projection, modelview;
+  CoglMatrix projection, old_modelview, modelview;
   const ClutterPaintVolume *volume;
+  CoglColor transparent;
   gfloat stage_width, stage_height;
   gfloat target_width = -1, target_height = -1;
-  float resource_scale;
-  float ceiled_resource_scale;
+  CoglFramebuffer *framebuffer;
+  gfloat resource_scale;
+  gfloat ceiled_resource_scale;
+  graphene_point3d_t local_offset;
+  gfloat old_viewport[4];
+
+  local_offset = GRAPHENE_POINT3D_INIT (0.0f, 0.0f, 0.0f);
 
   if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
-    goto fail;
+    return FALSE;
 
   if (priv->actor == NULL)
-    goto fail;
+    return FALSE;
 
   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
@@ -325,7 +300,12 @@ clutter_offscreen_effect_pre_paint (ClutterEffect       *effect,
 
   /* First assert that the framebuffer is the right size... */
   if (!update_fbo (effect, target_width, target_height, resource_scale))
-    goto fail;
+    return FALSE;
+
+  framebuffer = clutter_paint_context_get_framebuffer (paint_context);
+  cogl_framebuffer_get_modelview_matrix (framebuffer, &old_modelview);
+
+  clutter_paint_context_push_framebuffer (paint_context, priv->offscreen);
 
   /* We don't want the FBO contents to be transformed. That could waste memory
    * (e.g. during zoom), or result in something that's not rectangular (clipped
@@ -337,6 +317,13 @@ clutter_offscreen_effect_pre_paint (ClutterEffect       *effect,
   clutter_actor_get_transform (priv->stage, &modelview);
   cogl_framebuffer_set_modelview_matrix (priv->offscreen, &modelview);
 
+  /* Save the original viewport for calculating priv->position */
+  _clutter_stage_get_viewport (CLUTTER_STAGE (priv->stage),
+                               &old_viewport[0],
+                               &old_viewport[1],
+                               &old_viewport[2],
+                               &old_viewport[3]);
+
   /* Set up the viewport so that it has the same size as the stage (avoid
    * distortion), but translated to account for the FBO offset...
    */
@@ -350,173 +337,170 @@ clutter_offscreen_effect_pre_paint (ClutterEffect       *effect,
   _clutter_stage_get_projection_matrix (CLUTTER_STAGE (priv->stage),
                                         &projection);
 
+  /* Now save the global position of the effect (not just of the actor).
+   * It doesn't appear anyone actually uses this yet, but get_target_rect is
+   * documented as returning it. So we should...
+   */
+  _clutter_util_fully_transform_vertices (&old_modelview,
+                                          &projection,
+                                          old_viewport,
+                                          &local_offset,
+                                          &priv->position,
+                                          1);
+
   cogl_framebuffer_set_projection_matrix (priv->offscreen, &projection);
 
-  return TRUE;
+  cogl_color_init_from_4ub (&transparent, 0, 0, 0, 0);
+  cogl_framebuffer_clear (priv->offscreen,
+                          COGL_BUFFER_BIT_COLOR |
+                          COGL_BUFFER_BIT_DEPTH,
+                          &transparent);
 
-fail:
-  cogl_clear_object (&priv->offscreen);
-  return FALSE;
+  cogl_framebuffer_push_matrix (priv->offscreen);
+
+  /* Override the actor's opacity to fully opaque - we paint the offscreen
+   * texture with the actor's paint opacity, so we need to do this to avoid
+   * multiplying the opacity twice.
+   */
+  priv->old_opacity_override =
+    clutter_actor_get_opacity_override (priv->actor);
+  clutter_actor_set_opacity_override (priv->actor, 0xff);
+
+  return TRUE;
 }
 
 static void
 clutter_offscreen_effect_real_paint_target (ClutterOffscreenEffect *effect,
-                                            ClutterPaintNode       *node,
                                             ClutterPaintContext    *paint_context)
 {
   ClutterOffscreenEffectPrivate *priv = effect->priv;
-  ClutterPaintNode *pipeline_node;
+  CoglFramebuffer *framebuffer =
+    clutter_paint_context_get_framebuffer (paint_context);
   guint8 paint_opacity;
 
   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,
                               paint_opacity);
 
-  pipeline_node = clutter_pipeline_node_new (priv->pipeline);
-  clutter_paint_node_set_static_name (pipeline_node,
-                                      "ClutterOffscreenEffect (pipeline)");
-  clutter_paint_node_add_child (node, pipeline_node);
-
   /* At this point we are in stage coordinates translated so if
    * we draw our texture using a textured quad the size of the paint
    * box then we will overlay where the actor would have drawn if it
    * hadn't been redirected offscreen.
    */
-  clutter_paint_node_add_rectangle (pipeline_node,
-                                    &(ClutterActorBox) {
-                                        0.f, 0.f,
-                                        cogl_texture_get_width (priv->texture),
-                                        cogl_texture_get_height (priv->texture),
-                                    });
-
-  clutter_paint_node_unref (pipeline_node);
+  cogl_framebuffer_draw_textured_rectangle (framebuffer,
+                                            priv->target,
+                                            0, 0,
+                                            cogl_texture_get_width (priv->texture),
+                                            cogl_texture_get_height (priv->texture),
+                                            0.0, 0.0,
+                                            1.0, 1.0);
 }
 
 static void
 clutter_offscreen_effect_paint_texture (ClutterOffscreenEffect *effect,
-                                        ClutterPaintNode       *node,
                                         ClutterPaintContext    *paint_context)
 {
   ClutterOffscreenEffectPrivate *priv = effect->priv;
-  CoglMatrix transform;
+  CoglFramebuffer *framebuffer =
+    clutter_paint_context_get_framebuffer (paint_context);
+  CoglMatrix modelview;
   float resource_scale;
 
-  cogl_matrix_init_identity (&transform);
+  cogl_framebuffer_push_matrix (framebuffer);
 
-  resource_scale = clutter_actor_get_resource_scale (priv->actor);
+  /* The current modelview matrix is *almost* perfect already. It's only
+   * missing a correction for the expanded FBO and offset rendering within...
+   */
+  cogl_framebuffer_get_modelview_matrix (framebuffer, &modelview);
 
-  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 (&transform, paint_scale, paint_scale, 1);
+      cogl_matrix_scale (&modelview, paint_scale, paint_scale, 1);
     }
 
-  cogl_matrix_translate (&transform,
+  cogl_matrix_translate (&modelview,
                          priv->fbo_offset_x,
                          priv->fbo_offset_y,
                          0.0f);
-
-  if (!cogl_matrix_is_identity (&transform))
-    {
-      ClutterPaintNode *transform_node;
-
-      transform_node = clutter_transform_node_new (&transform);
-      clutter_paint_node_set_static_name (transform_node,
-                                          "ClutterOffscreenEffect (transform)");
-      clutter_paint_node_add_child (node, transform_node);
-      clutter_paint_node_unref (transform_node);
-
-      node = transform_node;
-    }
+  cogl_framebuffer_set_modelview_matrix (framebuffer, &modelview);
 
   /* paint the target material; this is virtualized for
    * sub-classes that require special hand-holding
    */
-  clutter_offscreen_effect_paint_target (effect, node, paint_context);
+  clutter_offscreen_effect_paint_target (effect, paint_context);
+
+  cogl_framebuffer_pop_matrix (framebuffer);
 }
 
 static void
 clutter_offscreen_effect_post_paint (ClutterEffect       *effect,
-                                     ClutterPaintNode    *node,
                                      ClutterPaintContext *paint_context)
 {
   ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (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;
 
-  clutter_offscreen_effect_paint_texture (self, node, paint_context);
-}
+  /* Restore the previous opacity override */
+  clutter_actor_set_opacity_override (priv->actor, priv->old_opacity_override);
 
-static void
-clutter_offscreen_effect_paint_node (ClutterEffect           *effect,
-                                     ClutterPaintNode        *node,
-                                     ClutterPaintContext     *paint_context,
-                                     ClutterEffectPaintFlags  flags)
-{
-  ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (effect);
-  ClutterOffscreenEffectPrivate *priv = offscreen_effect->priv;
-  ClutterPaintNode *layer_node;
-  ClutterPaintNode *actor_node;
+  framebuffer = clutter_paint_context_get_framebuffer (paint_context);
+  cogl_framebuffer_pop_matrix (framebuffer);
+  clutter_paint_context_pop_framebuffer (paint_context);
 
-  layer_node = clutter_layer_node_new_with_framebuffer (priv->offscreen,
-                                                        priv->pipeline,
-                                                        255);
-  clutter_paint_node_set_static_name (layer_node,
-                                      "ClutterOffscreenEffect (actor offscreen)");
-  clutter_paint_node_add_child (node, layer_node);
-  clutter_paint_node_unref (layer_node);
-
-  actor_node = clutter_actor_node_new (priv->actor, 255);
-  clutter_paint_node_add_child (layer_node, actor_node);
-  clutter_paint_node_unref (actor_node);
+  clutter_offscreen_effect_paint_texture (self, paint_context);
 }
 
 static void
 clutter_offscreen_effect_paint (ClutterEffect           *effect,
-                                ClutterPaintNode        *node,
                                 ClutterPaintContext     *paint_context,
                                 ClutterEffectPaintFlags  flags)
 {
   ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
   ClutterOffscreenEffectPrivate *priv = self->priv;
-  ClutterEffectClass *parent_class =
-    CLUTTER_EFFECT_CLASS (clutter_offscreen_effect_parent_class);
-
-  if (flags & CLUTTER_EFFECT_PAINT_BYPASS_EFFECT)
-    {
-      parent_class->paint_node (effect, node, paint_context, flags);
-      cogl_clear_object (&priv->offscreen);
-      return;
-    }
 
   /* If we've already got a cached image and the actor hasn't been redrawn
    * then we can just use the cached image in the FBO.
    */
   if (priv->offscreen == NULL || (flags & CLUTTER_EFFECT_PAINT_ACTOR_DIRTY))
-    parent_class->paint (effect, node, paint_context, flags);
+    {
+      ClutterEffectClass *effect_class = CLUTTER_EFFECT_GET_CLASS (effect);
+      gboolean pre_paint_succeeded;
+
+      pre_paint_succeeded = effect_class->pre_paint (effect, paint_context);
+
+      clutter_actor_continue_paint (priv->actor, paint_context);
+
+      if (pre_paint_succeeded)
+        effect_class->post_paint (effect, paint_context);
+      else
+        g_clear_pointer (&priv->offscreen, cogl_object_unref);
+    }
   else
-    clutter_offscreen_effect_paint_texture (self, node, paint_context);
+    clutter_offscreen_effect_paint_texture (self, paint_context);
 }
 
 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
@@ -527,7 +511,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);
 }
@@ -540,18 +524,16 @@ clutter_offscreen_effect_class_init (ClutterOffscreenEffectClass *klass)
   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 
   klass->create_texture = clutter_offscreen_effect_real_create_texture;
-  klass->create_pipeline = clutter_offscreen_effect_real_create_pipeline;
   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;
-  effect_class->paint_node = clutter_offscreen_effect_paint_node;
 
   gobject_class->finalize = clutter_offscreen_effect_finalize;
+  gobject_class->notify = clutter_offscreen_effect_notify;
 }
 
 static void
@@ -590,34 +572,33 @@ clutter_offscreen_effect_get_texture (ClutterOffscreenEffect *effect)
 }
 
 /**
- * clutter_offscreen_effect_get_pipeline:
+ * clutter_offscreen_effect_get_target: (skip)
  * @effect: a #ClutterOffscreenEffect
  *
- * Retrieves the pipeline used as a render target for the offscreen
+ * Retrieves the material used as a render target for the offscreen
  * buffer created by @effect
  *
- * You should only use the returned #CoglPipeline when painting. The
- * returned pipeline might change between different frames.
+ * You should only use the returned #CoglMaterial when painting. The
+ * returned material might change between different frames.
  *
- * Return value: (transfer none)(nullable): a #CoglPipeline. The
- *   pipeline is owned by Clutter and it should not be modified
- *   or freed
+ * Return value: (transfer none): a #CoglMaterial or %NULL. The
+ *   returned material is owned by Clutter and it should not be
+ *   modified or freed
  *
  * Since: 1.4
  */
-CoglPipeline *
-clutter_offscreen_effect_get_pipeline (ClutterOffscreenEffect *effect)
+CoglMaterial *
+clutter_offscreen_effect_get_target (ClutterOffscreenEffect *effect)
 {
   g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect),
                         NULL);
 
-  return effect->priv->pipeline;
+  return (CoglMaterial *)effect->priv->target;
 }
 
 /**
  * clutter_offscreen_effect_paint_target:
  * @effect: a #ClutterOffscreenEffect
- * @node: a #ClutterPaintNode
  * @paint_context: a #ClutterPaintContext
  *
  * Calls the paint_target() virtual function of the @effect
@@ -626,13 +607,11 @@ clutter_offscreen_effect_get_pipeline (ClutterOffscreenEffect *effect)
  */
 void
 clutter_offscreen_effect_paint_target (ClutterOffscreenEffect *effect,
-                                       ClutterPaintNode       *node,
                                        ClutterPaintContext    *paint_context)
 {
   g_return_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect));
 
   CLUTTER_OFFSCREEN_EFFECT_GET_CLASS (effect)->paint_target (effect,
-                                                             node,
                                                              paint_context);
 }
 
@@ -680,6 +659,8 @@ clutter_offscreen_effect_create_texture (ClutterOffscreenEffect *effect,
  *   and %FALSE otherwise
  *
  * Since: 1.8
+ *
+ * Deprecated: 1.14: Use clutter_offscreen_effect_get_target_rect() instead
  */
 gboolean
 clutter_offscreen_effect_get_target_size (ClutterOffscreenEffect *effect,
@@ -703,3 +684,43 @@ clutter_offscreen_effect_get_target_size (ClutterOffscreenEffect *effect,
 
   return TRUE;
 }
+
+/**
+ * clutter_offscreen_effect_get_target_rect:
+ * @effect: a #ClutterOffscreenEffect
+ * @rect: (out caller-allocates): return location for the target area
+ *
+ * Retrieves the origin and size of the offscreen buffer used by @effect to
+ * paint the actor to which it has been applied.
+ *
+ * This function should only be called by #ClutterOffscreenEffect
+ * implementations, from within the #ClutterOffscreenEffectClass.paint_target()
+ * virtual function.
+ *
+ * Return value: %TRUE if the offscreen buffer has a valid rectangle,
+ *   and %FALSE otherwise
+ *
+ * Since: 1.14
+ */
+gboolean
+clutter_offscreen_effect_get_target_rect (ClutterOffscreenEffect *effect,
+                                          graphene_rect_t        *rect)
+{
+  ClutterOffscreenEffectPrivate *priv;
+
+  g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect), FALSE);
+  g_return_val_if_fail (rect != NULL, FALSE);
+
+  priv = effect->priv;
+
+  if (priv->texture == NULL)
+    return FALSE;
+
+  graphene_rect_init (rect,
+                      priv->position.x,
+                      priv->position.y,
+                      cogl_texture_get_width (priv->texture),
+                      cogl_texture_get_height (priv->texture));
+
+  return TRUE;
+}

clutter/clutter/clutter-offscreen-effect.h

@@ -79,10 +79,7 @@ struct _ClutterOffscreenEffectClass
   CoglHandle (* create_texture) (ClutterOffscreenEffect *effect,
                                  gfloat                  width,
                                  gfloat                  height);
-  CoglPipeline* (* create_pipeline) (ClutterOffscreenEffect *effect,
-                                     CoglTexture            *texture);
   void       (* paint_target)   (ClutterOffscreenEffect *effect,
-                                 ClutterPaintNode       *node,
                                  ClutterPaintContext    *paint_context);
 
   /*< private >*/
@@ -99,25 +96,28 @@ CLUTTER_EXPORT
 GType clutter_offscreen_effect_get_type (void) G_GNUC_CONST;
 
 CLUTTER_EXPORT
-CoglPipeline *  clutter_offscreen_effect_get_pipeline           (ClutterOffscreenEffect *effect);
+CoglMaterial *  clutter_offscreen_effect_get_target             (ClutterOffscreenEffect *effect);
 
 CLUTTER_EXPORT
 CoglHandle      clutter_offscreen_effect_get_texture            (ClutterOffscreenEffect *effect);
 
 CLUTTER_EXPORT
 void            clutter_offscreen_effect_paint_target           (ClutterOffscreenEffect *effect,
-                                                                 ClutterPaintNode       *node,
                                                                  ClutterPaintContext    *paint_context);
 CLUTTER_EXPORT
 CoglHandle      clutter_offscreen_effect_create_texture         (ClutterOffscreenEffect *effect,
                                                                  gfloat                  width,
                                                                  gfloat                  height);
 
-CLUTTER_EXPORT
+CLUTTER_DEPRECATED_FOR (clutter_offscreen_effect_get_target_rect)
 gboolean        clutter_offscreen_effect_get_target_size        (ClutterOffscreenEffect *effect,
                                                                  gfloat                 *width,
                                                                  gfloat                 *height);
 
+CLUTTER_EXPORT
+gboolean        clutter_offscreen_effect_get_target_rect        (ClutterOffscreenEffect *effect,
+                                                                 graphene_rect_t        *rect);
+
 G_END_DECLS
 
 #endif /* __CLUTTER_OFFSCREEN_EFFECT_H__ */

clutter/clutter/clutter-paint-context-private.h

@@ -20,9 +20,7 @@
 
 #include "clutter-paint-context.h"
 
-ClutterPaintContext * clutter_paint_context_new_for_view (ClutterStageView     *view,
-                                                          const cairo_region_t *redraw_clip,
-                                                          ClutterPaintFlag      paint_flags);
+ClutterPaintContext * clutter_paint_context_new_for_view (ClutterStageView *view);
 
 gboolean clutter_paint_context_is_drawing_off_stage (ClutterPaintContext *paint_context);
 

clutter/clutter/clutter-paint-context.c

@@ -23,13 +23,9 @@ struct _ClutterPaintContext
 {
   grefcount ref_count;
 
-  ClutterPaintFlag paint_flags;
-
   GList *framebuffers;
 
   ClutterStageView *view;
-
-  cairo_region_t *redraw_clip;
 };
 
 G_DEFINE_BOXED_TYPE (ClutterPaintContext, clutter_paint_context,
@@ -37,9 +33,7 @@ G_DEFINE_BOXED_TYPE (ClutterPaintContext, clutter_paint_context,
                      clutter_paint_context_unref)
 
 ClutterPaintContext *
-clutter_paint_context_new_for_view (ClutterStageView     *view,
-                                    const cairo_region_t *redraw_clip,
-                                    ClutterPaintFlag      paint_flags)
+clutter_paint_context_new_for_view (ClutterStageView *view)
 {
   ClutterPaintContext *paint_context;
   CoglFramebuffer *framebuffer;
@@ -47,8 +41,6 @@ clutter_paint_context_new_for_view (ClutterStageView     *view,
   paint_context = g_new0 (ClutterPaintContext, 1);
   g_ref_count_init (&paint_context->ref_count);
   paint_context->view = view;
-  paint_context->redraw_clip = cairo_region_copy (redraw_clip);
-  paint_context->paint_flags = paint_flags;
 
   framebuffer = clutter_stage_view_get_framebuffer (view);
   clutter_paint_context_push_framebuffer (paint_context, framebuffer);
@@ -60,16 +52,12 @@ clutter_paint_context_new_for_view (ClutterStageView     *view,
  * clutter_paint_context_new_for_framebuffer: (skip)
  */
 ClutterPaintContext *
-clutter_paint_context_new_for_framebuffer (CoglFramebuffer      *framebuffer,
-                                           const cairo_region_t *redraw_clip,
-                                           ClutterPaintFlag      paint_flags)
+clutter_paint_context_new_for_framebuffer (CoglFramebuffer *framebuffer)
 {
   ClutterPaintContext *paint_context;
 
   paint_context = g_new0 (ClutterPaintContext, 1);
   g_ref_count_init (&paint_context->ref_count);
-  paint_context->redraw_clip = cairo_region_copy (redraw_clip);
-  paint_context->paint_flags = paint_flags;
 
   clutter_paint_context_push_framebuffer (paint_context, framebuffer);
 
@@ -89,7 +77,6 @@ clutter_paint_context_dispose (ClutterPaintContext *paint_context)
   g_list_free_full (paint_context->framebuffers,
                     cogl_object_unref);
   paint_context->framebuffers = NULL;
-  g_clear_pointer (&paint_context->redraw_clip, cairo_region_destroy);
 }
 
 void
@@ -128,12 +115,6 @@ clutter_paint_context_pop_framebuffer (ClutterPaintContext *paint_context)
                         paint_context->framebuffers);
 }
 
-const cairo_region_t *
-clutter_paint_context_get_redraw_clip (ClutterPaintContext *paint_context)
-{
-  return paint_context->redraw_clip;
-}
-
 /**
  * clutter_paint_context_get_framebuffer:
  * @paint_context: The #ClutterPaintContext
@@ -178,12 +159,3 @@ clutter_paint_context_is_drawing_off_stage (ClutterPaintContext *paint_context)
 
   return !paint_context->view;
 }
-
-/**
- * clutter_paint_context_get_paint_flags: (skip)
- */
-ClutterPaintFlag
-clutter_paint_context_get_paint_flags (ClutterPaintContext *paint_context)
-{
-  return paint_context->paint_flags;
-}

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);
@@ -67,10 +59,4 @@ void clutter_paint_context_push_framebuffer (ClutterPaintContext *paint_context,
 CLUTTER_EXPORT
 void clutter_paint_context_pop_framebuffer (ClutterPaintContext *paint_context);
 
-CLUTTER_EXPORT
-const cairo_region_t * clutter_paint_context_get_redraw_clip (ClutterPaintContext *paint_context);
-
-CLUTTER_EXPORT
-ClutterPaintFlag clutter_paint_context_get_paint_flags (ClutterPaintContext *paint_context);
-
 #endif /* CLUTTER_PAINT_CONTEXT_H */

clutter/clutter/clutter-paint-node-private.h

@@ -49,11 +49,11 @@ struct _ClutterPaintNode
   ClutterPaintNode *next_sibling;
   ClutterPaintNode *last_child;
 
+  guint n_children;
+
   GArray *operations;
 
-  const gchar *name;
-
-  guint n_children;
+  gchar *name;
 
   volatile int ref_count;
 };
@@ -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;
 };
@@ -141,26 +144,6 @@ ClutterPaintNode *      clutter_paint_node_get_last_child               (Clutter
 G_GNUC_INTERNAL
 ClutterPaintNode *      clutter_paint_node_get_parent                   (ClutterPaintNode      *node);
 
-
-#define CLUTTER_TYPE_EFFECT_NODE                (clutter_effect_node_get_type ())
-#define CLUTTER_EFFECT_NODE(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_EFFECT_NODE, ClutterEffectNode))
-#define CLUTTER_IS_EFFECT_NODE(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_EFFECT_NODE))
-
-/**
- * ClutterEffectNode:
- *
- * The #ClutterEffectNode structure is an opaque
- * type whose members cannot be directly accessed.
- */
-typedef struct _ClutterEffectNode ClutterEffectNode;
-typedef struct _ClutterEffectNode ClutterEffectNodeClass;
-
-CLUTTER_EXPORT
-GType clutter_effect_node_get_type (void) G_GNUC_CONST;
-
-CLUTTER_EXPORT
-ClutterPaintNode * clutter_effect_node_new (ClutterEffect *actor);
-
 G_END_DECLS
 
 #endif /* __CLUTTER_PAINT_NODE_PRIVATE_H__ */

clutter/clutter/clutter-paint-node.c

@@ -171,6 +171,8 @@ clutter_paint_node_real_finalize (ClutterPaintNode *node)
 {
   ClutterPaintNode *iter;
 
+  g_free (node->name);
+
   if (node->operations != NULL)
     {
       guint i;
@@ -295,8 +297,7 @@ clutter_paint_node_get_type (void)
  *
  * The @name will be used for debugging purposes.
  *
- * The @node will intern @name using g_intern_string(). If you have access to a
- * static string, use clutter_paint_node_set_static_name() instead.
+ * The @node will copy the passed string.
  *
  * Since: 1.10
  */
@@ -306,22 +307,8 @@ clutter_paint_node_set_name (ClutterPaintNode *node,
 {
   g_return_if_fail (CLUTTER_IS_PAINT_NODE (node));
 
-  node->name = g_intern_string (name);
-}
-
-/**
- * clutter_paint_node_set_static_name: (skip)
- *
- * Like clutter_paint_node_set_name() but uses a static or interned string
- * containing the name.
- */
-void
-clutter_paint_node_set_static_name (ClutterPaintNode *node,
-                                    const char       *name)
-{
-  g_return_if_fail (CLUTTER_IS_PAINT_NODE (node));
-
-  node->name = name;
+  g_free (node->name);
+  node->name = g_strdup (name);
 }
 
 /**
@@ -782,6 +769,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 +823,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 +937,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 +1101,11 @@ clutter_paint_node_to_json (ClutterPaintNode *node)
               json_builder_end_array (builder);
               break;
 
+            case PAINT_OP_PATH:
+              json_builder_set_member_name (builder, "path");
+              json_builder_add_int_value (builder, (intptr_t) op->op.path);
+              break;
+
             case PAINT_OP_PRIMITIVE:
               json_builder_set_member_name (builder, "primitive");
               json_builder_add_int_value (builder, (intptr_t) op->op.primitive);
@@ -1146,6 +1181,8 @@ _clutter_paint_node_create (GType gtype)
 {
   g_return_val_if_fail (g_type_is_a (gtype, CLUTTER_TYPE_PAINT_NODE), NULL);
 
+  _clutter_paint_node_init_types ();
+
   return (gpointer) g_type_create_instance (gtype);
 }
 

clutter/clutter/clutter-paint-node.h

@@ -56,9 +56,6 @@ void                    clutter_paint_node_paint                        (Clutter
 CLUTTER_EXPORT
 void                    clutter_paint_node_set_name                     (ClutterPaintNode      *node,
                                                                          const char            *name);
-CLUTTER_EXPORT
-void                    clutter_paint_node_set_static_name              (ClutterPaintNode      *node,
-                                                                         const char            *name);
 
 CLUTTER_EXPORT
 CoglFramebuffer *       clutter_paint_node_get_framebuffer              (ClutterPaintNode      *node);
@@ -84,6 +81,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);
 

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,
@@ -551,7 +555,7 @@ clutter_pipeline_node_init (ClutterPipelineNode *self)
 }
 
 /**
- * clutter_pipeline_node_new:
+ * clutter_pipeline_node_new: (skip)
  * @pipeline: (allow-none): a Cogl pipeline state object, or %NULL
  *
  * Creates a new #ClutterPaintNode that will use the @pipeline to
@@ -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;
@@ -1115,8 +1126,6 @@ struct _ClutterActorNode
   ClutterPaintNode parent_instance;
 
   ClutterActor *actor;
-  int opacity_override;
-  int old_opacity_override;
 };
 
 struct _ClutterActorNodeClass
@@ -1132,14 +1141,6 @@ clutter_actor_node_pre_draw (ClutterPaintNode    *node,
 {
   ClutterActorNode *actor_node = CLUTTER_ACTOR_NODE (node);
 
-  if (actor_node->opacity_override != -1)
-    {
-      actor_node->old_opacity_override =
-        clutter_actor_get_opacity_override (actor_node->actor);
-      clutter_actor_set_opacity_override (actor_node->actor,
-                                          actor_node->opacity_override);
-    }
-
   CLUTTER_SET_PRIVATE_FLAGS (actor_node->actor, CLUTTER_IN_PAINT);
 
   return TRUE;
@@ -1161,12 +1162,6 @@ clutter_actor_node_post_draw (ClutterPaintNode    *node,
   ClutterActorNode *actor_node = CLUTTER_ACTOR_NODE (node);
 
   CLUTTER_UNSET_PRIVATE_FLAGS (actor_node->actor, CLUTTER_IN_PAINT);
-
- if (actor_node->opacity_override != -1)
-    {
-      clutter_actor_set_opacity_override (actor_node->actor,
-                                          actor_node->old_opacity_override);
-    }
 }
 
 static JsonNode *
@@ -1208,7 +1203,6 @@ clutter_actor_node_init (ClutterActorNode *self)
 /*
  * clutter_actor_node_new:
  * @actor: the actor to paint
- * @opacity: opacity to draw the actor with, or -1 to use the actor's opacity
  *
  * Creates a new #ClutterActorNode.
  *
@@ -1220,8 +1214,7 @@ clutter_actor_node_init (ClutterActorNode *self)
  *   Use clutter_paint_node_unref() when done.
  */
 ClutterPaintNode *
-clutter_actor_node_new (ClutterActor *actor,
-                        int           opacity)
+clutter_actor_node_new (ClutterActor *actor)
 {
   ClutterActorNode *res;
 
@@ -1229,96 +1222,11 @@ clutter_actor_node_new (ClutterActor *actor,
 
   res = _clutter_paint_node_create (CLUTTER_TYPE_ACTOR_NODE);
   res->actor = actor;
-  res->opacity_override = CLAMP (opacity, -1, 255);
 
   return (ClutterPaintNode *) res;
 }
 
 
-/*
- * ClutterEffectNode
- */
-
-struct _ClutterEffectNode
-{
-  ClutterPaintNode parent_instance;
-
-  ClutterEffect *effect;
-};
-
-struct _ClutterEffectNodeClass
-{
-  ClutterPaintNodeClass parent_class;
-};
-
-G_DEFINE_TYPE (ClutterEffectNode, clutter_effect_node, CLUTTER_TYPE_PAINT_NODE)
-
-static JsonNode *
-clutter_effect_node_serialize (ClutterPaintNode *node)
-{
-  ClutterEffectNode *effect_node = CLUTTER_EFFECT_NODE (node);
-  ClutterActorMeta *effect_meta = CLUTTER_ACTOR_META (effect_node->effect);
-  g_autoptr (JsonBuilder) builder = NULL;
-  g_autoptr (GString) string = NULL;
-  const char *meta_name;
-
-  meta_name = clutter_actor_meta_get_name (effect_meta);
-
-  string = g_string_new (NULL);
-  g_string_append (string, G_OBJECT_TYPE_NAME (effect_node->effect));
-  g_string_append (string, " (");
-  if (meta_name)
-    g_string_append_printf (string, "\"%s\"", meta_name);
-  else
-    g_string_append (string, "unnamed");
-  g_string_append (string, ")");
-
-  builder = json_builder_new ();
-
-  json_builder_begin_object (builder);
-  json_builder_set_member_name (builder, "effect");
-  json_builder_add_string_value (builder, string->str);
-  json_builder_end_object (builder);
-
-  return json_builder_get_root (builder);
-}
-
-static void
-clutter_effect_node_class_init (ClutterEffectNodeClass *klass)
-{
-  ClutterPaintNodeClass *node_class;
-
-  node_class = CLUTTER_PAINT_NODE_CLASS (klass);
-  node_class->serialize = clutter_effect_node_serialize;
-}
-
-static void
-clutter_effect_node_init (ClutterEffectNode *self)
-{
-}
-
-/*
- * clutter_effect_node_new:
- * @actor: the actor to paint
- *
- * Creates a new #ClutterEffectNode.
- *
- * Return value: (transfer full): the newly created #ClutterEffectNode.
- *   Use clutter_paint_node_unref() when done.
- */
-ClutterPaintNode *
-clutter_effect_node_new (ClutterEffect *effect)
-{
-  ClutterEffectNode *res;
-
-  g_assert (effect != NULL);
-
-  res = _clutter_paint_node_create (CLUTTER_TYPE_EFFECT_NODE);
-  res->effect = effect;
-
-  return (ClutterPaintNode *) res;
-}
-
 /*
  * ClutterLayerNode
  */
@@ -1334,11 +1242,11 @@ struct _ClutterLayerNode
   float fbo_width;
   float fbo_height;
 
-  CoglPipeline *pipeline;
+  CoglPipeline *state;
   CoglFramebuffer *offscreen;
+  CoglTexture *texture;
 
   guint8 opacity;
-  gboolean update_modelview;
 };
 
 struct _ClutterLayerNodeClass
@@ -1353,6 +1261,8 @@ clutter_layer_node_pre_draw (ClutterPaintNode *node,
                              ClutterPaintContext *paint_context)
 {
   ClutterLayerNode *lnode = (ClutterLayerNode *) node;
+  CoglFramebuffer *framebuffer;
+  CoglMatrix matrix;
 
   /* if we were unable to create an offscreen buffer for this node, then
    * we simply ignore it
@@ -1360,30 +1270,29 @@ clutter_layer_node_pre_draw (ClutterPaintNode *node,
   if (lnode->offscreen == NULL)
     return FALSE;
 
-  if (lnode->update_modelview)
-    {
-      CoglFramebuffer *framebuffer;
-      CoglMatrix matrix;
+  /* if no geometry was submitted for this node then we simply ignore it */
+  if (node->operations == NULL)
+    return FALSE;
 
-      /* copy the same modelview from the current framebuffer to the one we
-       * are going to use
-       */
-      framebuffer = clutter_paint_context_get_framebuffer (paint_context);
-      cogl_framebuffer_get_modelview_matrix (framebuffer, &matrix);
-      cogl_framebuffer_set_modelview_matrix (lnode->offscreen, &matrix);
-
-      cogl_framebuffer_set_viewport (lnode->offscreen,
-                                     lnode->viewport.x,
-                                     lnode->viewport.y,
-                                     lnode->viewport.width,
-                                     lnode->viewport.height);
-
-      cogl_framebuffer_set_projection_matrix (lnode->offscreen,
-                                              &lnode->projection);
-    }
+  /* copy the same modelview from the current framebuffer to the one we
+   * are going to use
+   */
+  framebuffer = clutter_paint_context_get_framebuffer (paint_context);
+  cogl_framebuffer_get_modelview_matrix (framebuffer, &matrix);
 
   clutter_paint_context_push_framebuffer (paint_context, lnode->offscreen);
 
+  cogl_framebuffer_set_modelview_matrix (lnode->offscreen, &matrix);
+
+  cogl_framebuffer_set_viewport (lnode->offscreen,
+                                 lnode->viewport.x,
+                                 lnode->viewport.y,
+                                 lnode->viewport.width,
+                                 lnode->viewport.height);
+
+  cogl_framebuffer_set_projection_matrix (lnode->offscreen,
+                                          &lnode->projection);
+
   /* clear out the target framebuffer */
   cogl_framebuffer_clear4f (lnode->offscreen,
                             COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_DEPTH,
@@ -1410,10 +1319,6 @@ clutter_layer_node_post_draw (ClutterPaintNode    *node,
   cogl_framebuffer_pop_matrix (lnode->offscreen);
   clutter_paint_context_pop_framebuffer (paint_context);
 
-  /* if no geometry was submitted for this node then we simply ignore it */
-  if (node->operations == NULL)
-    return;
-
   fb = clutter_paint_context_get_framebuffer (paint_context);
 
   for (i = 0; i < node->operations->len; i++)
@@ -1429,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],
@@ -1442,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],
@@ -1451,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;
         }
     }
@@ -1465,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);
@@ -1474,25 +1381,6 @@ clutter_layer_node_finalize (ClutterPaintNode *node)
   CLUTTER_PAINT_NODE_CLASS (clutter_layer_node_parent_class)->finalize (node);
 }
 
-static JsonNode *
-clutter_layer_node_serialize (ClutterPaintNode *node)
-{
-  ClutterLayerNode *layer_node = CLUTTER_LAYER_NODE (node);
-  g_autoptr (JsonBuilder) builder = NULL;
-  g_autofree char *framebuffer_ptr = NULL;
-
-  builder = json_builder_new ();
-
-  framebuffer_ptr = g_strdup_printf ("%p", layer_node->offscreen);
-
-  json_builder_begin_object (builder);
-  json_builder_set_member_name (builder, "framebuffer");
-  json_builder_add_string_value (builder, framebuffer_ptr);
-  json_builder_end_object (builder);
-
-  return json_builder_get_root (builder);
-}
-
 static void
 clutter_layer_node_class_init (ClutterLayerNodeClass *klass)
 {
@@ -1502,7 +1390,6 @@ clutter_layer_node_class_init (ClutterLayerNodeClass *klass)
   node_class->pre_draw = clutter_layer_node_pre_draw;
   node_class->post_draw = clutter_layer_node_post_draw;
   node_class->finalize = clutter_layer_node_finalize;
-  node_class->serialize = clutter_layer_node_serialize;
 }
 
 static void
@@ -1538,14 +1425,10 @@ 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);
 
-  res->update_modelview = TRUE;
   res->projection = *projection;
   res->viewport = *viewport;
   res->fbo_width = width;
@@ -1553,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;
     }
 
@@ -1574,257 +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;
 }
-
-/**
- * clutter_layer_node_new_with_framebuffer:
- * @framebuffer: a #CoglFramebuffer
- * @pipeline: a #CoglPipeline
- * @opacity: the opacity to be used when drawing the layer
- *
- * Creates a new #ClutterLayerNode with @framebuffer and
- * @pipeline. @framebuffer will then be painted using the
- * given @opacity.
- *
- * When using this constructor, the caller is responsible
- * for setting up the framebuffer's modelview and projection
- * matrices.
- *
- * Return value: (transfer full)(nullable): the newly created #ClutterLayerNode.
- *   Use clutter_paint_node_unref() when done.
- */
-ClutterPaintNode *
-clutter_layer_node_new_with_framebuffer (CoglFramebuffer *framebuffer,
-                                         CoglPipeline    *pipeline,
-                                         guint8           opacity)
-{
-  ClutterLayerNode *res;
-  CoglColor color;
-
-  g_return_val_if_fail (cogl_is_framebuffer (framebuffer), NULL);
-
-  res = _clutter_paint_node_create (CLUTTER_TYPE_LAYER_NODE);
-
-  res->update_modelview = FALSE;
-  res->offscreen = cogl_object_ref (framebuffer);
-  res->pipeline = cogl_pipeline_copy (pipeline);
-
-  cogl_color_init_from_4ub (&color, opacity, opacity, opacity, opacity);
-  cogl_pipeline_set_color (res->pipeline, &color);
-
-  return (ClutterPaintNode *) res;
-}
-
-/*
- * ClutterBlitNode
- */
-
-struct _ClutterBlitNode
-{
-  ClutterPaintNode parent_instance;
-
-  CoglFramebuffer *source;
-  CoglFramebuffer *dest;
-};
-
-struct _ClutterBlitNodeClass
-{
-  ClutterPaintNodeClass parent_class;
-};
-
-G_DEFINE_TYPE (ClutterBlitNode, clutter_blit_node, CLUTTER_TYPE_PAINT_NODE)
-
-static gboolean
-clutter_blit_node_pre_draw (ClutterPaintNode    *node,
-                            ClutterPaintContext *paint_context)
-{
-  return TRUE;
-}
-
-static void
-clutter_blit_node_draw (ClutterPaintNode    *node,
-                        ClutterPaintContext *paint_context)
-{
-  ClutterBlitNode *blit_node = CLUTTER_BLIT_NODE (node);
-  g_autoptr (GError) error = NULL;
-  CoglFramebuffer *source;
-  guint i;
-
-  if (node->operations == NULL)
-    return;
-
-  source = blit_node->source;
-  if (!source)
-    source = clutter_paint_context_get_framebuffer (paint_context);
-
-  for (i = 0; i < node->operations->len; i++)
-    {
-      const ClutterPaintOperation *op;
-      float op_width, op_height;
-
-      op = &g_array_index (node->operations, ClutterPaintOperation, i);
-
-      switch (op->opcode)
-        {
-        case PAINT_OP_INVALID:
-          break;
-
-        case PAINT_OP_TEX_RECT:
-          op_width = op->op.texrect[6] - op->op.texrect[4];
-          op_height = op->op.texrect[7] - op->op.texrect[5];
-
-          cogl_blit_framebuffer (source,
-                                 blit_node->dest,
-                                 op->op.texrect[0],
-                                 op->op.texrect[1],
-                                 op->op.texrect[4],
-                                 op->op.texrect[5],
-                                 op_width,
-                                 op_height,
-                                 &error);
-
-          if (error)
-            {
-              g_warning ("Error blitting framebuffers: %s", error->message);
-              return;
-            }
-          break;
-
-        case PAINT_OP_MULTITEX_RECT:
-        case PAINT_OP_PRIMITIVE:
-          break;
-        }
-    }
-}
-
-static void
-clutter_blit_node_finalize (ClutterPaintNode *node)
-{
-  ClutterBlitNode *blit_node = CLUTTER_BLIT_NODE (node);
-
-  cogl_clear_object (&blit_node->source);
-  cogl_clear_object (&blit_node->dest);
-
-  CLUTTER_PAINT_NODE_CLASS (clutter_layer_node_parent_class)->finalize (node);
-}
-
-static JsonNode *
-clutter_blit_node_serialize (ClutterPaintNode *node)
-{
-  ClutterBlitNode *blit_node = CLUTTER_BLIT_NODE (node);
-  g_autoptr (JsonBuilder) builder = NULL;
-  g_autofree char *source_ptr = NULL;
-  g_autofree char *dest_ptr = NULL;
-
-  builder = json_builder_new ();
-
-  source_ptr = g_strdup_printf ("%p", blit_node->source);
-  dest_ptr = g_strdup_printf ("%p", blit_node->dest);
-
-  json_builder_begin_object (builder);
-  json_builder_set_member_name (builder, "source");
-  json_builder_add_string_value (builder, source_ptr);
-  json_builder_end_object (builder);
-
-  json_builder_begin_object (builder);
-  json_builder_set_member_name (builder, "dest");
-  json_builder_add_string_value (builder, dest_ptr);
-  json_builder_end_object (builder);
-
-  return json_builder_get_root (builder);
-}
-
-static void
-clutter_blit_node_class_init (ClutterTransformNodeClass *klass)
-{
-  ClutterPaintNodeClass *node_class;
-
-  node_class = CLUTTER_PAINT_NODE_CLASS (klass);
-  node_class->pre_draw = clutter_blit_node_pre_draw;
-  node_class->draw = clutter_blit_node_draw;
-  node_class->finalize = clutter_blit_node_finalize;
-  node_class->serialize = clutter_blit_node_serialize;
-}
-
-static void
-clutter_blit_node_init (ClutterBlitNode *self)
-{
-}
-
-/**
- * clutter_blit_node_new:
- * @source: (nullable): the source #CoglFramebuffer
- * @dest: the destination #CoglFramebuffer
- *
- * Creates a new #ClutterBlitNode that blits @source into @dest.
- *
- * If @source is %NULL, the most recent framebuffer stacked into a
- * #ClutterPaintContext is used.
- *
- * You must only add rectangles using clutter_blit_node_add_blit_rectangle().
- *
- * Return value: (transfer full): the newly created #ClutterBlitNode.
- *   Use clutter_paint_node_unref() when done.
- */
-ClutterPaintNode *
-clutter_blit_node_new (CoglFramebuffer *source,
-                       CoglFramebuffer *dest)
-{
-  ClutterBlitNode *res;
-
-  g_return_val_if_fail (cogl_is_framebuffer (dest), NULL);
-
-  res = _clutter_paint_node_create (CLUTTER_TYPE_BLIT_NODE);
-  res->source = source ? cogl_object_ref (source) : NULL;
-  res->dest = cogl_object_ref (dest);
-
-  return (ClutterPaintNode *) res;
-}
-
-/**
- * clutter_blit_node_add_blit_rectangle:
- * @blit_node: a #ClutterBlitNode
- * @src_x: Source x position
- * @src_y: Source y position
- * @dst_x: Destination x position
- * @dst_y: Destination y position
- * @width: Width of region to copy
- * @height: Height of region to copy
- *
- * Adds a new blit rectangle to the stack of rectangles. All the
- * constraints of cogl_blit_framebuffer() apply here.
- */
-void
-clutter_blit_node_add_blit_rectangle (ClutterBlitNode *blit_node,
-                                      int              src_x,
-                                      int              src_y,
-                                      int              dst_x,
-                                      int              dst_y,
-                                      int              width,
-                                      int              height)
-{
-  g_return_if_fail (CLUTTER_IS_BLIT_NODE (blit_node));
-
-  clutter_paint_node_add_texture_rectangle (CLUTTER_PAINT_NODE (blit_node),
-                                            &(ClutterActorBox) {
-                                              src_x,
-                                              src_y,
-                                              src_x + width,
-                                              src_y + height,
-                                            },
-                                            dst_x,
-                                            dst_y,
-                                            dst_x + width,
-                                            dst_y + height);
-}

clutter/clutter/clutter-paint-nodes.h

@@ -160,8 +160,7 @@ CLUTTER_EXPORT
 GType clutter_actor_node_get_type (void) G_GNUC_CONST;
 
 CLUTTER_EXPORT
-ClutterPaintNode * clutter_actor_node_new (ClutterActor *actor,
-                                           int           opacity);
+ClutterPaintNode * clutter_actor_node_new (ClutterActor *actor);
 
 #define CLUTTER_TYPE_ROOT_NODE                  (clutter_root_node_get_type ())
 #define CLUTTER_ROOT_NODE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ROOT_NODE, ClutterRootNode))
@@ -209,11 +208,6 @@ ClutterPaintNode *      clutter_layer_node_new          (const CoglMatrix
                                                          float                    height,
                                                          guint8                   opacity);
 
-CLUTTER_EXPORT
-ClutterPaintNode * clutter_layer_node_new_with_framebuffer (CoglFramebuffer *framebuffer,
-                                                            CoglPipeline    *pipeline,
-                                                            guint8           opacity);
-
 
 #define CLUTTER_TYPE_TRANSFORM_NODE             (clutter_transform_node_get_type ())
 #define CLUTTER_TRANSFORM_NODE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TRANSFORM_NODE, ClutterTransformNode))
@@ -236,38 +230,6 @@ GType clutter_transform_node_get_type (void) G_GNUC_CONST;
 CLUTTER_EXPORT
 ClutterPaintNode *      clutter_transform_node_new          (const CoglMatrix *projection);
 
-#define CLUTTER_TYPE_BLIT_NODE                  (clutter_blit_node_get_type ())
-#define CLUTTER_BLIT_NODE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_BLIT_NODE, ClutterBlitNode))
-#define CLUTTER_IS_BLIT_NODE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_BLIT_NODE))
-
-/*
- * ClutterBlitNode:
- *
- * The #ClutterLayerNode structure is an opaque
- * type whose members cannot be directly accessed.
- *
- * Since: 1.10
- */
-typedef struct _ClutterBlitNode                 ClutterBlitNode;
-typedef struct _ClutterPaintNodeClass           ClutterBlitNodeClass;
-
-CLUTTER_EXPORT
-GType clutter_blit_node_get_type (void) G_GNUC_CONST;
-
-CLUTTER_EXPORT
-ClutterPaintNode * clutter_blit_node_new (CoglFramebuffer *source,
-                                          CoglFramebuffer *dest);
-
-
-CLUTTER_EXPORT
-void clutter_blit_node_add_blit_rectangle (ClutterBlitNode *blit_node,
-                                           int              src_x,
-                                           int              src_y,
-                                           int              dst_x,
-                                           int              dst_y,
-                                           int              width,
-                                           int              height);
-
 G_END_DECLS
 
 #endif /* __CLUTTER_PAINT_NODES_H__ */

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)
     {

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);
@@ -237,9 +248,6 @@ gboolean _clutter_util_rectangle_intersection (const cairo_rectangle_int_t *src1
                                                const cairo_rectangle_int_t *src2,
                                                cairo_rectangle_int_t       *dest);
 
-gboolean clutter_util_rectangle_equal (const cairo_rectangle_int_t *src1,
-                                       const cairo_rectangle_int_t *src2);
-
 
 struct _ClutterVertex4
 {
@@ -307,30 +315,6 @@ gboolean        _clutter_run_progress_function  (GType gtype,
 
 void            clutter_timeline_cancel_delay (ClutterTimeline *timeline);
 
-static inline uint64_t
-us (uint64_t us)
-{
-  return us;
-}
-
-static inline 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__ */

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

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);

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;

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);

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

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);

clutter/clutter/clutter-seat.c

@@ -41,7 +41,6 @@ enum
   PTR_A11Y_DWELL_CLICK_TYPE_CHANGED,
   PTR_A11Y_TIMEOUT_STARTED,
   PTR_A11Y_TIMEOUT_STOPPED,
-  IS_UNFOCUS_INHIBITED_CHANGED,
   N_SIGNALS,
 };
 
@@ -63,8 +62,6 @@ struct _ClutterSeatPrivate
 {
   ClutterBackend *backend;
 
-  unsigned int inhibit_unfocus_count;
-
   /* Keyboard a11y */
   ClutterKbdA11ySettings kbd_a11y_settings;
 
@@ -278,22 +275,6 @@ clutter_seat_class_init (ClutterSeatClass *klass)
                               G_TYPE_FROM_CLASS (object_class),
                               _clutter_marshal_VOID__OBJECT_FLAGS_BOOLEANv);
 
-  /**
-   * ClutterSeat::is-unfocus-inhibited-changed:
-   * @seat: the #ClutterSeat that emitted the signal
-   *
-   * The ::is-unfocus-inhibited-changed signal is emitted when the
-   * property to inhibit the unsetting of the focus-surface of the
-   * #ClutterSeat changed. To get the current state of this property,
-   * use clutter_seat_is_unfocus_inhibited().
-   */
-  signals[IS_UNFOCUS_INHIBITED_CHANGED] =
-    g_signal_new (I_("is-unfocus-inhibited-changed"),
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0, NULL, NULL, NULL,
-                  G_TYPE_NONE, 0);
-
   props[PROP_BACKEND] =
     g_param_spec_object ("backend",
                          P_("Backend"),
@@ -301,12 +282,6 @@ clutter_seat_class_init (ClutterSeatClass *klass)
                          CLUTTER_TYPE_BACKEND,
                          CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
 
-  /**
-   * ClutterSeat:touch-mode:
-   *
-   * The current touch-mode of the #ClutterSeat, it is set to %TRUE if the
-   * requirements documented in clutter_seat_get_touch_mode() are fulfilled.
-   **/
   props[PROP_TOUCH_MODE] =
     g_param_spec_boolean ("touch-mode",
                           P_("Touch mode"),
@@ -354,17 +329,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 +345,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
@@ -544,85 +508,6 @@ clutter_seat_set_pointer_a11y_dwell_click_type (ClutterSeat
   priv->pointer_a11y_settings.dwell_click_type = click_type;
 }
 
-/**
- * clutter_seat_inhibit_unfocus:
- * @seat: a #ClutterSeat
- *
- * Inhibits unsetting of the pointer focus-surface for the #ClutterSeat @seat,
- * this allows to keep using the pointer even when it's hidden.
- *
- * This property is refcounted, so clutter_seat_uninhibit_unfocus() must be
- * called the exact same number of times as clutter_seat_inhibit_unfocus()
- * was called before.
- **/
-void
-clutter_seat_inhibit_unfocus (ClutterSeat *seat)
-{
-  ClutterSeatPrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_SEAT (seat));
-
-  priv = clutter_seat_get_instance_private (seat);
-
-  priv->inhibit_unfocus_count++;
-
-  if (priv->inhibit_unfocus_count == 1)
-    g_signal_emit (G_OBJECT (seat), signals[IS_UNFOCUS_INHIBITED_CHANGED], 0);
-}
-
-/**
- * clutter_seat_uninhibit_unfocus:
- * @seat: a #ClutterSeat
- *
- * Disables the inhibiting of unsetting of the pointer focus-surface
- * previously enabled by calling clutter_seat_inhibit_unfocus().
- *
- * This property is refcounted, so clutter_seat_uninhibit_unfocus() must be
- * called the exact same number of times as clutter_seat_inhibit_unfocus()
- * was called before.
- **/
-void
-clutter_seat_uninhibit_unfocus (ClutterSeat *seat)
-{
-  ClutterSeatPrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_SEAT (seat));
-
-  priv = clutter_seat_get_instance_private (seat);
-
-  if (priv->inhibit_unfocus_count == 0)
-    {
-      g_warning ("Called clutter_seat_uninhibit_unfocus without inhibiting before");
-      return;
-    }
-
-  priv->inhibit_unfocus_count--;
-
-  if (priv->inhibit_unfocus_count == 0)
-    g_signal_emit (G_OBJECT (seat), signals[IS_UNFOCUS_INHIBITED_CHANGED], 0);
-}
-
-/**
- * clutter_seat_is_unfocus_inhibited:
- * @seat: a #ClutterSeat
- *
- * Gets whether unsetting of the pointer focus-surface is inhibited
- * for the #ClutterSeat @seat.
- *
- * Returns: %TRUE if unsetting is inhibited, %FALSE otherwise
- **/
-gboolean
-clutter_seat_is_unfocus_inhibited (ClutterSeat *seat)
-{
-  ClutterSeatPrivate *priv;
-
-  g_return_val_if_fail (CLUTTER_IS_SEAT (seat), FALSE);
-
-  priv = clutter_seat_get_instance_private (seat);
-
-  return priv->inhibit_unfocus_count > 0;
-}
-
 /**
  * clutter_seat_create_virtual_device:
  * @seat: a #ClutterSeat
@@ -645,8 +530,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)
 {
@@ -684,20 +569,6 @@ clutter_seat_warp_pointer (ClutterSeat *seat,
   CLUTTER_SEAT_GET_CLASS (seat)->warp_pointer (seat, x, y);
 }
 
-/**
- * clutter_seat_get_touch_mode:
- * @seat: a #ClutterSeat
- *
- * Gets the current touch-mode state of the #ClutterSeat @seat.
- * The #ClutterSeat:touch-mode property is set to %TRUE if the following
- * requirements are fulfilled:
- *
- *  - A touchscreen is available
- *  - A tablet mode switch, if present, is enabled
- *
- * Returns: %TRUE if the device is a tablet that doesn't have an external
- *   keyboard attached, %FALSE otherwise.
- **/
 gboolean
 clutter_seat_get_touch_mode (ClutterSeat *seat)
 {

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);
 
@@ -160,16 +159,6 @@ void clutter_seat_get_pointer_a11y_settings (ClutterSeat                *seat,
 CLUTTER_EXPORT
 void clutter_seat_set_pointer_a11y_dwell_click_type (ClutterSeat                      *seat,
                                                      ClutterPointerA11yDwellClickType  click_type);
-
-CLUTTER_EXPORT
-void clutter_seat_inhibit_unfocus (ClutterSeat *seat);
-
-CLUTTER_EXPORT
-void clutter_seat_uninhibit_unfocus (ClutterSeat *seat);
-
-CLUTTER_EXPORT
-gboolean clutter_seat_is_unfocus_inhibited (ClutterSeat *seat);
-
 CLUTTER_EXPORT
 ClutterVirtualInputDevice *clutter_seat_create_virtual_device (ClutterSeat            *seat,
                                                                ClutterInputDeviceType  device_type);