meson: Use sysprof interface defintion from correct prefix

The sysprof interface definition may be installed to a prefix different
from where mutter is going to be installed. Fetch the prefix from
pkgconfig instead.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/993

.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
@@ -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,31 +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:
-    - meson . coverage-build -Dbuildtype=debugoptimized -Db_coverage=true -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
-    - ninja -C coverage-build coverage
-    - cat coverage-build/meson-logs/coverage.txt
-  artifacts:
-    paths:
-      - coverage-build/meson-logs
-  when: manual
-  except:
-    refs:
-      - tags
-      - master
-
 can-build-gnome-shell:
   stage: test
   dependencies:

.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 build --format docker --no-cache -t registry.gitlab.gnome.org/gnome/mutter/master:v3 .
-#     podman push registry.gitlab.gnome.org/gnome/mutter/master:v4
+#     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 \
+    dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 '*/xvfb-run' gdm-lib accountsservice-libs gnome-control-center && \
-        '*/xvfb-run' gdm-lib accountsservice-libs gnome-control-center gcovr \
-        --setopt=install_weak_deps=False && \
 
     # 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 $?
 }
 

.gitlab/issue_templates/Bug.md

@@ -1,55 +0,0 @@
-<!-- 
-Please read https://wiki.gnome.org/Community/GettingInTouch/BugReportingGuidelines
-first to ensure that you create a clear and specific issue.
--->
-
-### Affected version
-
-<!--
-Provide at least the following information:
-* Your OS and version
-* Affected Mutter version
-* Does this issue appear in XOrg and/or Wayland
--->
-
-### Bug summary
-
-<!-- 
-Provide a short summary of the bug you encountered.
--->
-
-### Steps to reproduce
-
-<!-- 
-1. Step one
-2. Step two
-3. ...
--->
-
-### What happened
-
-<!-- 
-What did Mutter do that was unexpected?
--->
-
-### What did you expect to happen
-
-<!-- 
-What did you expect Mutter to do?
--->
-
-### Relevant logs, screenshots, screencasts etc.
-
-<!-- 
-If you have further information, such as technical documentation, logs,
-screenshots or screencasts related, please provide them here.
-
-If the bug is a crash, please obtain a stack trace with installed debug
-symbols (at least for GNOME Shell and Mutter) and attach it to
-this issue following the instructions on
-https://wiki.gnome.org/Community/GettingInTouch/Bugzilla/GettingTraces.
--->
-
-
-<!-- Do not remove the following line. -->
-/label ~"1. Bug"

.gitlab/issue_templates/Feature.md

@@ -1,30 +0,0 @@
-<!-- 
-Please read https://wiki.gnome.org/Community/GettingInTouch/BugReportingGuidelines
-first to ensure that you create a clear and specific issue.
--->
-
-### Feature summary
-
-<!-- 
-Describe what you would like to be able to do with Mutter
-that you currently cannot do.
--->
-
-### How would you like it to work
-
-<!-- 
-If you can think of a way Mutter might be able to do this,
-let us know here.
--->
-
-### Relevant links, screenshots, screencasts etc.
-
-<!-- 
-If you have further information, such as technical documentation,
-code, mockups or a similar feature in another window managers,
-please provide them here.
--->
-
-
-<!-- Do not remove the following line. -->
-/label ~"1. Feature"

NEWS

@@ -1,196 +1,3 @@
-3.37.3
-======
-* Support custom keyboard layouts in $XDG_CONFIG_HOME/xkb [Peter; !936]
-* Optimize resource scale computation [Jonas D.; !1196, !1276, !1343]
-* Allow animating ClutterActor's content property [Georges; !1301]
-* Implement backgrounds as ClutterContent [Georges; !1302]
-* Add ClutterAlignContraint:pivot-point property [Jonas D.; !737]
-* Fix crash on area screenshots with fractional scaling [Sebastian; !1320]
-* Do not paint textures of fully obscured windows [Robert; !1326]
-* Use a more appropriate combine function on opaque areas [Daniel; !1331]
-* Fix remote desktop being broken without screencast session [Olivier; #1307]
-* Remove more long-deprecated Clutter APIs [Adam, Georges; !1194, !1332]
-* Drive each monitor by its own frame clock [Jonas Å.; !1285]
-* Fix copy/paste failures on X11 [Carlos; !1350]
-* Mipmap background texture rendering [Daniel; !1347]
-* Plugged memory leaks [Sebastian, Jonas D.; !1293, !1281, !1304]
-* Misc. bug fixes and cleanups [Jonas Å., Jonas D., Daniel, Corentin, Carlos,
-  Sebastian, Michel, Robert, Florian; !1288, !1289, !1291, !1296, !1292, !1298,
-  !1300, !1303, !1290, !1287, !1306, !1305, !1308, !1313, !1250, !1314, !1267,
-  !1275, !1317, !1270, !1322, !1181, !1282, !1325, !1323, !1240, !1295, !1329,
-  !1333, !1334, !1336, !1341, #1312, !1345, !1349, !1356, #873, !1310, !1357]
-
-Contributors:
-  Jonas Dreßler, Michel Dänzer, Olivier Fourdan, Carlos Garnacho,
-  Peter Hutterer, Adam Jackson, Sebastian Keller, Robert Mader, Florian Müllner,
-  Georges Basile Stavracas Neto, Corentin Noël, Daniel van Vugt, Jonas Ådahl
-
-3.37.2
-======
-* Fix move-to-center keybinding with multiple monitors [Sergey; #1073]
-* Fix stuck buttons when a virtual device is destroyed [Carlos; !1239]
-* Use workarea when centering new windows [Akatsuki; #964]
-* Limit mipmap levels when rendering background [Daniel; !1003]
-* Broadcast clipboard/primary offers [Carlos; !1253]
-* Support primary-selection protocol from wayland-protocols [Carlos; !1255]
-* Fix monitor screen cast on X11 [Jonas Å.; !1251]
-* Support a "blank" cursor type [Florian; !1244]
-* Improve stage view damage tracking [Jonas Å.; !1237]
-* Implement touch-mode detecation for the X11 backend [Carlos; !1278]
-* Drop external keyboard detection from touch-mode heuristics [Carlos; !1277]
-* Optimize actor allocations [Jonas D.; !1247]
-* Fixed crashes [Daniel, Carlos, Jonas Å., Jonas D.; !1256, !1258, !1217, !1280]
-* Misc. bug fixes and cleanups [Christian, Jonas D., Olivier, Ting-Wei,
-  Jonas Å., Marco, Corentin, Daniel, Robert, Niels, Florian, Simon; !1231,
-  !1228, !1238, !1229, !1192, !1236, !1171, !1134, #1126, !1234, !1230, !1210,
-  !1242, !1243, !1252, !1113, !1232, !1259, !1245, !1265, !1180, !1261, !788,
-  !1264, !1235, !1218, !1150, !1274, !1271, !1279, !1283, !1272]
-
-Contributors:
-  Marco Trevisan (Treviño), Akatsuki, Jonas Dreßler, Olivier Fourdan,
-  Carlos Garnacho, Niels De Graef, Ting-Wei Lan, Robert Mader, Simon McVittie,
-  Florian Müllner, Corentin Noël, Christian Rauch, Daniel van Vugt,
-  Sergey Zigachev, Jonas Ådahl
-
-3.37.1
-======
-* Fix screencasting non-maximized windows [Jonas Å.; !1174]
-* Make window-aliveness checks less aggressive [Jonas Å.; !1182]
-* Fix stylus coordinates when using screen rotation [Jonas T.; #1118]
-* Preserve keyboard state on VT switch [Olivier; !1185]
-* Remove Clutter's drag and drop actions [Jonas D.; !789]
-* Cancel clicks/gestures actions on disable [Georges; !1188]
-* Fix various clipboard issues [Carlos; !1186, !1198, !1203, !1204, !1206]
-* Fix trackball button scrolling [Phillip; #1120]
-* Fix tiled monitor support [Jonas; !1199]
-* Support unredirecting fullscreen wayland surfaces [Jonas Å.; !798]
-* Support area screencasts [Jonas Å.; !1207]
-* Synchronize shadows to server-side decorations [Olivier; !1214]
-* Allow inhibiting remote access [Jonas Å.; !1212]
-* Fix overview key on X11 when using multiple keyboard layouts [Olivier; !1219]
-* Fixed crashes [Jonas, D., Carlos; !1173, !1183, !1012]
-* Misc. bug fixes and cleanups [Andre, Georges, Christian, Jonas Å., Andre,
-  Simon, Florian, Carlos, Adam, Marco, Thomas, Elias, Pekka, Jonas D.,
-  Laurent; !1169, !1168, !1166, !1170, !1167, !1172, !1175, !1176, !1184,
-  !1126, !1187, !1191, !1195, !1179, !1200, !1193, !1209, !1213, !1208,
-  #1074, !1223]
-
-Contributors:
-  Marco Trevisan (Treviño), Elias Aebi, Thomas Hindoe Paaboel Andersen,
-  Laurent Bigonville, Jonas Dreßler, Olivier Fourdan, Carlos Garnacho,
-  Adam Jackson, Andre Moreira Magalhaes, Simon McVittie, Florian Müllner,
-  Georges Basile Stavracas Neto, Pekka Paalanen, Christian Rauch, Jonas Troeger,
-  Phillip Wood, Jonas Ådahl
-
-Translators:
-  Dušan Kazik [sk], Christian Kirbach [de]
-
-3.36.0
-======
-* Fix placement of popup windows in multi-monitor setups [Jonas; !1110]
-* Fix invisible mouse cursor on some hardware [Jonas; !1079]
-
-Contributors:
-  Jonas Ådahl
-
-Translators:
-  Aurimas Černius [lt], Goran Vidović [hr], Anders Jonsson [sv],
-  Guillaume Bernard [fr], Milo Casagrande [it], Daniel Korostil [uk],
-  Andre Klapper [cy], Aman Alam [pa], Nathan Follens [nl]
-
-3.35.92
-=======
-* Fix visibility of initially hidden windows [Jonas Å.; !1066]
-* Avoid flicker when (un)redirecting windows [Sebastian; #997]
-* Let BindConstraints update the preferred size [Emmanuele; !1070]
-* Learn about GLES3 [Adam; !882]
-* Ping windows on every window focus [Jonas D.; !891]
-* Remove overhead from hot code paths [Christian;
-  #1056, !1081, !1083, !1071, !1087]
-* Allow remote desktop services to inhibit animations [Jonas Å.; !838]
-* Update screen-cast code to PipeWire 0.3 API [Wim; !1062]
-* Make check-alive timeouts configurable [Jonas Å.; !1080]
-* Make each stage view correspond to a single CRTC [Jonas Å.; !1042]
-* Implement scaled/transformed hardware cursors [Robert; !526]
-* Use DMA buffers for screencasting if possible [Georges; !1086]
-* Make Xwayland startup asynchronous [Carlos; !944]
-* Fix clipping glitches in long text entries [Jonas D.; !1096]
-* Add side channel for starting required X11 services [Carlos; !945]
-* Support synchronized wayland popup moving [Jonas Å.; !705]
-* Fixed crashes [Olivier, Jonas Å.; !1073, !1093]
-* Plugged memory leaks [Sebastian, Jonas Å.; !1089, !1095]
-* Misc. bug fixes and cleanups [Jonas Å, Olivier, Florian, Daniel, Jonas D.,
-  Robert, Sebastian, Christian, Arun, Carlos, worldofpeace; !1061, #1043,
-  !1067, !1068, !1065, !835, !1058, !1069, !1075, #1060, !1077, !423, !1090,
-  !1088, !1094, #1067, !1064, !1099, !957, !1000, !1082]
-
-Contributors:
-  Emmanuele Bassi, Jonas Dreßler, Olivier Fourdan, Carlos Garnacho,
-  Christian Hergert, Adam Jackson, Sebastian Keller, Robert Mader,
-  Florian Müllner, Georges Basile Stavracas Neto, Arun Raghavan, Wim Taymans,
-  Daniel van Vugt, worldofpeace, Jonas Ådahl
-
-Translators:
-  Yi-Jyun Pan [zh_TW], Asier Sarasua Garmendia [eu], Rafael Fontenelle [pt_BR],
-  Emin Tufan Çetin [tr], Daniel Mustieles [es], Balázs Úr [hu],
-  Gwan-gyeong Mun [ko], Marek Černocký [cs], Fran Dieguez [gl],
-  Kukuh Syafaat [id], Alan Mortensen [da], Piotr Drąg [pl], sicklylife [ja],
-  Matej Urbančič [sl]
-
-3.35.91
-=======
-* Honor accelerometer orientation on monitor config changes [Hans; !959]
-* Enable culling for integer-scaled actors [Robert; !1036]
-* Add ClutterSeat::touch-mode property [Carlos; !1044]
-* Fix mis-scaling when streaming windows [Olivier; !1022]
-* Make the cursor renderer use the transactional KMS API [Jonas; !930]
-* Advertise MetaMonitor as wl_output [Olivier; !994]
-* Fix culling of XWayland windows [Robert; !1049]
-* Only consider enabled effects when disabling culling [Robert; !1052]
-* Misc. bug fixes and cleanups [Olivier, Sergio, Adam, Carlos, Björn; !1040,
-  #985, !1024, !1039, !1051]
-
-Contributors:
-  Sergio Costas, Björn Daase, Olivier Fourdan, Carlos Garnacho, Hans de Goede,
-  Adam Jackson, Robert Mader, Jonas Ådahl
-
-Translators:
-  sicklylife [ja]
-
-3.35.90
-=======
-* Cull out clip region [Robert; !985]
-* Always enable tap-to-click/drag on opaque Wacom tablets [Carlos; !968]
-* Fix visual glitches with offscreen effects applied [Georges; !992]
-* Fix "sticky corner" in multi-head setups [Jonas D.; #774]
-* Fix black shadows around XWayland windows during resizes [Ray, Olivier; #858]
-* Zero-copy path for GPU-less secondary GPUs [Pekka; !810]
-* Cancel DND on Esc [Carlos; #1020]
-* Sync XWayland window shadows to frame during resizes [Olivier; !1009]
-* Add support for per-monitor workareas [Alberts; !370]
-* Ensure newly mapped wayland windows receive ENTER event [Olivier; !1026]
-* Add ClutterSeat object [Carlos; !852]
-* Honour CLUTTER_ACTOR_NO_LAYOUT flag more efficiently [Daniel; !575]
-* Fix interoperation with wl_data_device_manager v1 [Carlos; #965]
-* Favor text over images in clipboard manager [Carlos; #919]
-* Apply monitor scale after background texture creation [Daniel; !1004]
-* Plugged memory leaks [Sebastian, Adam; !991, #1000, !1011, !1020, !1030,
-  !1001, !1033]
-* Fixed crashes [Jonas Å., Florian, Olivier; !961, #1029, !1037]
-* Misc. bug fixes and cleanups [Björn, Jonas Å., Adam, Sebastian, Jonas D.,
-  Daniel, Carlos, Corentin, Sebastian, Robert, Daniel; #385, !998, !1007, !995,
-  !1016, !1018, !1017, !1005, !1019, !1025, !1028, !1029, !1031, !1015, !1032,
-  !1034, #1025]
-
-Contributors:
-  Björn Daase, Jonas Dreßler, Olivier Fourdan, Carlos Garnacho, Adam Jackson,
-  Sebastian Keller, Robert Mader, Alberts Muktupāvels, Florian Müllner,
-  Georges Basile Stavracas Neto, Corentin Noël, Pekka Paalanen, Ray Strode,
-  Daniel van Vugt, Jonas Ådahl
-
-Translators:
-  sicklylife [ja], Umarzuki Bin Mochlis Moktar [ms]
-
 3.35.3
 ======
 * backends/native: Correct dy value in pinch gesture event [Yariv; !974]

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
+typedef struct _ClutterActionClass      ClutterActionClass;
-G_DECLARE_DERIVABLE_TYPE (ClutterAction, clutter_action,
+
-                          CLUTTER, ACTION, ClutterActorMeta);
+/**
+ * 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 =
+  meta->priv->actor = NULL;
-    clutter_actor_meta_get_instance_private (meta);
-
-  priv->actor = NULL;
 }
 
 static void
 clutter_actor_meta_real_set_actor (ClutterActorMeta *meta,
                                    ClutterActor     *actor)
 {
-  ClutterActorMetaPrivate *priv =
+  if (meta->priv->actor == actor)
-    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)
     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)
+  if (meta->priv->actor != NULL)
-    priv->destroy_id = g_signal_connect (priv->actor, "destroy",
+    meta->priv->destroy_id = g_signal_connect (meta->priv->actor, "destroy",
-                                         G_CALLBACK (on_actor_destroy),
+                                               G_CALLBACK (on_actor_destroy),
-                                         meta);
+                                               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]);
 }
 
 static void
@@ -156,21 +131,20 @@ clutter_actor_meta_get_property (GObject    *gobject,
                                  GValue     *value,
                                  GParamSpec *pspec)
 {
-  ClutterActorMetaPrivate *priv =
+  ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject);
-    clutter_actor_meta_get_instance_private (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 =
+  ClutterActorMetaPrivate *priv = CLUTTER_ACTOR_META (gobject)->priv;
-    clutter_actor_meta_get_instance_private (CLUTTER_ACTOR_META (gobject));
 
   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 =
+  self->priv = clutter_actor_meta_get_instance_private (self);
-    clutter_actor_meta_get_instance_private (self);
+  self->priv->is_enabled = TRUE;
-
+  self->priv->priority = CLUTTER_ACTOR_META_PRIORITY_DEFAULT;
-  priv->is_enabled = TRUE;
-  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 (meta->priv->name, name) == 0)
-
-  if (g_strcmp0 (priv->name, name) == 0)
     return;
 
-  g_free (priv->name);
+  g_free (meta->priv->name);
-  priv->name = g_strdup (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 meta->priv->name;
-
-  return 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 meta->priv->is_enabled;
-
-  return 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 meta->priv->actor;
-
-  return 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 meta->priv->priority;
-
-  return priv->priority;
 }
 
 gboolean
 _clutter_actor_meta_is_internal (ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv =
+  gint priority = meta->priv->priority;
-    clutter_actor_meta_get_instance_private (meta);
-  gint priority = 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
+                 meta->priv->name != NULL
-                   ? priv->name
+                   ? meta->priv->name
                    : "<unknown>",
-                 clutter_actor_get_name (priv->actor) != NULL
+                 clutter_actor_get_name (meta->priv->actor) != NULL
-                   ? clutter_actor_get_name (priv->actor)
+                   ? clutter_actor_get_name (meta->priv->actor)
-                   : G_OBJECT_TYPE_NAME (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 =
+  if (meta->priv->actor != group->actor)
-    clutter_actor_meta_get_instance_private (meta);
-
-  if (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
+                 meta->priv->name != NULL
-                   ? priv->name
+                   ? 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 =
+  return meta->priv->name != NULL ? meta->priv->name
-    clutter_actor_meta_get_instance_private (meta);
+                                  : G_OBJECT_TYPE_NAME (meta);
-
-  return priv->name != NULL ? 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
+typedef struct _ClutterActorMetaPrivate         ClutterActorMetaPrivate;
-G_DECLARE_DERIVABLE_TYPE (ClutterActorMeta, clutter_actor_meta,
+typedef struct _ClutterActorMetaClass           ClutterActorMetaClass;
-                          CLUTTER, ACTOR_META, GInitiallyUnowned);
 
-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
+ * @allocate: virtual function, used when settings the coordinates of an
- *   actor; it is used by clutter_actor_allocate(); when overriding this
+ *   actor; it is used by clutter_actor_allocate(); it must chain up to
- *   function without chaining up, clutter_actor_set_allocation() must be
+ *   the parent's implementation, or call clutter_actor_set_allocation()
- *   called and children must be allocated by the implementation, when
- *   chaining up though, those things will be done by the parent's
- *   implementation.
  * @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
+ *   the allocation; it must chain up to the parent's implementation
- *   have changed, the cached transformation must be invalidated by calling
- *   clutter_actor_invalidate_transform(); 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,31 +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,
-                                                                                 float                        x,
+                                                                                 ClutterAllocationFlags       flags);
-                                                                                 float                        y);
 CLUTTER_EXPORT
 void                            clutter_actor_allocate_available_size           (ClutterActor                *self,
                                                                                  gfloat                       x,
                                                                                  gfloat                       y,
                                                                                  gfloat                       available_width,
-                                                                                 gfloat                       available_height);
+                                                                                 gfloat                       available_height,
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_EXPORT
 void                            clutter_actor_allocate_align_fill               (ClutterActor                *self,
                                                                                  const ClutterActorBox       *box,
                                                                                  gdouble                      x_align,
                                                                                  gdouble                      y_align,
                                                                                  gboolean                     x_fill,
-                                                                                 gboolean                     y_fill);
+                                                                                 gboolean                     y_fill,
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_EXPORT
 void                            clutter_actor_set_allocation                    (ClutterActor                *self,
-                                                                                 const ClutterActorBox       *box);
+                                                                                 const ClutterActorBox       *box,
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_EXPORT
 void                            clutter_actor_get_allocation_box                (ClutterActor                *self,
                                                                                  ClutterActorBox             *box);
 CLUTTER_EXPORT
+void                            clutter_actor_get_allocation_vertices           (ClutterActor                *self,
+                                                                                 ClutterActor                *ancestor,
+                                                                                 graphene_point3d_t          *verts);
+CLUTTER_EXPORT
 gboolean                        clutter_actor_has_allocation                    (ClutterActor                *self);
 CLUTTER_EXPORT
 void                            clutter_actor_set_size                          (ClutterActor                *self,
@@ -456,10 +458,6 @@ void                            clutter_actor_set_position
                                                                                  gfloat                       x,
                                                                                  gfloat                       y);
 CLUTTER_EXPORT
-gboolean clutter_actor_get_fixed_position (ClutterActor *self,
-                                           float        *x,
-                                           float        *y);
-CLUTTER_EXPORT
 void                            clutter_actor_get_position                      (ClutterActor                *self,
                                                                                  gfloat                      *x,
                                                                                  gfloat                      *y);
@@ -599,7 +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);
@@ -882,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
@@ -924,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,
+source_position_changed (ClutterActor           *actor,
-                       ClutterAlignConstraint *align)
+                         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 source_x, source_y;
-  gfloat pivot_x, pivot_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->x1 = ((source_width - actor_width) * align->factor)
-      allocation->y1 += offset_y_start + (source_height * 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_signal_connect (align->source, "allocation-changed",
-                        G_CALLBACK (source_queue_relayout),
+                        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

@@ -23,7 +23,8 @@
 #define __CLUTTER_BACKEND_PRIVATE_H__
 
 #include <clutter/clutter-backend.h>
-#include <clutter/clutter-seat.h>
+#include <clutter/clutter-device-manager.h>
+#include <clutter/clutter-keymap.h>
 #include <clutter/clutter-stage-window.h>
 
 #define CLUTTER_BACKEND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_BACKEND, ClutterBackendClass))
@@ -46,6 +47,8 @@ struct _ClutterBackend
 
   CoglOnscreen *dummy_onscreen;
 
+  ClutterDeviceManager *device_manager;
+
   cairo_font_options_t *font_options;
 
   gchar *font_name;
@@ -53,11 +56,11 @@ struct _ClutterBackend
   gfloat units_per_em;
   gint32 units_serial;
 
-  float fallback_resource_scale;
-
   ClutterStageWindow *stage_window;
 
   ClutterInputMethod *input_method;
+
+  ClutterKeymap *keymap;
 };
 
 struct _ClutterBackendClass
@@ -86,12 +89,17 @@ struct _ClutterBackendClass
                                                 GError         **error);
   gboolean              (* create_context)     (ClutterBackend  *backend,
                                                 GError         **error);
+  ClutterDeviceManager *(* get_device_manager) (ClutterBackend  *backend);
 
   gboolean              (* translate_event)    (ClutterBackend     *backend,
                                                 gpointer            native,
                                                 ClutterEvent       *event);
 
-  ClutterSeat *         (* get_default_seat)   (ClutterBackend *backend);
+  PangoDirection        (* get_keymap_direction) (ClutterBackend   *backend);
+
+  void                  (* bell_notify)          (ClutterBackend   *backend);
+
+  ClutterKeymap *       (* get_keymap)           (ClutterBackend   *backend);
 
   /* signals */
   void (* resolution_changed) (ClutterBackend *backend);
@@ -131,17 +139,13 @@ gfloat                  _clutter_backend_get_units_per_em               (Clutter
                                                                          PangoFontDescription   *font_desc);
 gint32                  _clutter_backend_get_units_serial               (ClutterBackend         *backend);
 
+PangoDirection          _clutter_backend_get_keymap_direction           (ClutterBackend         *backend);
+
 void                    clutter_set_allowed_drivers                     (const char             *drivers);
 
 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

@@ -51,6 +51,7 @@
 #include "clutter-stage-manager-private.h"
 #include "clutter-stage-private.h"
 #include "clutter-stage-window.h"
+#include "clutter-device-manager-private.h"
 
 #ifdef CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
 #include "wayland/clutter-wayland-compositor.h"
@@ -527,6 +528,30 @@ clutter_backend_real_init_events (ClutterBackend *backend)
   g_error ("Unknown input backend");
 }
 
+static ClutterDeviceManager *
+clutter_backend_real_get_device_manager (ClutterBackend *backend)
+{
+  if (G_UNLIKELY (backend->device_manager == NULL))
+    {
+      g_critical ("No device manager available, expect broken input");
+      return NULL;
+    }
+
+  return backend->device_manager;
+}
+
+static ClutterKeymap *
+clutter_backend_real_get_keymap (ClutterBackend *backend)
+{
+  if (G_UNLIKELY (backend->keymap == NULL))
+    {
+      g_critical ("No keymap available, expect broken keyboard input");
+      return NULL;
+    }
+
+  return backend->keymap;
+}
+
 static void
 clutter_backend_class_init (ClutterBackendClass *klass)
 {
@@ -590,8 +615,10 @@ clutter_backend_class_init (ClutterBackendClass *klass)
   klass->font_changed = clutter_backend_real_font_changed;
 
   klass->init_events = clutter_backend_real_init_events;
+  klass->get_device_manager = clutter_backend_real_get_device_manager;
   klass->create_context = clutter_backend_real_create_context;
   klass->get_features = clutter_backend_real_get_features;
+  klass->get_keymap = clutter_backend_real_get_keymap;
 }
 
 static void
@@ -601,8 +628,6 @@ clutter_backend_init (ClutterBackend *self)
   self->units_serial = 1;
 
   self->dummy_onscreen = NULL;
-
-  self->fallback_resource_scale = 1.f;
 }
 
 void
@@ -758,24 +783,24 @@ _clutter_backend_copy_event_data (ClutterBackend     *backend,
                                   const ClutterEvent *src,
                                   ClutterEvent       *dest)
 {
-  ClutterSeatClass *seat_class;
+  ClutterDeviceManagerClass *device_manager_class;
-  ClutterSeat *seat;
+  ClutterDeviceManager *device_manager;
 
-  seat = clutter_backend_get_default_seat (backend);
+  device_manager = clutter_device_manager_get_default ();
-  seat_class = CLUTTER_SEAT_GET_CLASS (seat);
+  device_manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
-  seat_class->copy_event_data (seat, src, dest);
+  device_manager_class->copy_event_data (device_manager, src, dest);
 }
 
 void
 _clutter_backend_free_event_data (ClutterBackend *backend,
                                   ClutterEvent   *event)
 {
-  ClutterSeatClass *seat_class;
+  ClutterDeviceManagerClass *device_manager_class;
-  ClutterSeat *seat;
+  ClutterDeviceManager *device_manager;
 
-  seat = clutter_backend_get_default_seat (backend);
+  device_manager = clutter_device_manager_get_default ();
-  seat_class = CLUTTER_SEAT_GET_CLASS (seat);
+  device_manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
-  seat_class->free_event_data (seat, event);
+  device_manager_class->free_event_data (device_manager, event);
 }
 
 /**
@@ -972,6 +997,18 @@ clutter_wayland_set_compositor_display (void *display)
 }
 #endif
 
+PangoDirection
+_clutter_backend_get_keymap_direction (ClutterBackend *backend)
+{
+  ClutterBackendClass *klass;
+
+  klass = CLUTTER_BACKEND_GET_CLASS (backend);
+  if (klass->get_keymap_direction != NULL)
+    return klass->get_keymap_direction (backend);
+
+  return PANGO_DIRECTION_NEUTRAL;
+}
+
 void
 clutter_set_allowed_drivers (const char *drivers)
 {
@@ -984,6 +1021,16 @@ clutter_set_allowed_drivers (const char *drivers)
   allowed_drivers = g_strdup (drivers);
 }
 
+void
+clutter_backend_bell_notify (ClutterBackend *backend)
+{
+  ClutterBackendClass *klass;
+
+  klass = CLUTTER_BACKEND_GET_CLASS (backend);
+  if (klass->bell_notify)
+    klass->bell_notify (backend);
+}
+
 /**
  * clutter_backend_get_input_method:
  * @backend: the #CLutterBackend
@@ -1012,37 +1059,22 @@ clutter_backend_set_input_method (ClutterBackend     *backend,
   g_set_object (&backend->input_method, method);
 }
 
+/**
+ * clutter_backend_get_keymap:
+ * @backend: the #ClutterBackend
+ *
+ * Gets the keymap used by Clutter
+ *
+ * Returns: (transfer none): the keymap
+ **/
+ClutterKeymap *
+clutter_backend_get_keymap (ClutterBackend *backend)
+{
+  return CLUTTER_BACKEND_GET_CLASS (backend)->get_keymap (backend);
+}
+
 ClutterStageWindow *
 clutter_backend_get_stage_window (ClutterBackend *backend)
 {
   return backend->stage_window;
 }
-
-/**
- * clutter_backend_get_default_seat:
- * @backend: the #ClutterBackend
- *
- * Returns the default seat
- *
- * Returns: (transfer none): the default seat
- **/
-ClutterSeat *
-clutter_backend_get_default_seat (ClutterBackend *backend)
-{
-  g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), NULL);
-
-  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-backend.h

@@ -36,7 +36,6 @@
 #include <clutter/clutter-config.h>
 #include <clutter/clutter-keymap.h>
 #include <clutter/clutter-types.h>
-#include <clutter/clutter-seat.h>
 
 G_BEGIN_DECLS
 
@@ -73,6 +72,9 @@ const cairo_font_options_t *    clutter_backend_get_font_options        (Clutter
 CLUTTER_EXPORT
 CoglContext *                   clutter_backend_get_cogl_context        (ClutterBackend             *backend);
 
+CLUTTER_EXPORT
+void                            clutter_backend_bell_notify             (ClutterBackend             *backend);
+
 CLUTTER_EXPORT
 ClutterInputMethod *            clutter_backend_get_input_method        (ClutterBackend             *backend);
 
@@ -80,7 +82,7 @@ CLUTTER_EXPORT
 void                            clutter_backend_set_input_method        (ClutterBackend             *backend,
                                                                          ClutterInputMethod         *method);
 CLUTTER_EXPORT
-ClutterSeat *                   clutter_backend_get_default_seat        (ClutterBackend             *backend);
+ClutterKeymap *                 clutter_backend_get_keymap              (ClutterBackend             *backend);
 
 G_END_DECLS
 

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 ();
+ * rect[0] = clutter_rectangle_new_with_color (&red_color);
- * clutter_actor_set_background_color (rect[0], &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 ();
+ * rect[1] = clutter_rectangle_new_with_color (&green_color);
- * clutter_actor_set_background_color (rect[1], &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 ();
+ * rect[2] = clutter_rectangle_new_with_color (&blue_color);
- * clutter_actor_set_background_color (rect[2], &blue_color);
  * clutter_actor_set_size (rect[2], 100, 100);
  * clutter_actor_set_opacity (rect[2], 0);
  *
@@ -147,58 +144,6 @@ source_destroyed (ClutterActor          *actor,
   bind->source = NULL;
 }
 
-static void
-clutter_bind_constraint_update_preferred_size (ClutterConstraint  *constraint,
-                                               ClutterActor       *actor,
-                                               ClutterOrientation  direction,
-                                               float               for_size,
-                                               float              *minimum_size,
-                                               float              *natural_size)
-{
-  ClutterBindConstraint *bind = CLUTTER_BIND_CONSTRAINT (constraint);
-  float source_min, source_nat;
-
-  if (bind->source == NULL)
-    return;
-
-  /* only these bindings affect the preferred size */
-  if (!(bind->coordinate == CLUTTER_BIND_WIDTH ||
-        bind->coordinate == CLUTTER_BIND_HEIGHT ||
-        bind->coordinate == CLUTTER_BIND_SIZE ||
-        bind->coordinate == CLUTTER_BIND_ALL))
-    return;
-
-  if (clutter_actor_contains (bind->source, actor))
-    return;
-
-  switch (direction)
-    {
-    case CLUTTER_ORIENTATION_HORIZONTAL:
-      if (bind->coordinate != CLUTTER_BIND_HEIGHT)
-        {
-          clutter_actor_get_preferred_width (bind->source, for_size,
-                                             &source_min,
-                                             &source_nat);
-
-          *minimum_size = source_min;
-          *natural_size = source_nat;
-        }
-      break;
-
-    case CLUTTER_ORIENTATION_VERTICAL:
-      if (bind->coordinate != CLUTTER_BIND_WIDTH)
-        {
-          clutter_actor_get_preferred_height (bind->source, for_size,
-                                              &source_min,
-                                              &source_nat);
-
-          *minimum_size = source_min;
-          *natural_size = source_nat;
-        }
-      break;
-    }
-}
-
 static void
 clutter_bind_constraint_update_allocation (ClutterConstraint *constraint,
                                            ClutterActor      *actor,
@@ -383,8 +328,6 @@ clutter_bind_constraint_class_init (ClutterBindConstraintClass *klass)
   meta_class->set_actor = clutter_bind_constraint_set_actor;
 
   constraint_class->update_allocation = clutter_bind_constraint_update_allocation;
-  constraint_class->update_preferred_size = clutter_bind_constraint_update_preferred_size;
-
   /**
    * ClutterBindConstraint:source:
    *

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-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 =
+  ClutterClickActionPrivate *priv = action->priv;
-    clutter_click_action_get_instance_private (action);
 
   is_pressed = !!is_pressed;
 
@@ -175,8 +174,7 @@ static inline void
 click_action_set_held (ClutterClickAction *action,
                        gboolean            is_held)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
-    clutter_click_action_get_instance_private (action);
 
   is_held = !!is_held;
 
@@ -191,8 +189,7 @@ static gboolean
 click_action_emit_long_press (gpointer data)
 {
   ClutterClickAction *action = data;
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
-    clutter_click_action_get_instance_private (action);
   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 =
+  ClutterClickActionPrivate *priv = action->priv;
-    clutter_click_action_get_instance_private (action);
   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 =
+  ClutterClickActionPrivate *priv = action->priv;
-    clutter_click_action_get_instance_private (action);
 
   if (priv->long_press_id != 0)
     {
@@ -277,8 +271,7 @@ on_event (ClutterActor       *actor,
           ClutterEvent       *event,
           ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
-    clutter_click_action_get_instance_private (action);
   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 =
+  ClutterClickActionPrivate *priv = action->priv;
-    clutter_click_action_get_instance_private (action);
   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 =
+  ClutterClickActionPrivate *priv = action->priv;
-    clutter_click_action_get_instance_private (action);
 
   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 =
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
-    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
 
   switch (prop_id)
     {
@@ -521,8 +497,7 @@ clutter_click_action_get_property (GObject    *gobject,
                                    GValue     *value,
                                    GParamSpec *pspec)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
-    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
 
   switch (prop_id)
     {
@@ -551,8 +526,7 @@ clutter_click_action_get_property (GObject    *gobject,
 static void
 clutter_click_action_dispose (GObject *gobject)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
-    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
 
   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 =
+  self->priv = clutter_click_action_get_instance_private (self);
-    clutter_click_action_get_instance_private (self);
+  self->priv->long_press_threshold = -1;
-
+  self->priv->long_press_duration = -1;
-  priv->long_press_threshold = -1;
-  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 action->priv->press_button;
-
-  return 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 action->priv->modifier_state;
-
-  return 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
+typedef struct _ClutterClickAction              ClutterClickAction;
-G_DECLARE_DERIVABLE_TYPE (ClutterClickAction, clutter_click_action,
+typedef struct _ClutterClickActionPrivate       ClutterClickActionPrivate;
-                          CLUTTER, CLICK_ACTION, ClutterAction);
+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,31 +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, flags);
-      float x = 0.f;
-      float y = 0.f;
-
-      clutter_actor_get_fixed_position (priv->clone_source, &x, &y);
-      clutter_actor_allocate_preferred_size (priv->clone_source, x, y);
-    }
-
-  clutter_actor_get_allocation_box (priv->clone_source, &source_box);
-
-  /* We need to scale what the clone-source actor paints to fill our own
-   * allocation...
-   */
-  x_scale = clutter_actor_box_get_width (box)
-          / clutter_actor_box_get_width (&source_box);
-  y_scale = clutter_actor_box_get_height (box)
-          / clutter_actor_box_get_height (&source_box);
-
-  if (!G_APPROX_VALUE (priv->x_scale, x_scale, FLT_EPSILON) ||
-      !G_APPROX_VALUE (priv->y_scale, y_scale, FLT_EPSILON))
-    {
-      priv->x_scale = x_scale;
-      priv->y_scale = y_scale;
-      clutter_actor_invalidate_transform (CLUTTER_ACTOR (self));
-    }
 
 #if 0
   /* XXX - this is wrong: ClutterClone cannot clone unparented
@@ -284,7 +273,7 @@ clutter_clone_allocate (ClutterActor           *self,
    * paint cycle, we can safely give it as much size as it requires
    */
   if (clutter_actor_get_parent (priv->clone_source) == NULL)
-    clutter_actor_allocate_preferred_size (priv->clone_source);
+    clutter_actor_allocate_preferred_size (priv->clone_source, flags);
 #endif
 }
 
@@ -376,9 +365,6 @@ static void
 clutter_clone_init (ClutterClone *self)
 {
   self->priv = clutter_clone_get_instance_private (self);
-
-  self->priv->x_scale = 1.f;
-  self->priv->y_scale = 1.f;
 }
 
 /**

clutter/clutter/clutter-config.h.in

@@ -9,13 +9,7 @@
 
 G_BEGIN_DECLS
 
-#mesondefine CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
+@CLUTTER_CONFIG_DEFINES@
-#mesondefine CLUTTER_WINDOWING_X11
-#mesondefine CLUTTER_INPUT_X11
-#mesondefine CLUTTER_WINDOWING_GLX
-#mesondefine CLUTTER_WINDOWING_EGL
-#mesondefine CLUTTER_INPUT_EVDEV
-#mesondefine CLUTTER_INPUT_NULL
 
 G_END_DECLS
 

clutter/clutter/clutter-constraint-private.h

@@ -30,6 +30,13 @@ gboolean clutter_constraint_update_allocation (ClutterConstraint *constraint,
                                                ClutterActor      *actor,
                                                ClutterActorBox   *allocation);
 
+void clutter_constraint_update_preferred_size (ClutterConstraint  *constraint,
+                                               ClutterActor       *actor,
+                                               ClutterOrientation  direction,
+                                               float               for_size,
+                                               float              *minimum_size,
+                                               float              *natural_size);
+
 G_END_DECLS
 
 #endif /* __CLUTTER_CONSTRAINT_PRIVATE_H__ */

clutter/clutter/clutter-constraint.c

@@ -160,26 +160,28 @@ constraint_update_preferred_size (ClutterConstraint  *constraint,
 }
 
 static void
-clutter_constraint_set_enabled (ClutterActorMeta *meta,
+clutter_constraint_notify (GObject    *gobject,
-                                gboolean          is_enabled)
+                           GParamSpec *pspec)
 {
-  ClutterActorMetaClass *parent_class =
+  if (strcmp (pspec->name, "enabled") == 0)
-    CLUTTER_ACTOR_META_CLASS (clutter_constraint_parent_class);
+    {
-  ClutterActor *actor;
+      ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject);
+      ClutterActor *actor = clutter_actor_meta_get_actor (meta);
 
-  actor = clutter_actor_meta_get_actor (meta);
+      if (actor != NULL)
-  if (actor)
+        clutter_actor_queue_relayout (actor);
-    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;
@@ -220,17 +222,6 @@ clutter_constraint_update_allocation (ClutterConstraint *constraint,
   return !clutter_actor_box_equal (allocation, &old_alloc);
 }
 
-/**
- * clutter_constraint_update_preferred_size:
- * @constraint: a #ClutterConstraint
- * @actor: a #ClutterActor
- * @direction: a #ClutterOrientation
- * @for_size: the size in the opposite direction
- * @minimum_size: (inout): the minimum size to modify
- * @natural_size: (inout): the natural size to modify
- *
- * Asks the @constraint to update the size request of a #ClutterActor.
- */
 void
 clutter_constraint_update_preferred_size (ClutterConstraint  *constraint,
                                           ClutterActor       *actor,

clutter/clutter/clutter-constraint.h

@@ -99,14 +99,6 @@ struct _ClutterConstraintClass
 CLUTTER_EXPORT
 GType clutter_constraint_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
-void clutter_constraint_update_preferred_size (ClutterConstraint  *constraint,
-                                               ClutterActor       *actor,
-                                               ClutterOrientation  direction,
-                                               float               for_size,
-                                               float              *minimum_size,
-                                               float              *natural_size);
-
 /* ClutterActor API */
 CLUTTER_EXPORT
 void               clutter_actor_add_constraint            (ClutterActor      *self,

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

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

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-device-manager-private.h

@@ -0,0 +1,306 @@
+/*
+ * 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_DEVICE_MANAGER_PRIVATE_H__
+#define __CLUTTER_DEVICE_MANAGER_PRIVATE_H__
+
+#include <clutter/clutter-backend.h>
+#include <clutter/clutter-device-manager.h>
+#include <clutter/clutter-event.h>
+
+G_BEGIN_DECLS
+
+typedef struct _ClutterAxisInfo
+{
+  ClutterInputAxis axis;
+
+  gdouble min_axis;
+  gdouble max_axis;
+
+  gdouble min_value;
+  gdouble max_value;
+
+  gdouble resolution;
+} ClutterAxisInfo;
+
+typedef struct _ClutterKeyInfo
+{
+  guint keyval;
+  ClutterModifierType modifiers;
+} ClutterKeyInfo;
+
+typedef struct _ClutterScrollInfo
+{
+  guint axis_id;
+  ClutterScrollDirection direction;
+  gdouble increment;
+
+  gdouble last_value;
+  guint last_value_valid : 1;
+} ClutterScrollInfo;
+
+typedef struct _ClutterTouchInfo
+{
+  ClutterEventSequence *sequence;
+  ClutterActor *actor;
+
+  gfloat current_x;
+  gfloat current_y;
+} ClutterTouchInfo;
+
+typedef struct _ClutterPtrA11yData
+{
+  int n_btn_pressed;
+  float current_x;
+  float current_y;
+
+  float dwell_x;
+  float dwell_y;
+  gboolean dwell_drag_started;
+  gboolean dwell_gesture_started;
+  guint dwell_timer;
+  guint dwell_position_timer;
+
+  guint secondary_click_timer;
+  gboolean secondary_click_triggered;
+} ClutterPtrA11yData;
+
+struct _ClutterInputDevice
+{
+  GObject parent_instance;
+
+  gint id;
+
+  ClutterInputDeviceType device_type;
+  ClutterInputMode device_mode;
+
+  gchar *device_name;
+
+  ClutterDeviceManager *device_manager;
+
+  ClutterBackend *backend;
+
+  /* the associated device */
+  ClutterInputDevice *associated;
+
+  GList *slaves;
+
+  /* the actor underneath the pointer */
+  ClutterActor *cursor_actor;
+  GHashTable   *inv_touch_sequence_actors;
+
+  /* the actor that has a grab in place for the device */
+  ClutterActor *pointer_grab_actor;
+  ClutterActor *keyboard_grab_actor;
+  GHashTable   *sequence_grab_actors;
+  GHashTable   *inv_sequence_grab_actors;
+
+  /* the current click count */
+  gint click_count;
+
+  /* the stage the device is on */
+  ClutterStage *stage;
+
+  /* the current state */
+  gfloat current_x;
+  gfloat current_y;
+  guint32 current_time;
+  gint current_button_number;
+  ClutterModifierType current_state;
+
+  /* the current touch points states */
+  GHashTable *touch_sequences_info;
+
+  /* the previous state, used for click count generation */
+  gint previous_x;
+  gint previous_y;
+  guint32 previous_time;
+  gint previous_button_number;
+  ClutterModifierType previous_state;
+
+  GArray *axes;
+
+  guint n_keys;
+  GArray *keys;
+
+  GArray *scroll_info;
+
+  gchar *vendor_id;
+  gchar *product_id;
+  gchar *node_path;
+
+  GPtrArray *tools;
+
+  gint n_rings;
+  gint n_strips;
+  gint n_mode_groups;
+
+  ClutterInputDeviceMapping mapping_mode;
+
+  guint has_cursor : 1;
+  guint is_enabled : 1;
+
+  /* Accessiblity */
+  ClutterVirtualInputDevice *accessibility_virtual_device;
+  ClutterPtrA11yData *ptr_a11y_data;
+};
+
+typedef void (*ClutterEmitInputDeviceEvent) (ClutterEvent       *event,
+                                             ClutterInputDevice *device);
+
+struct _ClutterInputDeviceClass
+{
+  GObjectClass parent_class;
+
+  gboolean (* keycode_to_evdev) (ClutterInputDevice *device,
+                                 guint               hardware_keycode,
+                                 guint              *evdev_keycode);
+  void (* update_from_tool) (ClutterInputDevice     *device,
+                             ClutterInputDeviceTool *tool);
+
+  gboolean (* is_mode_switch_button) (ClutterInputDevice *device,
+                                      guint               group,
+                                      guint               button);
+  gint (* get_group_n_modes) (ClutterInputDevice *device,
+                              gint                group);
+
+  gboolean (* is_grouped) (ClutterInputDevice *device,
+                           ClutterInputDevice *other_device);
+
+  /* Keyboard accessbility */
+  void (* process_kbd_a11y_event) (ClutterEvent               *event,
+                                   ClutterInputDevice         *device,
+                                   ClutterEmitInputDeviceEvent emit_event_func);
+};
+
+/* device manager */
+CLUTTER_EXPORT
+void            _clutter_device_manager_add_device              (ClutterDeviceManager *device_manager,
+                                                                 ClutterInputDevice   *device);
+CLUTTER_EXPORT
+void            _clutter_device_manager_remove_device           (ClutterDeviceManager *device_manager,
+                                                                 ClutterInputDevice   *device);
+void            _clutter_device_manager_update_devices          (ClutterDeviceManager *device_manager);
+CLUTTER_EXPORT
+void            _clutter_device_manager_select_stage_events     (ClutterDeviceManager *device_manager,
+                                                                 ClutterStage         *stage);
+ClutterBackend *_clutter_device_manager_get_backend             (ClutterDeviceManager *device_manager);
+
+void            _clutter_device_manager_compress_motion         (ClutterDeviceManager *device_manger,
+                                                                 ClutterEvent         *event,
+                                                                 const ClutterEvent   *to_discard);
+CLUTTER_EXPORT
+void            clutter_device_manager_ensure_a11y_state        (ClutterDeviceManager *device_manager);
+
+/* input device */
+CLUTTER_EXPORT
+gboolean        _clutter_input_device_has_sequence              (ClutterInputDevice   *device,
+                                                                 ClutterEventSequence *sequence);
+CLUTTER_EXPORT
+void            _clutter_input_device_add_event_sequence        (ClutterInputDevice   *device,
+                                                                 ClutterEvent         *event);
+CLUTTER_EXPORT
+void            _clutter_input_device_remove_event_sequence     (ClutterInputDevice   *device,
+                                                                 ClutterEvent         *event);
+CLUTTER_EXPORT
+void            _clutter_input_device_set_coords                (ClutterInputDevice   *device,
+                                                                 ClutterEventSequence *sequence,
+                                                                 gfloat                x,
+                                                                 gfloat                y,
+                                                                 ClutterStage         *stage);
+CLUTTER_EXPORT
+void            _clutter_input_device_set_state                 (ClutterInputDevice   *device,
+                                                                 ClutterModifierType   state);
+CLUTTER_EXPORT
+void            _clutter_input_device_set_time                  (ClutterInputDevice   *device,
+                                                                 guint32               time_);
+CLUTTER_EXPORT
+void            _clutter_input_device_set_stage                 (ClutterInputDevice   *device,
+                                                                 ClutterStage         *stage);
+CLUTTER_EXPORT
+ClutterStage *  _clutter_input_device_get_stage                 (ClutterInputDevice   *device);
+void            _clutter_input_device_set_actor                 (ClutterInputDevice   *device,
+                                                                 ClutterEventSequence *sequence,
+                                                                 ClutterActor         *actor,
+                                                                 gboolean              emit_crossing);
+ClutterActor *  _clutter_input_device_update                    (ClutterInputDevice   *device,
+                                                                 ClutterEventSequence *sequence,
+                                                                 gboolean              emit_crossing);
+CLUTTER_EXPORT
+void            _clutter_input_device_set_n_keys                (ClutterInputDevice   *device,
+                                                                 guint                 n_keys);
+CLUTTER_EXPORT
+guint           _clutter_input_device_add_axis                  (ClutterInputDevice   *device,
+                                                                 ClutterInputAxis      axis,
+                                                                 gdouble               min_value,
+                                                                 gdouble               max_value,
+                                                                 gdouble               resolution);
+CLUTTER_EXPORT
+void            _clutter_input_device_reset_axes                (ClutterInputDevice   *device);
+
+CLUTTER_EXPORT
+void            _clutter_input_device_set_associated_device     (ClutterInputDevice   *device,
+                                                                 ClutterInputDevice   *associated);
+CLUTTER_EXPORT
+void            _clutter_input_device_add_slave                 (ClutterInputDevice   *master,
+                                                                 ClutterInputDevice   *slave);
+CLUTTER_EXPORT
+void            _clutter_input_device_remove_slave              (ClutterInputDevice   *master,
+                                                                 ClutterInputDevice   *slave);
+
+CLUTTER_EXPORT
+gboolean        _clutter_input_device_translate_axis            (ClutterInputDevice   *device,
+                                                                 guint                 index_,
+                                                                 gdouble               value,
+                                                                 gdouble              *axis_value);
+
+CLUTTER_EXPORT
+void            _clutter_input_device_add_scroll_info           (ClutterInputDevice   *device,
+                                                                 guint                 index_,
+                                                                 ClutterScrollDirection direction,
+                                                                 gdouble               increment);
+CLUTTER_EXPORT
+void            _clutter_input_device_reset_scroll_info         (ClutterInputDevice   *device);
+CLUTTER_EXPORT
+gboolean        _clutter_input_device_get_scroll_delta          (ClutterInputDevice   *device,
+                                                                 guint                 index_,
+                                                                 gdouble               value,
+                                                                 ClutterScrollDirection *direction_p,
+                                                                 gdouble                *delta_p);
+
+CLUTTER_EXPORT
+ClutterInputDeviceTool * clutter_input_device_lookup_tool       (ClutterInputDevice         *device,
+                                                                 guint64                     serial,
+                                                                 ClutterInputDeviceToolType  type);
+CLUTTER_EXPORT
+void            clutter_input_device_add_tool                   (ClutterInputDevice     *device,
+                                                                 ClutterInputDeviceTool *tool);
+
+CLUTTER_EXPORT
+void            clutter_input_device_update_from_tool           (ClutterInputDevice     *device,
+                                                                 ClutterInputDeviceTool *tool);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_DEVICE_MANAGER_PRIVATE_H__ */

clutter/clutter/clutter-device-manager.c

@@ -0,0 +1,753 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2009  Intel Corp.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Emmanuele Bassi <ebassi@linux.intel.com>
+ */
+
+/**
+ * SECTION:clutter-device-manager
+ * @short_description: Maintains the list of input devices
+ *
+ * #ClutterDeviceManager is a singleton object, owned by Clutter, which
+ * maintains the list of #ClutterInputDevice<!-- -->s.
+ *
+ * Depending on the backend used by Clutter it is possible to use the
+ * #ClutterDeviceManager::device-added and
+ * #ClutterDeviceManager::device-removed to monitor addition and removal
+ * of devices.
+ *
+ * #ClutterDeviceManager is available since Clutter 1.2
+ */
+
+#include "clutter-build-config.h"
+
+#include "clutter-backend-private.h"
+#include "clutter-debug.h"
+#include "clutter-device-manager-private.h"
+#include "clutter-enum-types.h"
+#include "clutter-marshal.h"
+#include "clutter-private.h"
+#include "clutter-stage-private.h"
+#include "clutter-virtual-input-device.h"
+#include "clutter-input-device-tool.h"
+#include "clutter-input-pointer-a11y-private.h"
+
+struct _ClutterDeviceManagerPrivate
+{
+  /* back-pointer to the backend */
+  ClutterBackend *backend;
+
+  /* Keyboard a11y */
+  ClutterKbdA11ySettings kbd_a11y_settings;
+  /* Pointer a11y */
+  ClutterPointerA11ySettings pointer_a11y_settings;
+};
+
+enum
+{
+  PROP_0,
+
+  PROP_BACKEND,
+
+  PROP_LAST
+};
+
+static GParamSpec *obj_props[PROP_LAST];
+
+enum
+{
+  DEVICE_ADDED,
+  DEVICE_REMOVED,
+  TOOL_CHANGED,
+  KBD_A11Y_MASK_CHANGED,
+  KBD_A11Y_FLAGS_CHANGED,
+  PTR_A11Y_DWELL_CLICK_TYPE_CHANGED,
+  PTR_A11Y_TIMEOUT_STARTED,
+  PTR_A11Y_TIMEOUT_STOPPED,
+
+  LAST_SIGNAL
+};
+
+static guint manager_signals[LAST_SIGNAL] = { 0, };
+
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ClutterDeviceManager,
+                                     clutter_device_manager,
+                                     G_TYPE_OBJECT)
+
+static void
+clutter_device_manager_set_property (GObject      *gobject,
+                                     guint         prop_id,
+                                     const GValue *value,
+                                     GParamSpec   *pspec)
+{
+  ClutterDeviceManager *self = CLUTTER_DEVICE_MANAGER (gobject);
+  ClutterDeviceManagerPrivate *priv = clutter_device_manager_get_instance_private (self);
+
+  switch (prop_id)
+    {
+    case PROP_BACKEND:
+      priv->backend = g_value_get_object (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+    }
+}
+
+static void
+clutter_device_manager_get_property (GObject    *gobject,
+                                     guint       prop_id,
+                                     GValue     *value,
+                                     GParamSpec *pspec)
+{
+  ClutterDeviceManager *self = CLUTTER_DEVICE_MANAGER (gobject);
+  ClutterDeviceManagerPrivate *priv = clutter_device_manager_get_instance_private (self);
+
+  switch (prop_id)
+    {
+    case PROP_BACKEND:
+      g_value_set_object (value, priv->backend);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+    }
+}
+
+static void
+clutter_device_manager_class_init (ClutterDeviceManagerClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  obj_props[PROP_BACKEND] =
+    g_param_spec_object ("backend",
+                         P_("Backend"),
+                         P_("The ClutterBackend of the device manager"),
+                         CLUTTER_TYPE_BACKEND,
+                         CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+  gobject_class->set_property = clutter_device_manager_set_property;
+  gobject_class->get_property = clutter_device_manager_get_property;
+  g_object_class_install_properties (gobject_class,
+                                     PROP_LAST,
+                                     obj_props);
+
+  /**
+   * ClutterDeviceManager::device-added:
+   * @manager: the #ClutterDeviceManager that emitted the signal
+   * @device: the newly added #ClutterInputDevice
+   *
+   * The ::device-added signal is emitted each time a device has been
+   * added to the #ClutterDeviceManager
+   *
+   * Since: 1.2
+   */
+  manager_signals[DEVICE_ADDED] =
+    g_signal_new (I_("device-added"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 1,
+                  CLUTTER_TYPE_INPUT_DEVICE);
+
+  /**
+   * ClutterDeviceManager::device-removed:
+   * @manager: the #ClutterDeviceManager that emitted the signal
+   * @device: the removed #ClutterInputDevice
+   *
+   * The ::device-removed signal is emitted each time a device has been
+   * removed from the #ClutterDeviceManager
+   *
+   * Since: 1.2
+   */
+  manager_signals[DEVICE_REMOVED] =
+    g_signal_new (I_("device-removed"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 1,
+                  CLUTTER_TYPE_INPUT_DEVICE);
+
+  manager_signals[TOOL_CHANGED] =
+    g_signal_new (I_("tool-changed"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL,
+                  _clutter_marshal_VOID__OBJECT_OBJECT,
+                  G_TYPE_NONE, 2,
+                  CLUTTER_TYPE_INPUT_DEVICE,
+                  CLUTTER_TYPE_INPUT_DEVICE_TOOL);
+
+  /**
+   * ClutterDeviceManager::kbd-a11y-mods-state-changed:
+   * @manager: the #ClutterDeviceManager that emitted the signal
+   * @latched_mask: the latched modifier mask from stickykeys
+   * @locked_mask:  the locked modifier mask from stickykeys
+   *
+   * The ::kbd-a11y-mods-state-changed signal is emitted each time either the
+   * latched modifiers mask or locked modifiers mask are changed as the
+   * result of keyboard accessibilty's sticky keys operations.
+   */
+  manager_signals[KBD_A11Y_MASK_CHANGED] =
+    g_signal_new (I_("kbd-a11y-mods-state-changed"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL,
+                  _clutter_marshal_VOID__UINT_UINT,
+                  G_TYPE_NONE, 2,
+                  G_TYPE_UINT,
+                  G_TYPE_UINT);
+
+  /**
+   * ClutterDeviceManager::kbd-a11y-flags-changed:
+   * @manager: the #ClutterDeviceManager that emitted the signal
+   * @settings_flags: the new ClutterKeyboardA11yFlags configuration
+   * @changed_mask: the ClutterKeyboardA11yFlags changed
+   *
+   * The ::kbd-a11y-flags-changed signal is emitted each time the
+   * ClutterKeyboardA11yFlags configuration is changed as the result of
+   * keyboard accessibilty operations.
+   */
+  manager_signals[KBD_A11Y_FLAGS_CHANGED] =
+    g_signal_new (I_("kbd-a11y-flags-changed"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL,
+                  _clutter_marshal_VOID__UINT_UINT,
+                  G_TYPE_NONE, 2,
+                  G_TYPE_UINT,
+                  G_TYPE_UINT);
+
+  /**
+   * ClutterDeviceManager::ptr-a11y-dwell-click-type-changed:
+   * @manager: the #ClutterDeviceManager that emitted the signal
+   * @click_type: the new #ClutterPointerA11yDwellClickType mode
+   *
+   * The ::ptr-a11y-dwell-click-type-changed signal is emitted each time
+   * the ClutterPointerA11yDwellClickType mode is changed as the result
+   * of pointer accessibility operations.
+   */
+  manager_signals[PTR_A11Y_DWELL_CLICK_TYPE_CHANGED] =
+    g_signal_new (I_("ptr-a11y-dwell-click-type-changed"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL,
+                  g_cclosure_marshal_VOID__FLAGS,
+                  G_TYPE_NONE, 1,
+                  CLUTTER_TYPE_POINTER_A11Y_DWELL_CLICK_TYPE);
+
+  /**
+   * ClutterDeviceManager::ptr-a11y-timeout-started:
+   * @manager: the #ClutterDeviceManager that emitted the signal
+   * @device: the core pointer #ClutterInputDevice
+   * @timeout_type: the type of timeout #ClutterPointerA11yTimeoutType
+   * @delay: the delay in ms before secondary-click is triggered.
+   *
+   * The ::ptr-a11y-timeout-started signal is emitted when a
+   * pointer accessibility timeout delay is started, so that upper
+   * layers can notify the user with some visual feedback.
+   */
+  manager_signals[PTR_A11Y_TIMEOUT_STARTED] =
+    g_signal_new (I_("ptr-a11y-timeout-started"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL,
+                  _clutter_marshal_VOID__OBJECT_FLAGS_UINT,
+                  G_TYPE_NONE, 3,
+                  CLUTTER_TYPE_INPUT_DEVICE,
+                  CLUTTER_TYPE_POINTER_A11Y_TIMEOUT_TYPE,
+                  G_TYPE_UINT);
+
+  /**
+   * ClutterDeviceManager::ptr-a11y-timeout-stopped:
+   * @manager: the #ClutterDeviceManager that emitted the signal
+   * @device: the core pointer #ClutterInputDevice
+   * @timeout_type: the type of timeout #ClutterPointerA11yTimeoutType
+   * @clicked: %TRUE if the timeout finished and triggered a click
+   *
+   * The ::ptr-a11y-timeout-stopped signal is emitted when a running
+   * pointer accessibility timeout delay is stopped, either because
+   * it's triggered at the end of the delay or cancelled, so that
+   * upper layers can notify the user with some visual feedback.
+   */
+  manager_signals[PTR_A11Y_TIMEOUT_STOPPED] =
+    g_signal_new (I_("ptr-a11y-timeout-stopped"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL,
+                  _clutter_marshal_VOID__OBJECT_FLAGS_BOOLEAN,
+                  G_TYPE_NONE, 3,
+                  CLUTTER_TYPE_INPUT_DEVICE,
+                  CLUTTER_TYPE_POINTER_A11Y_TIMEOUT_TYPE,
+                  G_TYPE_BOOLEAN);
+}
+
+static void
+clutter_device_manager_init (ClutterDeviceManager *self)
+{
+}
+
+/**
+ * clutter_device_manager_get_default:
+ *
+ * Retrieves the device manager singleton
+ *
+ * Return value: (transfer none): the #ClutterDeviceManager singleton.
+ *   The returned instance is owned by Clutter and it should not be
+ *   modified or freed
+ *
+ * Since: 1.2
+ */
+ClutterDeviceManager *
+clutter_device_manager_get_default (void)
+{
+  ClutterBackend *backend = clutter_get_default_backend ();
+
+  return CLUTTER_BACKEND_GET_CLASS (backend)->get_device_manager (backend);
+}
+
+/**
+ * clutter_device_manager_list_devices:
+ * @device_manager: a #ClutterDeviceManager
+ *
+ * Lists all currently registered input devices
+ *
+ * Return value: (transfer container) (element-type Clutter.InputDevice):
+ *   a newly allocated list of #ClutterInputDevice objects. Use
+ *   g_slist_free() to deallocate it when done
+ *
+ * Since: 1.2
+ */
+GSList *
+clutter_device_manager_list_devices (ClutterDeviceManager *device_manager)
+{
+  const GSList *devices;
+
+  g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
+
+  devices = clutter_device_manager_peek_devices (device_manager);
+
+  return g_slist_copy ((GSList *) devices);
+}
+
+/**
+ * clutter_device_manager_peek_devices:
+ * @device_manager: a #ClutterDeviceManager
+ *
+ * Lists all currently registered input devices
+ *
+ * Return value: (transfer none) (element-type Clutter.InputDevice):
+ *   a pointer to the internal list of #ClutterInputDevice objects. The
+ *   returned list is owned by the #ClutterDeviceManager and should never
+ *   be modified or freed
+ *
+ * Since: 1.2
+ */
+const GSList *
+clutter_device_manager_peek_devices (ClutterDeviceManager *device_manager)
+{
+  ClutterDeviceManagerClass *manager_class;
+
+  g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
+
+  manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
+  return manager_class->get_devices (device_manager);
+}
+
+/**
+ * clutter_device_manager_get_device:
+ * @device_manager: a #ClutterDeviceManager
+ * @device_id: the integer id of a device
+ *
+ * Retrieves the #ClutterInputDevice with the given @device_id
+ *
+ * Return value: (transfer none): a #ClutterInputDevice or %NULL. The
+ *   returned device is owned by the #ClutterDeviceManager and should
+ *   never be modified or freed
+ *
+ * Since: 1.2
+ */
+ClutterInputDevice *
+clutter_device_manager_get_device (ClutterDeviceManager *device_manager,
+                                   gint                  device_id)
+{
+  ClutterDeviceManagerClass *manager_class;
+
+  g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
+
+  manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
+  return manager_class->get_device (device_manager, device_id);
+}
+
+/**
+ * clutter_device_manager_get_core_device:
+ * @device_manager: a #ClutterDeviceManager
+ * @device_type: the type of the core device
+ *
+ * Retrieves the core #ClutterInputDevice of type @device_type
+ *
+ * Core devices are devices created automatically by the default
+ * Clutter backend
+ *
+ * Return value: (transfer none): a #ClutterInputDevice or %NULL. The
+ *   returned device is owned by the #ClutterDeviceManager and should
+ *   not be modified or freed
+ *
+ * Since: 1.2
+ */
+ClutterInputDevice *
+clutter_device_manager_get_core_device (ClutterDeviceManager   *device_manager,
+                                        ClutterInputDeviceType  device_type)
+{
+  ClutterDeviceManagerClass *manager_class;
+
+  g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
+
+  manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
+  return manager_class->get_core_device (device_manager, device_type);
+}
+
+void
+_clutter_device_manager_select_stage_events (ClutterDeviceManager *device_manager,
+                                             ClutterStage         *stage)
+{
+  ClutterDeviceManagerClass *manager_class;
+
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
+  if (manager_class->select_stage_events)
+    manager_class->select_stage_events (device_manager, stage);
+}
+
+/*
+ * _clutter_device_manager_add_device:
+ * @device_manager: a #ClutterDeviceManager
+ * @device: a #ClutterInputDevice
+ *
+ * Adds @device to the list of #ClutterInputDevice<!-- -->s maintained
+ * by @device_manager
+ *
+ * The reference count of @device is not increased
+ *
+ * The #ClutterDeviceManager::device-added signal is emitted after
+ * adding @device to the list
+ */
+void
+_clutter_device_manager_add_device (ClutterDeviceManager *device_manager,
+                                    ClutterInputDevice   *device)
+{
+  ClutterDeviceManagerClass *manager_class;
+
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
+  g_assert (manager_class->add_device != NULL);
+
+  manager_class->add_device (device_manager, device);
+
+  g_signal_emit (device_manager, manager_signals[DEVICE_ADDED], 0, device);
+}
+
+/*
+ * _clutter_device_manager_remove_device:
+ * @device_manager: a #ClutterDeviceManager
+ * @device: a #ClutterInputDevice
+ *
+ * Removes @device from the list of #ClutterInputDevice<!-- -->s
+ * maintained by @device_manager
+ *
+ * The reference count of @device is not decreased
+ *
+ * The #ClutterDeviceManager::device-removed signal is emitted after
+ * removing @device from the list
+ */
+void
+_clutter_device_manager_remove_device (ClutterDeviceManager *device_manager,
+                                       ClutterInputDevice   *device)
+{
+  ClutterDeviceManagerClass *manager_class;
+
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
+  g_assert (manager_class->remove_device != NULL);
+
+  /* The subclass remove_device() method will likely unref it but we
+     have to keep it alive during the signal emission. */
+  g_object_ref (device);
+
+  manager_class->remove_device (device_manager, device);
+  g_signal_emit (device_manager, manager_signals[DEVICE_REMOVED], 0, device);
+
+  g_object_unref (device);
+}
+
+/*
+ * _clutter_device_manager_update_devices:
+ * @device_manager: a #ClutterDeviceManager
+ *
+ * Updates every #ClutterInputDevice handled by @device_manager
+ * by performing a pick paint at the coordinates of each pointer
+ * device
+ */
+void
+_clutter_device_manager_update_devices (ClutterDeviceManager *device_manager)
+{
+  const GSList *d;
+
+  for (d = clutter_device_manager_peek_devices (device_manager);
+       d != NULL;
+       d = d->next)
+    {
+      ClutterInputDevice *device = d->data;
+      ClutterInputDeviceType device_type;
+
+      /* we only care about pointer devices */
+      device_type = clutter_input_device_get_device_type (device);
+      if (device_type != CLUTTER_POINTER_DEVICE)
+        continue;
+
+      /* out of stage */
+      if (device->stage == NULL)
+        continue;
+
+      /* the user disabled motion events delivery on actors for
+       * the stage the device is on; we don't perform any picking
+       * since the source of the events will always be set to be
+       * the stage
+       */
+      if (!clutter_stage_get_motion_events_enabled (device->stage))
+        continue;
+
+      _clutter_input_device_update (device, NULL, TRUE);
+    }
+}
+
+ClutterBackend *
+_clutter_device_manager_get_backend (ClutterDeviceManager *manager)
+{
+  ClutterDeviceManagerPrivate *priv = clutter_device_manager_get_instance_private (manager);
+
+  g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (manager), NULL);
+
+  return priv->backend;
+}
+
+/**
+ * clutter_device_manager_create_virtual_device:
+ * @device_manager: a #ClutterDeviceManager
+ * @device_type: the type of the virtual device
+ *
+ * Creates a virtual input device.
+ *
+ * Returns: (transfer full): a newly created virtual device
+ **/
+ClutterVirtualInputDevice *
+clutter_device_manager_create_virtual_device (ClutterDeviceManager   *device_manager,
+                                              ClutterInputDeviceType  device_type)
+{
+  ClutterDeviceManagerClass *manager_class;
+
+  g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
+
+  manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
+  return manager_class->create_virtual_device (device_manager,
+                                               device_type);
+}
+
+/**
+ * clutter_device_manager_supported_virtua_device_types: (skip)
+ */
+ClutterVirtualDeviceType
+clutter_device_manager_get_supported_virtual_device_types (ClutterDeviceManager *device_manager)
+{
+  ClutterDeviceManagerClass *manager_class;
+
+  g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager),
+                        CLUTTER_VIRTUAL_DEVICE_TYPE_NONE);
+
+  manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
+  return manager_class->get_supported_virtual_device_types (device_manager);
+}
+
+void
+_clutter_device_manager_compress_motion (ClutterDeviceManager *device_manager,
+                                         ClutterEvent         *event,
+                                         const ClutterEvent   *to_discard)
+{
+  ClutterDeviceManagerClass *manager_class;
+
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+
+  manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
+  if (!manager_class->compress_motion)
+    return;
+
+  manager_class->compress_motion (device_manager, event, to_discard);
+}
+
+void
+clutter_device_manager_ensure_a11y_state (ClutterDeviceManager *device_manager)
+{
+  ClutterInputDevice *core_pointer;
+
+  core_pointer = clutter_device_manager_get_core_device (device_manager,
+                                                         CLUTTER_POINTER_DEVICE);
+  if (core_pointer)
+    {
+      if (_clutter_is_input_pointer_a11y_enabled (core_pointer))
+        _clutter_input_pointer_a11y_add_device (core_pointer);
+    }
+}
+
+static gboolean
+are_kbd_a11y_settings_equal (ClutterKbdA11ySettings *a,
+                             ClutterKbdA11ySettings *b)
+{
+  return (memcmp (a, b, sizeof (ClutterKbdA11ySettings)) == 0);
+}
+
+void
+clutter_device_manager_set_kbd_a11y_settings (ClutterDeviceManager   *device_manager,
+                                              ClutterKbdA11ySettings *settings)
+{
+  ClutterDeviceManagerClass *manager_class;
+  ClutterDeviceManagerPrivate *priv = clutter_device_manager_get_instance_private (device_manager);
+
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  if (are_kbd_a11y_settings_equal (&priv->kbd_a11y_settings, settings))
+    return;
+
+  priv->kbd_a11y_settings = *settings;
+
+  manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
+  if (manager_class->apply_kbd_a11y_settings)
+    manager_class->apply_kbd_a11y_settings (device_manager, settings);
+}
+
+void
+clutter_device_manager_get_kbd_a11y_settings (ClutterDeviceManager   *device_manager,
+                                              ClutterKbdA11ySettings *settings)
+{
+  ClutterDeviceManagerPrivate *priv = clutter_device_manager_get_instance_private (device_manager);
+
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  *settings = priv->kbd_a11y_settings;
+}
+
+static gboolean
+are_pointer_a11y_settings_equal (ClutterPointerA11ySettings *a,
+                                 ClutterPointerA11ySettings *b)
+{
+  return (memcmp (a, b, sizeof (ClutterPointerA11ySettings)) == 0);
+}
+
+static void
+clutter_device_manager_enable_pointer_a11y (ClutterDeviceManager *device_manager)
+{
+  ClutterInputDevice *core_pointer;
+
+  core_pointer = clutter_device_manager_get_core_device (device_manager,
+                                                         CLUTTER_POINTER_DEVICE);
+
+  _clutter_input_pointer_a11y_add_device (core_pointer);
+}
+
+static void
+clutter_device_manager_disable_pointer_a11y (ClutterDeviceManager *device_manager)
+{
+  ClutterInputDevice *core_pointer;
+
+  core_pointer = clutter_device_manager_get_core_device (device_manager,
+                                                         CLUTTER_POINTER_DEVICE);
+
+  _clutter_input_pointer_a11y_remove_device (core_pointer);
+}
+
+/**
+ * clutter_device_manager_set_pointer_a11y_settings:
+ * @device_manager: a #ClutterDeviceManager
+ * @settings: a pointer to a #ClutterPointerA11ySettings
+ *
+ * Sets the pointer accessibility settings
+ **/
+void
+clutter_device_manager_set_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
+                                                  ClutterPointerA11ySettings *settings)
+{
+  ClutterDeviceManagerPrivate *priv =
+    clutter_device_manager_get_instance_private (device_manager);
+
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  if (are_pointer_a11y_settings_equal (&priv->pointer_a11y_settings, settings))
+    return;
+
+  if (priv->pointer_a11y_settings.controls == 0 && settings->controls != 0)
+    clutter_device_manager_enable_pointer_a11y (device_manager);
+  else if (priv->pointer_a11y_settings.controls != 0 && settings->controls == 0)
+    clutter_device_manager_disable_pointer_a11y (device_manager);
+
+  priv->pointer_a11y_settings = *settings;
+}
+
+/**
+ * clutter_device_manager_get_pointer_a11y_settings:
+ * @device_manager: a #ClutterDeviceManager
+ * @settings: a pointer to a #ClutterPointerA11ySettings
+ *
+ * Gets the current pointer accessibility settings
+ **/
+void
+clutter_device_manager_get_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
+                                                  ClutterPointerA11ySettings *settings)
+{
+  ClutterDeviceManagerPrivate *priv =
+    clutter_device_manager_get_instance_private (device_manager);
+
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  *settings = priv->pointer_a11y_settings;
+}
+
+/**
+ * clutter_device_manager_set_pointer_a11y_dwell_click_type:
+ * @device_manager: a #ClutterDeviceManager
+ * @click_type: type of click as #ClutterPointerA11yDwellClickType
+ *
+ * Sets the dwell click type
+ **/
+void
+clutter_device_manager_set_pointer_a11y_dwell_click_type (ClutterDeviceManager             *device_manager,
+                                                          ClutterPointerA11yDwellClickType  click_type)
+{
+  ClutterDeviceManagerPrivate *priv =
+    clutter_device_manager_get_instance_private (device_manager);
+
+  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
+
+  priv->pointer_a11y_settings.dwell_click_type = click_type;
+}

clutter/clutter/clutter-device-manager.h

@@ -0,0 +1,181 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2009  Intel Corp.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Emmanuele Bassi <ebassi@linux.intel.com>
+ */
+
+#ifndef __CLUTTER_DEVICE_MANAGER_H__
+#define __CLUTTER_DEVICE_MANAGER_H__
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#include <clutter/clutter-input-device.h>
+#include <clutter/clutter-stage.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_DEVICE_MANAGER (clutter_device_manager_get_type ())
+CLUTTER_EXPORT
+G_DECLARE_DERIVABLE_TYPE (ClutterDeviceManager, clutter_device_manager,
+                          CLUTTER, DEVICE_MANAGER, GObject)
+
+typedef struct _ClutterDeviceManagerPrivate     ClutterDeviceManagerPrivate;
+
+/**
+ * ClutterVirtualDeviceType:
+ */
+typedef enum _ClutterVirtualDeviceType
+{
+  CLUTTER_VIRTUAL_DEVICE_TYPE_NONE = 0,
+  CLUTTER_VIRTUAL_DEVICE_TYPE_KEYBOARD = 1 << 0,
+  CLUTTER_VIRTUAL_DEVICE_TYPE_POINTER = 1 << 1,
+  CLUTTER_VIRTUAL_DEVICE_TYPE_TOUCHSCREEN = 1 << 2,
+} ClutterVirtualDeviceType;
+
+/**
+ * ClutterKbdA11ySettings:
+ *
+ * The #ClutterKbdA11ySettings structure contains keyboard accessibility
+ * settings
+ *
+ */
+typedef struct _ClutterKbdA11ySettings
+{
+  ClutterKeyboardA11yFlags controls;
+  gint slowkeys_delay;
+  gint debounce_delay;
+  gint timeout_delay;
+  gint mousekeys_init_delay;
+  gint mousekeys_max_speed;
+  gint mousekeys_accel_time;
+} ClutterKbdA11ySettings;
+
+/**
+ * ClutterPointerA11ySettings:
+ *
+ * The #ClutterPointerA11ySettings structure contains pointer accessibility
+ * settings
+ *
+ */
+typedef struct _ClutterPointerA11ySettings
+{
+  ClutterPointerA11yFlags controls;
+  ClutterPointerA11yDwellClickType dwell_click_type;
+  ClutterPointerA11yDwellMode dwell_mode;
+  ClutterPointerA11yDwellDirection dwell_gesture_single;
+  ClutterPointerA11yDwellDirection dwell_gesture_double;
+  ClutterPointerA11yDwellDirection dwell_gesture_drag;
+  ClutterPointerA11yDwellDirection dwell_gesture_secondary;
+  gint secondary_click_delay;
+  gint dwell_delay;
+  gint dwell_threshold;
+} ClutterPointerA11ySettings;
+
+/**
+ * ClutterDeviceManagerClass:
+ *
+ * The #ClutterDeviceManagerClass structure contains only private data
+ *
+ * Since: 1.2
+ */
+struct _ClutterDeviceManagerClass
+{
+  /*< private >*/
+  GObjectClass parent_class;
+
+  const GSList *      (* get_devices)     (ClutterDeviceManager   *device_manager);
+  ClutterInputDevice *(* get_core_device) (ClutterDeviceManager   *device_manager,
+                                           ClutterInputDeviceType  device_type);
+  ClutterInputDevice *(* get_device)      (ClutterDeviceManager   *device_manager,
+                                           gint                    device_id);
+
+  void                (* add_device)      (ClutterDeviceManager   *manager,
+                                           ClutterInputDevice     *device);
+  void                (* remove_device)   (ClutterDeviceManager   *manager,
+                                           ClutterInputDevice     *device);
+  void                (* select_stage_events) (ClutterDeviceManager *manager,
+                                               ClutterStage       *stage);
+  ClutterVirtualInputDevice *(* create_virtual_device) (ClutterDeviceManager  *device_manager,
+                                                        ClutterInputDeviceType device_type);
+  ClutterVirtualDeviceType (* get_supported_virtual_device_types) (ClutterDeviceManager *device_manager);
+  void                (* compress_motion) (ClutterDeviceManager *device_manger,
+                                           ClutterEvent         *event,
+                                           const ClutterEvent   *to_discard);
+  /* Keyboard accessbility */
+  void                (* apply_kbd_a11y_settings) (ClutterDeviceManager   *device_manger,
+                                                   ClutterKbdA11ySettings *settings);
+
+  /* Event platform data */
+  void (* copy_event_data) (ClutterDeviceManager *device_manager,
+                            const ClutterEvent   *src,
+                            ClutterEvent         *dest);
+  void (* free_event_data) (ClutterDeviceManager *device_manager,
+                            ClutterEvent         *event);
+
+  /* padding */
+  gpointer _padding[4];
+};
+
+CLUTTER_EXPORT
+ClutterDeviceManager *clutter_device_manager_get_default     (void);
+CLUTTER_EXPORT
+GSList *              clutter_device_manager_list_devices    (ClutterDeviceManager   *device_manager);
+CLUTTER_EXPORT
+const GSList *        clutter_device_manager_peek_devices    (ClutterDeviceManager   *device_manager);
+
+CLUTTER_EXPORT
+ClutterInputDevice *  clutter_device_manager_get_device      (ClutterDeviceManager   *device_manager,
+                                                              gint                    device_id);
+CLUTTER_EXPORT
+ClutterInputDevice *  clutter_device_manager_get_core_device (ClutterDeviceManager   *device_manager,
+                                                              ClutterInputDeviceType  device_type);
+
+CLUTTER_EXPORT
+ClutterVirtualInputDevice *clutter_device_manager_create_virtual_device (ClutterDeviceManager  *device_manager,
+                                                                         ClutterInputDeviceType device_type);
+
+CLUTTER_EXPORT
+ClutterVirtualDeviceType clutter_device_manager_get_supported_virtual_device_types (ClutterDeviceManager *device_manager);
+
+CLUTTER_EXPORT
+void clutter_device_manager_set_kbd_a11y_settings (ClutterDeviceManager   *device_manager,
+                                                   ClutterKbdA11ySettings *settings);
+
+CLUTTER_EXPORT
+void clutter_device_manager_get_kbd_a11y_settings (ClutterDeviceManager   *device_manager,
+                                                   ClutterKbdA11ySettings *settings);
+
+CLUTTER_EXPORT
+void clutter_device_manager_set_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
+                                                       ClutterPointerA11ySettings *settings);
+
+CLUTTER_EXPORT
+void clutter_device_manager_get_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
+                                                       ClutterPointerA11ySettings *settings);
+
+CLUTTER_EXPORT
+void clutter_device_manager_set_pointer_a11y_dwell_click_type (ClutterDeviceManager             *device_manager,
+                                                               ClutterPointerA11yDwellClickType  click_type);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_DEVICE_MANAGER_H__ */

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

@@ -230,26 +230,28 @@ clutter_effect_real_pick (ClutterEffect      *effect,
 }
 
 static void
-clutter_effect_set_enabled (ClutterActorMeta *meta,
+clutter_effect_notify (GObject    *gobject,
-                            gboolean          is_enabled)
+                       GParamSpec *pspec)
 {
-  ClutterActorMetaClass *parent_class =
+  if (strcmp (pspec->name, "enabled") == 0)
-    CLUTTER_ACTOR_META_CLASS (clutter_effect_parent_class);
+    {
-  ClutterActor *actor;
+      ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject);
+      ClutterActor *actor = clutter_actor_meta_get_actor (meta);
 
-  actor = clutter_actor_meta_get_actor (meta);
+      if (actor != NULL)
-  if (actor)
+        clutter_actor_queue_redraw (actor);
-    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;

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">
@@ -535,13 +535,9 @@ typedef enum /*< prefix=CLUTTER_ACTOR >*/
  * ClutterOffscreenRedirect:
  * @CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY: Only redirect
  *   the actor if it is semi-transparent and its has_overlaps()
- *   virtual returns %TRUE.
+ *   virtual returns %TRUE. This is the default.
  * @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_AUTOMATIC_FOR_OPACITY = 1<<0,
-  CLUTTER_OFFSCREEN_REDIRECT_ALWAYS                = 1 << 1,
+  CLUTTER_OFFSCREEN_REDIRECT_ALWAYS = 1<<1
-  CLUTTER_OFFSCREEN_REDIRECT_ON_IDLE               = 1 << 2
 } ClutterOffscreenRedirect;
 
+/**
+ * ClutterAllocationFlags:
+ * @CLUTTER_ALLOCATION_NONE: No flag set
+ * @CLUTTER_ABSOLUTE_ORIGIN_CHANGED: Whether the absolute origin of the
+ *   actor has changed; this implies that any ancestor of the actor has
+ *   been moved.
+ * @CLUTTER_DELEGATE_LAYOUT: Whether the allocation should be delegated
+ *   to the #ClutterLayoutManager instance stored inside the
+ *   #ClutterActor:layout-manager property of #ClutterActor. This flag
+ *   should only be used if you are subclassing #ClutterActor and
+ *   overriding the #ClutterActorClass.allocate() virtual function, but
+ *   you wish to use the default implementation of the virtual function
+ *   inside #ClutterActor. Added in Clutter 1.10.
+ *
+ * Flags passed to the #ClutterActorClass.allocate() virtual function
+ * and to the clutter_actor_allocate() function.
+ *
+ * Since: 1.0
+ */
+typedef enum
+{
+  CLUTTER_ALLOCATION_NONE         = 0,
+  CLUTTER_ABSOLUTE_ORIGIN_CHANGED = 1 << 1,
+  CLUTTER_DELEGATE_LAYOUT         = 1 << 2
+} ClutterAllocationFlags;
+
 /**
  * ClutterAlignAxis:
  * @CLUTTER_ALIGN_X_AXIS: Maintain the alignment on the X axis
@@ -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_ACTOR_DIRTY = (1 << 0)
-  CLUTTER_EFFECT_PAINT_BYPASS_EFFECT = (1 << 1)
 } 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,11 +140,7 @@ clutter_fixed_layout_allocate (ClutterLayoutManager   *manager,
        child != NULL;
        child = clutter_actor_get_next_sibling (child))
     {
-      float x = 0.f;
+      clutter_actor_allocate_preferred_size (child, flags);
-      float y = 0.f;
-
-      clutter_actor_get_fixed_position (child, &x, &y);
-      clutter_actor_allocate_preferred_size (child, x, y);
     }
 }
 

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 =
+  ClutterGestureActionPrivate *priv = action->priv;
-    clutter_gesture_action_get_instance_private (action);
   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 =
+  ClutterGestureActionPrivate *priv = action->priv;
-    clutter_gesture_action_get_instance_private (action);
   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 =
+  ClutterGestureActionPrivate *priv = action->priv;
-    clutter_gesture_action_get_instance_private (action);
 
-  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 =
+  ClutterGestureActionPrivate *priv = action->priv;
-    clutter_gesture_action_get_instance_private (action);
   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 =
+  ClutterGestureActionPrivate *priv = action->priv;
-    clutter_gesture_action_get_instance_private (action);
   gboolean return_value;
 
   priv->in_gesture = TRUE;
@@ -358,8 +353,7 @@ stage_captured_event_cb (ClutterActor         *stage,
                          ClutterEvent         *event,
                          ClutterGestureAction *action)
 {
-  ClutterGestureActionPrivate *priv =
+  ClutterGestureActionPrivate *priv = action->priv;
-    clutter_gesture_action_get_instance_private (action);
   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 =
+  ClutterGestureActionPrivate *priv = action->priv;
-    clutter_gesture_action_get_instance_private (action);
   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 =
+  ClutterGestureActionPrivate *priv = CLUTTER_GESTURE_ACTION (meta)->priv;
-    clutter_gesture_action_get_instance_private (CLUTTER_GESTURE_ACTION (meta));
   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,
+      clutter_gesture_action_set_threshold_trigger_distance (self, g_value_get_float (value), self->priv->distance_y);
-                                                             g_value_get_float (value),
-                                                             priv->distance_y);
       break;
 
     case PROP_THRESHOLD_TRIGGER_DISTANCE_Y:
-      clutter_gesture_action_set_threshold_trigger_distance (self,
+      clutter_gesture_action_set_threshold_trigger_distance (self, self->priv->distance_x, g_value_get_float (value));
-                                                             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 =
+  ClutterGestureAction *self = CLUTTER_GESTURE_ACTION (gobject);
-    clutter_gesture_action_get_instance_private (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)
+      if (self->priv->distance_x > 0.0)
-        g_value_set_float (value, priv->distance_x);
+        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)
+      if (self->priv->distance_y > 0.0)
-        g_value_set_float (value, priv->distance_y);
+        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 =
+  ClutterGestureActionPrivate *priv = CLUTTER_GESTURE_ACTION (gobject)->priv;
-    clutter_gesture_action_get_instance_private (CLUTTER_GESTURE_ACTION (gobject));
 
   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 =
+  self->priv = clutter_gesture_action_get_instance_private (self);
-    clutter_gesture_action_get_instance_private (self);
 
-  priv->points = g_array_sized_new (FALSE, TRUE, sizeof (GesturePoint), 3);
+  self->priv->points = g_array_sized_new (FALSE, TRUE, sizeof (GesturePoint), 3);
-  g_array_set_clear_func (priv->points, (GDestroyNotify) gesture_point_unset);
+  g_array_set_clear_func (self->priv->points, (GDestroyNotify) gesture_point_unset);
 
-  priv->requested_nb_points = 1;
+  self->priv->requested_nb_points = 1;
-  priv->edge = CLUTTER_GESTURE_TRIGGER_EDGE_NONE;
+  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));
-
+  g_return_if_fail (action->priv->points->len > point);
-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_if_fail (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));
-
+  g_return_if_fail (action->priv->points->len > point);
-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_if_fail (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);
+  d_x = g_array_index (action->priv->points,
-
-  g_return_val_if_fail (priv->points->len > point, 0);
-
-  d_x = g_array_index (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));
-
+  g_return_if_fail (action->priv->points->len > point);
-  priv = clutter_gesture_action_get_instance_private (action);
-
-  g_return_if_fail (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);
-
+  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);
 
   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 action->priv->requested_nb_points;
-
-  return 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 action->priv->points->len;
-
-  return 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);
+  return g_array_index (action->priv->points, GesturePoint, point).sequence;
-
-  g_return_val_if_fail (priv->points->len > point, NULL);
-
-  return g_array_index (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);
+  return g_array_index (action->priv->points, GesturePoint, point).device;
-
-  g_return_val_if_fail (priv->points->len > point, NULL);
-
-  return g_array_index (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);
+  gesture_point = &g_array_index (action->priv->points, GesturePoint, point);
-
-  g_return_val_if_fail (priv->points->len > point, NULL);
-
-  gesture_point = &g_array_index (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 (action->priv->edge == edge)
-
-  if (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 action->priv->edge;
-
-  return 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 - action->priv->distance_x) > FLOAT_EPSILON)
-
-  if (fabsf (x - 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)
+      if (action->priv->distance_x > 0.0)
-        *x = priv->distance_x;
+        *x = action->priv->distance_x;
       else
         *x = gesture_get_default_threshold ();
     }
   if (y != NULL)
     {
-      if (priv->distance_y > 0.0)
+      if (action->priv->distance_y > 0.0)
-        *y = priv->distance_y;
+        *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
+typedef struct _ClutterGestureAction              ClutterGestureAction;
-G_DECLARE_DERIVABLE_TYPE (ClutterGestureAction, clutter_gesture_action,
+typedef struct _ClutterGestureActionPrivate       ClutterGestureActionPrivate;
-                          CLUTTER, GESTURE_ACTION, ClutterAction);
+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-private.h

@@ -1,255 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Copyright © 2009, 2010, 2011  Intel Corp.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Author: Emmanuele Bassi <ebassi@linux.intel.com>
- */
-
-#ifndef CLUTTER_INPUT_DEVICE_PRIVATE_H
-#define CLUTTER_INPUT_DEVICE_PRIVATE_H
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#include <clutter/clutter-input-device.h>
-
-G_BEGIN_DECLS
-
-typedef struct _ClutterAxisInfo
-{
-  ClutterInputAxis axis;
-
-  double min_axis;
-  double max_axis;
-
-  double min_value;
-  double max_value;
-
-  double resolution;
-} ClutterAxisInfo;
-
-typedef struct _ClutterKeyInfo
-{
-  guint keyval;
-  ClutterModifierType modifiers;
-} ClutterKeyInfo;
-
-typedef struct _ClutterScrollInfo
-{
-  guint axis_id;
-  ClutterScrollDirection direction;
-  double increment;
-
-  double last_value;
-  guint last_value_valid : 1;
-} ClutterScrollInfo;
-
-typedef struct _ClutterTouchInfo
-{
-  ClutterEventSequence *sequence;
-  ClutterActor *actor;
-
-  float current_x;
-  float current_y;
-} ClutterTouchInfo;
-
-typedef struct _ClutterPtrA11yData
-{
-  int n_btn_pressed;
-  float current_x;
-  float current_y;
-
-  float dwell_x;
-  float dwell_y;
-  gboolean dwell_drag_started;
-  gboolean dwell_gesture_started;
-  guint dwell_timer;
-  guint dwell_position_timer;
-
-  guint secondary_click_timer;
-  gboolean secondary_click_triggered;
-} ClutterPtrA11yData;
-
-struct _ClutterInputDevice
-{
-  GObject parent_instance;
-
-  int id;
-
-  ClutterInputDeviceType device_type;
-  ClutterInputMode device_mode;
-
-  char *device_name;
-
-  ClutterSeat *seat;
-
-  ClutterBackend *backend;
-
-  /* the associated device */
-  ClutterInputDevice *associated;
-
-  GList *slaves;
-
-  /* the actor underneath the pointer */
-  ClutterActor *cursor_actor;
-  GHashTable   *inv_touch_sequence_actors;
-
-  /* the actor that has a grab in place for the device */
-  ClutterActor *pointer_grab_actor;
-  ClutterActor *keyboard_grab_actor;
-  GHashTable   *sequence_grab_actors;
-  GHashTable   *inv_sequence_grab_actors;
-
-  /* the current click count */
-  int click_count;
-
-  /* the stage the device is on */
-  ClutterStage *stage;
-
-  /* the current state */
-  float current_x;
-  float current_y;
-  uint32_t current_time;
-  int current_button_number;
-  ClutterModifierType current_state;
-
-  /* the current touch points states */
-  GHashTable *touch_sequences_info;
-
-  /* the previous state, used for click count generation */
-  int previous_x;
-  int previous_y;
-  uint32_t previous_time;
-  int previous_button_number;
-  ClutterModifierType previous_state;
-
-  GArray *axes;
-
-  guint n_keys;
-  GArray *keys;
-
-  GArray *scroll_info;
-
-  char *vendor_id;
-  char *product_id;
-  char *node_path;
-
-  GPtrArray *tools;
-
-  int n_rings;
-  int n_strips;
-  int n_mode_groups;
-
-  ClutterInputDeviceMapping mapping_mode;
-
-  guint has_cursor : 1;
-  guint is_enabled : 1;
-
-  /* Accessiblity */
-  ClutterVirtualInputDevice *accessibility_virtual_device;
-  ClutterPtrA11yData *ptr_a11y_data;
-};
-
-CLUTTER_EXPORT
-void _clutter_input_device_set_associated_device (ClutterInputDevice *device,
-                                                  ClutterInputDevice *associated);
-CLUTTER_EXPORT
-void _clutter_input_device_add_slave (ClutterInputDevice *master,
-                                      ClutterInputDevice *slave);
-CLUTTER_EXPORT
-void _clutter_input_device_remove_slave (ClutterInputDevice *master,
-                                         ClutterInputDevice *slave);
-CLUTTER_EXPORT
-void clutter_input_device_update_from_tool (ClutterInputDevice     *device,
-                                            ClutterInputDeviceTool *tool);
-CLUTTER_EXPORT
-ClutterStage * _clutter_input_device_get_stage (ClutterInputDevice *device);
-CLUTTER_EXPORT
-void _clutter_input_device_set_stage (ClutterInputDevice *device,
-                                      ClutterStage       *stage);
-CLUTTER_EXPORT
-void _clutter_input_device_set_coords (ClutterInputDevice   *device,
-                                       ClutterEventSequence *sequence,
-                                       gfloat                x,
-                                       gfloat                y,
-                                       ClutterStage         *stage);
-CLUTTER_EXPORT
-void _clutter_input_device_set_state (ClutterInputDevice  *device,
-                                      ClutterModifierType  state);
-CLUTTER_EXPORT
-void _clutter_input_device_set_time (ClutterInputDevice *device,
-                                     guint32             time_);
-void _clutter_input_device_set_actor (ClutterInputDevice   *device,
-                                      ClutterEventSequence *sequence,
-                                      ClutterActor         *actor,
-                                      gboolean              emit_crossing);
-CLUTTER_EXPORT
-ClutterActor * clutter_input_device_update (ClutterInputDevice   *device,
-					    ClutterEventSequence *sequence,
-					    gboolean              emit_crossing);
-CLUTTER_EXPORT
-void _clutter_input_device_add_event_sequence (ClutterInputDevice *device,
-                                               ClutterEvent       *event);
-CLUTTER_EXPORT
-void _clutter_input_device_remove_event_sequence (ClutterInputDevice *device,
-                                                  ClutterEvent       *event);
-CLUTTER_EXPORT
-void _clutter_input_device_set_n_keys (ClutterInputDevice *device,
-                                       guint               n_keys);
-CLUTTER_EXPORT
-gboolean _clutter_input_device_translate_axis (ClutterInputDevice *device,
-                                               guint               index_,
-                                               gdouble             value,
-                                               gdouble            *axis_value);
-CLUTTER_EXPORT
-guint _clutter_input_device_add_axis (ClutterInputDevice *device,
-                                      ClutterInputAxis    axis,
-                                      gdouble             minimum,
-                                      gdouble             maximum,
-                                      gdouble             resolution);
-
-CLUTTER_EXPORT
-void _clutter_input_device_reset_axes (ClutterInputDevice *device);
-
-CLUTTER_EXPORT
-void _clutter_input_device_add_scroll_info (ClutterInputDevice     *device,
-                                            guint                   index_,
-                                            ClutterScrollDirection  direction,
-                                            gdouble                 increment);
-CLUTTER_EXPORT
-gboolean _clutter_input_device_get_scroll_delta (ClutterInputDevice     *device,
-                                                 guint                   index_,
-                                                 gdouble                 value,
-                                                 ClutterScrollDirection *direction_p,
-                                                 gdouble                *delta_p);
-CLUTTER_EXPORT
-void _clutter_input_device_reset_scroll_info (ClutterInputDevice *device);
-
-CLUTTER_EXPORT
-void clutter_input_device_add_tool (ClutterInputDevice     *device,
-                                    ClutterInputDeviceTool *tool);
-
-CLUTTER_EXPORT
-ClutterInputDeviceTool *
-   clutter_input_device_lookup_tool (ClutterInputDevice         *device,
-                                     guint64                     serial,
-                                     ClutterInputDeviceToolType  type);
-
-#endif /* CLUTTER_INPUT_DEVICE_PRIVATE_H */

clutter/clutter/clutter-input-device.c

@@ -37,12 +37,12 @@
 
 #include "clutter-actor-private.h"
 #include "clutter-debug.h"
+#include "clutter-device-manager-private.h"
 #include "clutter-enum-types.h"
 #include "clutter-event-private.h"
 #include "clutter-marshal.h"
 #include "clutter-private.h"
 #include "clutter-stage-private.h"
-#include "clutter-input-device-private.h"
 #include "clutter-input-device-tool.h"
 
 #include <math.h>
@@ -57,7 +57,7 @@ enum
   PROP_NAME,
 
   PROP_DEVICE_TYPE,
-  PROP_SEAT,
+  PROP_DEVICE_MANAGER,
   PROP_DEVICE_MODE,
 
   PROP_HAS_CURSOR,
@@ -96,7 +96,6 @@ clutter_input_device_dispose (GObject *gobject)
   g_clear_pointer (&device->device_name, g_free);
   g_clear_pointer (&device->vendor_id, g_free);
   g_clear_pointer (&device->product_id, g_free);
-  g_clear_pointer (&device->node_path, g_free);
 
   if (device->associated != NULL)
     {
@@ -171,8 +170,8 @@ clutter_input_device_set_property (GObject      *gobject,
       self->device_type = g_value_get_enum (value);
       break;
 
-    case PROP_SEAT:
+    case PROP_DEVICE_MANAGER:
-      self->seat = g_value_get_object (value);
+      self->device_manager = g_value_get_object (value);
       break;
 
     case PROP_DEVICE_MODE:
@@ -247,8 +246,8 @@ clutter_input_device_get_property (GObject    *gobject,
       g_value_set_enum (value, self->device_type);
       break;
 
-    case PROP_SEAT:
+    case PROP_DEVICE_MANAGER:
-      g_value_set_object (value, self->seat);
+      g_value_set_object (value, self->device_manager);
       break;
 
     case PROP_DEVICE_MODE:
@@ -362,15 +361,17 @@ clutter_input_device_class_init (ClutterInputDeviceClass *klass)
                        G_PARAM_CONSTRUCT_ONLY);
 
   /**
-   * ClutterInputDevice:seat:
+   * ClutterInputDevice:device-manager:
    *
-   * The #ClutterSeat instance which owns the device
+   * The #ClutterDeviceManager instance which owns the device
+   *
+   * Since: 1.6
    */
-  obj_props[PROP_SEAT] =
+  obj_props[PROP_DEVICE_MANAGER] =
-    g_param_spec_object ("seat",
+    g_param_spec_object ("device-manager",
-                         P_("Seat"),
+                         P_("Device Manager"),
-                         P_("Seat"),
+                         P_("The device manager instance"),
-                         CLUTTER_TYPE_SEAT,
+                         CLUTTER_TYPE_DEVICE_MANAGER,
                          CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
 
   /**
@@ -692,6 +693,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,
@@ -784,7 +799,7 @@ on_cursor_actor_reactive_changed (ClutterActor       *actor,
  *
  * Sets the actor under the pointer coordinates of @device
  *
- * This function is called by clutter_input_device_update()
+ * This function is called by _clutter_input_device_update()
  * and it will:
  *
  *   - queue a %CLUTTER_LEAVE event on the previous pointer actor
@@ -801,7 +816,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 +851,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);
@@ -1002,7 +1017,7 @@ clutter_input_device_get_coords (ClutterInputDevice   *device,
 }
 
 /*
- * clutter_input_device_update:
+ * _clutter_input_device_update:
  * @device: a #ClutterInputDevice
  *
  * Updates the input @device by determining the #ClutterActor underneath the
@@ -1016,9 +1031,9 @@ clutter_input_device_get_coords (ClutterInputDevice   *device,
  * Since: 1.2
  */
 ClutterActor *
-clutter_input_device_update (ClutterInputDevice   *device,
+_clutter_input_device_update (ClutterInputDevice   *device,
-                             ClutterEventSequence *sequence,
+                              ClutterEventSequence *sequence,
-                             gboolean              emit_crossing)
+                              gboolean              emit_crossing)
 {
   ClutterStage *stage;
   ClutterActor *new_cursor_actor;
@@ -1040,7 +1055,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 +1086,22 @@ clutter_input_device_update (ClutterInputDevice   *device,
 }
 
 /**
- * clutter_input_device_get_actor:
+ * clutter_input_device_get_pointer_actor:
- * @device: a #ClutterInputDevice
+ * @device: a #ClutterInputDevice of type %CLUTTER_POINTER_DEVICE
- * @sequence: (allow-none): an optional #ClutterEventSequence
  *
- * Retrieves the #ClutterActor underneath the pointer or touchpoint
+ * Retrieves the #ClutterActor underneath the pointer of @device
- * of @device and @sequence.
  *
  * Return value: (transfer none): a pointer to the #ClutterActor or %NULL
  *
  * Since: 1.2
  */
 ClutterActor *
-clutter_input_device_get_actor (ClutterInputDevice   *device,
+clutter_input_device_get_pointer_actor (ClutterInputDevice *device)
-                                ClutterEventSequence *sequence)
 {
-  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;
-    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;
 }
 
 /**
@@ -1220,11 +1224,11 @@ clutter_input_device_get_device_mode (ClutterInputDevice *device)
  *
  *   translate_native_event_to_clutter (native_event, &c_event);
  *
- *   // get the seat
+ *   // get the device manager
- *   seat = clutter_backend_get_deafult_seat (clutter_get_default_backend ());
+ *   manager = clutter_device_manager_get_default ();
  *
  *   // use the default Core Pointer that Clutter backends register by default
- *   device = clutter_seat_get_pointer (seat);
+ *   device = clutter_device_manager_get_core_device (manager, %CLUTTER_POINTER_DEVICE);
  *
  *   // update the state of the input device
  *   clutter_input_device_update_from_event (device, &c_event, FALSE);
@@ -2437,19 +2441,3 @@ clutter_input_device_is_grouped (ClutterInputDevice *device,
 
   return CLUTTER_INPUT_DEVICE_GET_CLASS (device)->is_grouped (device, other_device);
 }
-
-/**
- * clutter_input_device_get_seat:
- * @device: a #ClutterInputDevice
- *
- * Returns the seat the device belongs to
- *
- * Returns: (transfer none): the device seat
- **/
-ClutterSeat *
-clutter_input_device_get_seat (ClutterInputDevice *device)
-{
-  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), NULL);
-
-  return device->seat;
-}

clutter/clutter/clutter-input-device.h

@@ -28,40 +28,10 @@
 #error "Only <clutter/clutter.h> can be included directly."
 #endif
 
-#include <clutter/clutter-backend.h>
 #include <clutter/clutter-types.h>
-#include <clutter/clutter-seat.h>
 
 G_BEGIN_DECLS
 
-typedef void (*ClutterEmitInputDeviceEvent) (ClutterEvent       *event,
-                                             ClutterInputDevice *device);
-
-struct _ClutterInputDeviceClass
-{
-  GObjectClass parent_class;
-
-  gboolean (* keycode_to_evdev) (ClutterInputDevice *device,
-                                 guint               hardware_keycode,
-                                 guint              *evdev_keycode);
-  void (* update_from_tool) (ClutterInputDevice     *device,
-                             ClutterInputDeviceTool *tool);
-
-  gboolean (* is_mode_switch_button) (ClutterInputDevice *device,
-                                      guint               group,
-                                      guint               button);
-  gint (* get_group_n_modes) (ClutterInputDevice *device,
-                              gint                group);
-
-  gboolean (* is_grouped) (ClutterInputDevice *device,
-                           ClutterInputDevice *other_device);
-
-  /* Keyboard accessbility */
-  void (* process_kbd_a11y_event) (ClutterEvent               *event,
-                                   ClutterInputDevice         *device,
-                                   ClutterEmitInputDeviceEvent emit_event_func);
-};
-
 #define CLUTTER_TYPE_INPUT_DEVICE               (clutter_input_device_get_type ())
 #define CLUTTER_INPUT_DEVICE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_INPUT_DEVICE, ClutterInputDevice))
 #define CLUTTER_IS_INPUT_DEVICE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_INPUT_DEVICE))
@@ -92,8 +62,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,
+ClutterActor *          clutter_input_device_get_pointer_actor  (ClutterInputDevice  *device);
-                                                        ClutterEventSequence *sequence);
 CLUTTER_EXPORT
 ClutterStage *          clutter_input_device_get_pointer_stage  (ClutterInputDevice  *device);
 CLUTTER_EXPORT
@@ -202,8 +171,6 @@ void                      clutter_input_device_set_mapping_mode (ClutterInputDev
 CLUTTER_EXPORT
 gboolean                  clutter_input_device_is_grouped       (ClutterInputDevice *device,
                                                                  ClutterInputDevice *other_device);
-CLUTTER_EXPORT
-ClutterSeat *             clutter_input_device_get_seat         (ClutterInputDevice *device);
 
 G_END_DECLS
 

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

@@ -22,10 +22,10 @@
 #include "clutter-build-config.h"
 
 #include "clutter-private.h"
-#include "clutter/clutter-input-device-private.h"
 #include "clutter/clutter-input-method.h"
 #include "clutter/clutter-input-method-private.h"
 #include "clutter/clutter-input-focus-private.h"
+#include "clutter/clutter-device-manager-private.h"
 
 typedef struct _ClutterInputMethodPrivate ClutterInputMethodPrivate;
 
@@ -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;
@@ -452,8 +452,8 @@ clutter_input_method_forward_key (ClutterInputMethod *im,
                                   gboolean            press)
 {
   ClutterInputMethodPrivate *priv;
+  ClutterDeviceManager *device_manager;
   ClutterInputDevice *keyboard;
-  ClutterSeat *seat;
   ClutterStage *stage;
   ClutterEvent *event;
 
@@ -463,8 +463,9 @@ clutter_input_method_forward_key (ClutterInputMethod *im,
   if (!priv->focus)
     return;
 
-  seat = clutter_backend_get_default_seat (clutter_get_default_backend ());
+  device_manager = clutter_device_manager_get_default ();
-  keyboard = clutter_seat_get_keyboard (seat);
+  keyboard = clutter_device_manager_get_core_device (device_manager,
+                                                     CLUTTER_KEYBOARD_DEVICE);
   stage = _clutter_input_device_get_stage (keyboard);
   if (stage == NULL)
     return;

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-input-pointer-a11y.c

@@ -25,9 +25,10 @@
 
 #include "clutter-build-config.h"
 
+#include "clutter-device-manager.h"
+#include "clutter-device-manager-private.h"
 #include "clutter-enum-types.h"
 #include "clutter-input-device.h"
-#include "clutter-input-device-private.h"
 #include "clutter-input-pointer-a11y-private.h"
 #include "clutter-main.h"
 #include "clutter-virtual-input-device.h"
@@ -37,7 +38,7 @@ is_secondary_click_enabled (ClutterInputDevice *device)
 {
   ClutterPointerA11ySettings settings;
 
-  clutter_seat_get_pointer_a11y_settings (device->seat, &settings);
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
 
   return (settings.controls & CLUTTER_A11Y_SECONDARY_CLICK_ENABLED);
 }
@@ -47,7 +48,7 @@ is_dwell_click_enabled (ClutterInputDevice *device)
 {
   ClutterPointerA11ySettings settings;
 
-  clutter_seat_get_pointer_a11y_settings (device->seat, &settings);
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
 
   return (settings.controls & CLUTTER_A11Y_DWELL_ENABLED);
 }
@@ -57,7 +58,7 @@ get_secondary_click_delay (ClutterInputDevice *device)
 {
   ClutterPointerA11ySettings settings;
 
-  clutter_seat_get_pointer_a11y_settings (device->seat, &settings);
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
 
   return settings.secondary_click_delay;
 }
@@ -67,7 +68,7 @@ get_dwell_delay (ClutterInputDevice *device)
 {
   ClutterPointerA11ySettings settings;
 
-  clutter_seat_get_pointer_a11y_settings (device->seat, &settings);
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
 
   return settings.dwell_delay;
 }
@@ -77,7 +78,7 @@ get_dwell_threshold (ClutterInputDevice *device)
 {
   ClutterPointerA11ySettings settings;
 
-  clutter_seat_get_pointer_a11y_settings (device->seat, &settings);
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
 
   return settings.dwell_threshold;
 }
@@ -87,7 +88,7 @@ get_dwell_mode (ClutterInputDevice *device)
 {
   ClutterPointerA11ySettings settings;
 
-  clutter_seat_get_pointer_a11y_settings (device->seat, &settings);
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
 
   return settings.dwell_mode;
 }
@@ -97,7 +98,7 @@ get_dwell_click_type (ClutterInputDevice *device)
 {
   ClutterPointerA11ySettings settings;
 
-  clutter_seat_get_pointer_a11y_settings (device->seat, &settings);
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
 
   return settings.dwell_click_type;
 }
@@ -108,7 +109,7 @@ get_dwell_click_type_for_direction (ClutterInputDevice               *device,
 {
   ClutterPointerA11ySettings settings;
 
-  clutter_seat_get_pointer_a11y_settings (device->seat, &settings);
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
 
   if (direction == settings.dwell_gesture_single)
     return CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY;
@@ -167,7 +168,7 @@ trigger_secondary_click (gpointer data)
   device->ptr_a11y_data->secondary_click_triggered = TRUE;
   device->ptr_a11y_data->secondary_click_timer = 0;
 
-  g_signal_emit_by_name (device->seat,
+  g_signal_emit_by_name (device->device_manager,
                          "ptr-a11y-timeout-stopped",
                          device,
                          CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK,
@@ -184,7 +185,7 @@ start_secondary_click_timeout (ClutterInputDevice *device)
   device->ptr_a11y_data->secondary_click_timer =
     clutter_threads_add_timeout (delay, trigger_secondary_click, device);
 
-  g_signal_emit_by_name (device->seat,
+  g_signal_emit_by_name (device->device_manager,
                          "ptr-a11y-timeout-started",
                          device,
                          CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK,
@@ -199,7 +200,7 @@ stop_secondary_click_timeout (ClutterInputDevice *device)
       g_clear_handle_id (&device->ptr_a11y_data->secondary_click_timer,
                          g_source_remove);
 
-      g_signal_emit_by_name (device->seat,
+      g_signal_emit_by_name (device->device_manager,
                              "ptr-a11y-timeout-stopped",
                              device,
                              CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK,
@@ -303,7 +304,7 @@ update_dwell_click_type (ClutterInputDevice *device)
   ClutterPointerA11ySettings settings;
   ClutterPointerA11yDwellClickType dwell_click_type;
 
-  clutter_seat_get_pointer_a11y_settings (device->seat, &settings);
+  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
 
   dwell_click_type = settings.dwell_click_type;
   switch (dwell_click_type)
@@ -328,9 +329,10 @@ update_dwell_click_type (ClutterInputDevice *device)
   if (dwell_click_type != settings.dwell_click_type)
     {
       settings.dwell_click_type = dwell_click_type;
-      clutter_seat_set_pointer_a11y_settings (device->seat, &settings);
+      clutter_device_manager_set_pointer_a11y_settings (device->device_manager,
+                                                        &settings);
 
-      g_signal_emit_by_name (device->seat,
+      g_signal_emit_by_name (device->device_manager,
                              "ptr-a11y-dwell-click-type-changed",
                              dwell_click_type);
     }
@@ -435,7 +437,7 @@ trigger_dwell_gesture (gpointer data)
   device->ptr_a11y_data->dwell_timer =
     clutter_threads_add_timeout (delay, trigger_clear_dwell_gesture, device);
 
-  g_signal_emit_by_name (device->seat,
+  g_signal_emit_by_name (device->device_manager,
                          "ptr-a11y-timeout-stopped",
                          device,
                          CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE,
@@ -453,7 +455,7 @@ start_dwell_gesture_timeout (ClutterInputDevice *device)
     clutter_threads_add_timeout (delay, trigger_dwell_gesture, device);
   device->ptr_a11y_data->dwell_gesture_started = TRUE;
 
-  g_signal_emit_by_name (device->seat,
+  g_signal_emit_by_name (device->device_manager,
                          "ptr-a11y-timeout-started",
                          device,
                          CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE,
@@ -467,7 +469,7 @@ trigger_dwell_click (gpointer data)
 
   device->ptr_a11y_data->dwell_timer = 0;
 
-  g_signal_emit_by_name (device->seat,
+  g_signal_emit_by_name (device->device_manager,
                          "ptr-a11y-timeout-stopped",
                          device,
                          CLUTTER_A11Y_TIMEOUT_TYPE_DWELL,
@@ -497,7 +499,7 @@ start_dwell_timeout (ClutterInputDevice *device)
   device->ptr_a11y_data->dwell_timer =
     clutter_threads_add_timeout (delay, trigger_dwell_click, device);
 
-  g_signal_emit_by_name (device->seat,
+  g_signal_emit_by_name (device->device_manager,
                          "ptr-a11y-timeout-started",
                          device,
                          CLUTTER_A11Y_TIMEOUT_TYPE_DWELL,
@@ -512,7 +514,7 @@ stop_dwell_timeout (ClutterInputDevice *device)
       g_clear_handle_id (&device->ptr_a11y_data->dwell_timer, g_source_remove);
       device->ptr_a11y_data->dwell_gesture_started = FALSE;
 
-      g_signal_emit_by_name (device->seat,
+      g_signal_emit_by_name (device->device_manager,
                              "ptr-a11y-timeout-stopped",
                              device,
                              CLUTTER_A11Y_TIMEOUT_TYPE_DWELL,
@@ -571,7 +573,8 @@ is_device_core_pointer (ClutterInputDevice *device)
 {
   ClutterInputDevice *core_pointer;
 
-  core_pointer = clutter_seat_get_pointer (device->seat);
+  core_pointer = clutter_device_manager_get_core_device (device->device_manager,
+                                                         CLUTTER_POINTER_DEVICE);
   if (core_pointer == NULL)
     return FALSE;
 
@@ -585,8 +588,8 @@ _clutter_input_pointer_a11y_add_device (ClutterInputDevice *device)
     return;
 
   device->accessibility_virtual_device =
-    clutter_seat_create_virtual_device (device->seat,
+    clutter_device_manager_create_virtual_device (device->device_manager,
-                                        CLUTTER_POINTER_DEVICE);
+                                                  CLUTTER_POINTER_DEVICE);
 
   device->ptr_a11y_data = g_new0 (ClutterPtrA11yData, 1);
 }

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-keymap.c

@@ -62,9 +62,3 @@ clutter_keymap_get_caps_lock_state (ClutterKeymap *keymap)
 {
   return CLUTTER_KEYMAP_GET_CLASS (keymap)->get_caps_lock_state (keymap);
 }
-
-PangoDirection
-clutter_keymap_get_direction (ClutterKeymap *keymap)
-{
-  return CLUTTER_KEYMAP_GET_CLASS (keymap)->get_direction (keymap);
-}

clutter/clutter/clutter-keymap.h

@@ -29,7 +29,6 @@
 #include <clutter/clutter-macros.h>
 
 #include <glib-object.h>
-#include <pango/pango.h>
 
 typedef struct _ClutterKeymap ClutterKeymap;
 typedef struct _ClutterKeymapClass ClutterKeymapClass;
@@ -40,7 +39,6 @@ struct _ClutterKeymapClass
 
   gboolean (* get_num_lock_state)  (ClutterKeymap *keymap);
   gboolean (* get_caps_lock_state) (ClutterKeymap *keymap);
-  PangoDirection (* get_direction) (ClutterKeymap *keymap);
 };
 
 #define CLUTTER_TYPE_KEYMAP (clutter_keymap_get_type ())
@@ -55,6 +53,4 @@ gboolean clutter_keymap_get_num_lock_state  (ClutterKeymap *keymap);
 CLUTTER_EXPORT
 gboolean clutter_keymap_get_caps_lock_state (ClutterKeymap *keymap);
 
-PangoDirection clutter_keymap_get_direction (ClutterKeymap *keymap);
-
 #endif /* CLUTTER_KEYMAP_H */

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

@@ -55,14 +55,14 @@
 #include "clutter-backend-private.h"
 #include "clutter-config.h"
 #include "clutter-debug.h"
+#include "clutter-device-manager-private.h"
 #include "clutter-event-private.h"
 #include "clutter-feature.h"
-#include "clutter-input-device-private.h"
 #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 *
+static ClutterMainContext *
-_clutter_context_get_default (void)
+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;
 }
 
@@ -1460,7 +1523,7 @@ event_click_count_generate (ClutterEvent *event)
         previous_y = event->button.y;
         previous_time = event->button.time;
 
-        G_GNUC_FALLTHROUGH;
+        /* fallthrough */
       case CLUTTER_BUTTON_RELEASE:
         event->button.click_count = click_count;
         break;
@@ -1713,7 +1776,7 @@ _clutter_process_event_details (ClutterActor        *stage,
 
             emit_crossing_event (event, device);
 
-            actor = clutter_input_device_update (device, NULL, FALSE);
+            actor = _clutter_input_device_update (device, NULL, FALSE);
             if (actor != stage)
               {
                 ClutterEvent *crossing;
@@ -1771,10 +1834,13 @@ _clutter_process_event_details (ClutterActor        *stage,
           {
             if (_clutter_is_input_pointer_a11y_enabled (device))
               {
+                ClutterInputDevice *core_pointer;
                 gfloat x, y;
 
                 clutter_event_get_coords (event, &x, &y);
-                _clutter_input_pointer_a11y_on_motion_event (device, x, y);
+                core_pointer = clutter_device_manager_get_core_device (device->device_manager,
+                                                                       CLUTTER_POINTER_DEVICE);
+                _clutter_input_pointer_a11y_on_motion_event (core_pointer, x, y);
               }
           }
 #endif /* CLUTTER_WINDOWING_X11 */
@@ -1805,7 +1871,7 @@ _clutter_process_event_details (ClutterActor        *stage,
             break;
           }
 
-        G_GNUC_FALLTHROUGH;
+      /* fallthrough from motion */
       case CLUTTER_BUTTON_PRESS:
       case CLUTTER_BUTTON_RELEASE:
 #ifdef CLUTTER_WINDOWING_X11
@@ -1813,7 +1879,12 @@ _clutter_process_event_details (ClutterActor        *stage,
           {
             if (_clutter_is_input_pointer_a11y_enabled (device) && (event->type != CLUTTER_MOTION))
               {
-                _clutter_input_pointer_a11y_on_button_event (device,
+                ClutterInputDevice *core_pointer;
+
+                core_pointer = clutter_device_manager_get_core_device (device->device_manager,
+                                                                       CLUTTER_POINTER_DEVICE);
+
+                _clutter_input_pointer_a11y_on_button_event (core_pointer,
                                                              event->button.button,
                                                              event->type == CLUTTER_BUTTON_PRESS);
               }
@@ -1872,7 +1943,7 @@ _clutter_process_event_details (ClutterActor        *stage,
                * get the actor underneath
                */
               if (device != NULL)
-                actor = clutter_input_device_update (device, NULL, TRUE);
+                actor = _clutter_input_device_update (device, NULL, TRUE);
               else
                 {
                   CLUTTER_NOTE (EVENT, "No device found: picking");
@@ -1945,7 +2016,7 @@ _clutter_process_event_details (ClutterActor        *stage,
             break;
           }
 
-        G_GNUC_FALLTHROUGH;
+      /* fallthrough from motion */
       case CLUTTER_TOUCH_BEGIN:
       case CLUTTER_TOUCH_CANCEL:
       case CLUTTER_TOUCH_END:
@@ -1982,15 +2053,14 @@ _clutter_process_event_details (ClutterActor        *stage,
 
                   emit_touch_event (event, device);
 
-                  if (event->type == CLUTTER_TOUCH_END ||
+                  if (event->type == CLUTTER_TOUCH_END)
-                      event->type == CLUTTER_TOUCH_CANCEL)
                     _clutter_input_device_remove_event_sequence (device, event);
 
                   break;
                 }
 
               if (device != NULL)
-                actor = clutter_input_device_update (device, sequence, TRUE);
+                actor = _clutter_input_device_update (device, sequence, TRUE);
               else
                 {
                   CLUTTER_NOTE (EVENT, "No device found: picking");
@@ -2018,8 +2088,7 @@ _clutter_process_event_details (ClutterActor        *stage,
 
           emit_touch_event (event, device);
 
-          if (event->type == CLUTTER_TOUCH_END ||
+          if (event->type == CLUTTER_TOUCH_END)
-              event->type == CLUTTER_TOUCH_CANCEL)
             _clutter_input_device_remove_event_sequence (device, event);
 
           break;
@@ -2089,6 +2158,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 +2193,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 +2263,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 +2288,8 @@ clutter_threads_remove_repaint_func (guint handle_id)
 
       l = l->next;
     }
+
+  _clutter_context_unlock ();
 }
 
 /**
@@ -2291,13 +2388,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 +2405,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

@@ -26,8 +26,8 @@
 #define __CLUTTER_H_INSIDE__
 
 #include "clutter-backend.h"
+#include "clutter-device-manager-private.h"
 #include "clutter-event-private.h"
-#include "clutter-input-device-private.h"
 #include "clutter-input-pointer-a11y-private.h"
 #include "clutter-macros.h"
 #include "clutter-private.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,
+void clutter_stage_freeze_updates (ClutterStage *stage);
-                                         CoglFramebuffer             *framebuffer,
-                                         const cairo_rectangle_int_t *rect,
-                                         float                        scale,
-                                         ClutterPaintFlag             paint_flags);
 
 CLUTTER_EXPORT
-gboolean clutter_stage_paint_to_buffer (ClutterStage                 *stage,
+void clutter_stage_thaw_updates (ClutterStage *stage);
-                                        const cairo_rectangle_int_t  *rect,
-                                        float                         scale,
-                                        uint8_t                      *data,
-                                        int                           stride,
-                                        CoglPixelFormat               format,
-                                        ClutterPaintFlag              paint_flags,
-                                        GError                      **error);
 
 CLUTTER_EXPORT
-void clutter_stage_clear_stage_views (ClutterStage *stage);
+void clutter_stage_update_resource_scales (ClutterStage *stage);
-
-CLUTTER_EXPORT
-void clutter_stage_view_assign_next_scanout (ClutterStageView *stage_view,
-                                             CoglScanout      *scanout);
 
 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

@@ -81,7 +81,7 @@
 struct _ClutterOffscreenEffectPrivate
 {
   CoglHandle offscreen;
-  CoglPipeline *pipeline;
+  CoglPipeline *target;
   CoglHandle texture;
 
   ClutterActor *actor;
@@ -140,7 +140,7 @@ ensure_pipeline_filter_for_scale (ClutterOffscreenEffect *self,
 {
   CoglPipelineFilter filter;
 
-  if (!self->priv->pipeline)
+  if (!self->priv->target)
     return;
 
   /* If no fractional scaling is set, we're always going to render the texture
@@ -154,7 +154,7 @@ ensure_pipeline_filter_for_scale (ClutterOffscreenEffect *self,
   else
     filter = COGL_PIPELINE_FILTER_LINEAR;
 
-  cogl_pipeline_set_layer_filters (self->priv->pipeline, 0 /* layer_index */,
+  cogl_pipeline_set_layer_filters (self->priv->target, 0 /* layer_index */,
                                    filter, filter);
 }
 
@@ -185,12 +185,12 @@ update_fbo (ClutterEffect *effect,
     return TRUE;
   }
 
-  if (priv->pipeline == NULL)
+  if (priv->target == NULL)
     {
       CoglContext *ctx =
         clutter_backend_get_cogl_context (clutter_get_default_backend ());
 
-      priv->pipeline = cogl_pipeline_new (ctx);
+      priv->target = cogl_pipeline_new (ctx);
       ensure_pipeline_filter_for_scale (self, resource_scale);
     }
 
@@ -202,7 +202,7 @@ update_fbo (ClutterEffect *effect,
   if (priv->texture == NULL)
     return FALSE;
 
-  cogl_pipeline_set_layer_texture (priv->pipeline, 0, priv->texture);
+  cogl_pipeline_set_layer_texture (priv->target, 0, priv->texture);
 
   priv->target_width = target_width;
   priv->target_height = target_height;
@@ -212,8 +212,8 @@ update_fbo (ClutterEffect *effect,
     {
       g_warning ("%s: Unable to create an Offscreen buffer", G_STRLOC);
 
-      cogl_object_unref (priv->pipeline);
+      cogl_object_unref (priv->target);
-      priv->pipeline = NULL;
+      priv->target = NULL;
 
       priv->target_width = 0;
       priv->target_height = 0;
@@ -238,8 +238,8 @@ clutter_offscreen_effect_pre_paint (ClutterEffect       *effect,
   gfloat stage_width, stage_height;
   gfloat target_width = -1, target_height = -1;
   CoglFramebuffer *framebuffer;
-  float resource_scale;
+  gfloat resource_scale;
-  float ceiled_resource_scale;
+  gfloat ceiled_resource_scale;
   graphene_point3d_t local_offset;
   gfloat old_viewport[4];
 
@@ -254,11 +254,17 @@ clutter_offscreen_effect_pre_paint (ClutterEffect       *effect,
   stage = _clutter_actor_get_stage_internal (priv->actor);
   clutter_actor_get_size (stage, &stage_width, &stage_height);
 
-  resource_scale = clutter_actor_get_real_resource_scale (priv->actor);
+  if (_clutter_actor_get_real_resource_scale (priv->actor, &resource_scale))
-
+    {
-  ceiled_resource_scale = ceilf (resource_scale);
+      ceiled_resource_scale = ceilf (resource_scale);
-  stage_width *= ceiled_resource_scale;
+      stage_width *= ceiled_resource_scale;
-  stage_height *= ceiled_resource_scale;
+      stage_height *= ceiled_resource_scale;
+    }
+  else
+    {
+      /* We are sure we have a resource scale set to a good value at paint */
+      g_assert_not_reached ();
+    }
 
   /* Get the minimal bounding box for what we want to paint, relative to the
    * parent of priv->actor. Note that we may actually be painting a clone of
@@ -374,7 +380,7 @@ clutter_offscreen_effect_real_paint_target (ClutterOffscreenEffect *effect,
 
   paint_opacity = clutter_actor_get_paint_opacity (priv->actor);
 
-  cogl_pipeline_set_color4ub (priv->pipeline,
+  cogl_pipeline_set_color4ub (priv->target,
                               paint_opacity,
                               paint_opacity,
                               paint_opacity,
@@ -386,7 +392,7 @@ clutter_offscreen_effect_real_paint_target (ClutterOffscreenEffect *effect,
    * hadn't been redirected offscreen.
    */
   cogl_framebuffer_draw_textured_rectangle (framebuffer,
-                                            priv->pipeline,
+                                            priv->target,
                                             0, 0,
                                             cogl_texture_get_width (priv->texture),
                                             cogl_texture_get_height (priv->texture),
@@ -411,9 +417,8 @@ clutter_offscreen_effect_paint_texture (ClutterOffscreenEffect *effect,
    */
   cogl_framebuffer_get_modelview_matrix (framebuffer, &modelview);
 
-  resource_scale = clutter_actor_get_resource_scale (priv->actor);
+  if (clutter_actor_get_resource_scale (priv->actor, &resource_scale) &&
-
+      resource_scale != 1.0f)
-  if (resource_scale != 1.0f)
     {
       float paint_scale = 1.0f / resource_scale;
       cogl_matrix_scale (&modelview, paint_scale, paint_scale, 1);
@@ -441,16 +446,13 @@ clutter_offscreen_effect_post_paint (ClutterEffect       *effect,
   ClutterOffscreenEffectPrivate *priv = self->priv;
   CoglFramebuffer *framebuffer;
 
-  g_warn_if_fail (priv->offscreen);
+  if (priv->offscreen == NULL ||
-  g_warn_if_fail (priv->pipeline);
+      priv->target == NULL ||
-  g_warn_if_fail (priv->actor);
+      priv->actor == NULL)
+    return;
 
   /* Restore the previous opacity override */
-  if (priv->actor)
+  clutter_actor_set_opacity_override (priv->actor, priv->old_opacity_override);
-    {
-      clutter_actor_set_opacity_override (priv->actor,
-                                          priv->old_opacity_override);
-    }
 
   framebuffer = clutter_paint_context_get_framebuffer (paint_context);
   cogl_framebuffer_pop_matrix (framebuffer);
@@ -467,13 +469,6 @@ clutter_offscreen_effect_paint (ClutterEffect           *effect,
   ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
   ClutterOffscreenEffectPrivate *priv = self->priv;
 
-  if (flags & CLUTTER_EFFECT_PAINT_BYPASS_EFFECT)
-    {
-      clutter_actor_continue_paint (priv->actor, paint_context);
-      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.
    */
@@ -496,17 +491,16 @@ clutter_offscreen_effect_paint (ClutterEffect           *effect,
 }
 
 static void
-clutter_offscreen_effect_set_enabled (ClutterActorMeta *meta,
+clutter_offscreen_effect_notify (GObject    *gobject,
-                                      gboolean          is_enabled)
+                                 GParamSpec *pspec)
 {
-  ClutterActorMetaClass *parent_class =
+  ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (gobject);
-    CLUTTER_ACTOR_META_CLASS (clutter_offscreen_effect_parent_class);
-  ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (meta);
   ClutterOffscreenEffectPrivate *priv = offscreen_effect->priv;
 
-  g_clear_pointer (&priv->offscreen, cogl_object_unref);
+  if (strcmp (pspec->name, "enabled") == 0)
+    g_clear_pointer (&priv->offscreen, cogl_object_unref);
 
-  parent_class->set_enabled (meta, is_enabled);
+  G_OBJECT_CLASS (clutter_offscreen_effect_parent_class)->notify (gobject, pspec);
 }
 
 static void
@@ -517,7 +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);
 }
@@ -533,13 +527,13 @@ clutter_offscreen_effect_class_init (ClutterOffscreenEffectClass *klass)
   klass->paint_target = clutter_offscreen_effect_real_paint_target;
 
   meta_class->set_actor = clutter_offscreen_effect_set_actor;
-  meta_class->set_enabled = clutter_offscreen_effect_set_enabled;
 
   effect_class->pre_paint = clutter_offscreen_effect_pre_paint;
   effect_class->post_paint = clutter_offscreen_effect_post_paint;
   effect_class->paint = clutter_offscreen_effect_paint;
 
   gobject_class->finalize = clutter_offscreen_effect_finalize;
+  gobject_class->notify = clutter_offscreen_effect_notify;
 }
 
 static void
@@ -599,7 +593,7 @@ clutter_offscreen_effect_get_target (ClutterOffscreenEffect *effect)
   g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect),
                         NULL);
 
-  return (CoglMaterial *)effect->priv->pipeline;
+  return (CoglMaterial *)effect->priv->target;
 }
 
 /**

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,
+ClutterPaintContext * clutter_paint_context_new_for_view (ClutterStageView *view);
-                                                          const cairo_region_t *redraw_clip,
-                                                          ClutterPaintFlag      paint_flags);
 
 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,
+clutter_paint_context_new_for_view (ClutterStageView *view)
-                                    const cairo_region_t *redraw_clip,
-                                    ClutterPaintFlag      paint_flags)
 {
   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,
+clutter_paint_context_new_for_framebuffer (CoglFramebuffer *framebuffer)
-                                           const cairo_region_t *redraw_clip,
-                                           ClutterPaintFlag      paint_flags)
 {
   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,
+ClutterPaintContext * clutter_paint_context_new_for_framebuffer (CoglFramebuffer *framebuffer);
-                                                                 const cairo_region_t *redraw_clip,
-                                                                 ClutterPaintFlag      paint_flags);
 
 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;
+  gchar *name;
-
-  guint n_children;
 
   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;
 };

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
+ * The @node will copy the passed string.
- * static string, use clutter_paint_node_set_static_name() instead.
  *
  * 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);
+  g_free (node->name);
-}
+  node->name = g_strdup (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;
 }
 
 /**
@@ -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,
@@ -872,6 +876,7 @@ clutter_text_node_draw (ClutterPaintNode    *node,
           break;
 
         case PAINT_OP_MULTITEX_RECT:
+        case PAINT_OP_PATH:
         case PAINT_OP_PRIMITIVE:
         case PAINT_OP_INVALID:
           break;
@@ -1032,6 +1037,11 @@ clutter_clip_node_pre_draw (ClutterPaintNode    *node,
           retval = TRUE;
           break;
 
+        case PAINT_OP_PATH:
+          cogl_framebuffer_push_path_clip (fb, op->op.path);
+          retval = TRUE;
+          break;
+
         case PAINT_OP_MULTITEX_RECT:
         case PAINT_OP_PRIMITIVE:
         case PAINT_OP_INVALID:
@@ -1062,6 +1072,7 @@ clutter_clip_node_post_draw (ClutterPaintNode    *node,
 
       switch (op->opcode)
         {
+        case PAINT_OP_PATH:
         case PAINT_OP_TEX_RECT:
           cogl_framebuffer_pop_clip (fb);
           break;
@@ -1231,8 +1242,9 @@ struct _ClutterLayerNode
   float fbo_width;
   float fbo_height;
 
-  CoglPipeline *pipeline;
+  CoglPipeline *state;
   CoglFramebuffer *offscreen;
+  CoglTexture *texture;
 
   guint8 opacity;
 };
@@ -1322,7 +1334,7 @@ clutter_layer_node_post_draw (ClutterPaintNode    *node,
         case PAINT_OP_TEX_RECT:
           /* now we need to paint the texture */
           cogl_framebuffer_draw_textured_rectangle (fb,
-                                                    lnode->pipeline,
+                                                    lnode->state,
                                                     op->op.texrect[0],
                                                     op->op.texrect[1],
                                                     op->op.texrect[2],
@@ -1335,7 +1347,7 @@ clutter_layer_node_post_draw (ClutterPaintNode    *node,
 
         case PAINT_OP_MULTITEX_RECT:
           cogl_framebuffer_draw_multitextured_rectangle (fb,
-                                                         lnode->pipeline,
+                                                         lnode->state,
                                                          op->op.texrect[0],
                                                          op->op.texrect[1],
                                                          op->op.texrect[2],
@@ -1344,10 +1356,12 @@ clutter_layer_node_post_draw (ClutterPaintNode    *node,
                                                          op->multitex_coords->len);
           break;
 
+        case PAINT_OP_PATH:
+          cogl_framebuffer_fill_path (fb, lnode->state, op->op.path);
+          break;
+
         case PAINT_OP_PRIMITIVE:
-          cogl_framebuffer_draw_primitive (fb,
+          cogl_framebuffer_draw_primitive (fb, lnode->state, op->op.primitive);
-                                           lnode->pipeline,
-                                           op->op.primitive);
           break;
         }
     }
@@ -1358,8 +1372,8 @@ clutter_layer_node_finalize (ClutterPaintNode *node)
 {
   ClutterLayerNode *lnode = CLUTTER_LAYER_NODE (node);
 
-  if (lnode->pipeline != NULL)
+  if (lnode->state != NULL)
-    cogl_object_unref (lnode->pipeline);
+    cogl_object_unref (lnode->state);
 
   if (lnode->offscreen != NULL)
     cogl_object_unref (lnode->offscreen);
@@ -1411,9 +1425,6 @@ clutter_layer_node_new (const CoglMatrix        *projection,
                         guint8                   opacity)
 {
   ClutterLayerNode *res;
-  CoglContext *context;
-  CoglTexture2D *tex_2d;
-  CoglTexture *texture;
   CoglColor color;
 
   res = _clutter_paint_node_create (CLUTTER_TYPE_LAYER_NODE);
@@ -1425,18 +1436,19 @@ clutter_layer_node_new (const CoglMatrix        *projection,
   res->opacity = opacity;
 
   /* the texture backing the FBO */
-  context = clutter_backend_get_cogl_context (clutter_get_default_backend ());
+  res->texture = cogl_texture_new_with_size (MAX (res->fbo_width, 1),
+                                             MAX (res->fbo_height, 1),
+                                             COGL_TEXTURE_NO_SLICING,
+                                             COGL_PIXEL_FORMAT_RGBA_8888_PRE);
 
-  tex_2d = cogl_texture_2d_new_with_size (context,
+  res->offscreen = COGL_FRAMEBUFFER (cogl_offscreen_new_to_texture (res->texture));
-                                          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));
   if (res->offscreen == NULL)
     {
       g_critical ("%s: Unable to create an offscreen buffer", G_STRLOC);
+
+      cogl_object_unref (res->texture);
+      res->texture = NULL;
+
       goto out;
     }
 
@@ -1446,15 +1458,14 @@ clutter_layer_node_new (const CoglMatrix        *projection,
    * interpolation filters because the texture is always
    * going to be painted at a 1:1 texel:pixel ratio
    */
-  res->pipeline = cogl_pipeline_copy (default_texture_pipeline);
+  res->state = cogl_pipeline_copy (default_texture_pipeline);
-  cogl_pipeline_set_layer_filters (res->pipeline, 0,
+  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_layer_texture (res->state, 0, res->texture);
-  cogl_pipeline_set_color (res->pipeline, &color);
+  cogl_pipeline_set_color (res->state, &color);
+  cogl_object_unref (res->texture);
 
 out:
-  cogl_object_unref (texture);
-
   return (ClutterPaintNode *) res;
 }

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,
+G_DEFINE_TYPE_WITH_PRIVATE (ClutterPanAction, clutter_pan_action, CLUTTER_TYPE_GESTURE_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),
+          clutter_gesture_action_get_motion_delta (CLUTTER_GESTURE_ACTION (self), 0, &delta_x, &delta_y);
-                                                   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) &&
+          if ((drag_angle > -scroll_threshold) && (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),
+  clutter_gesture_action_get_release_coords (CLUTTER_GESTURE_ACTION (self), 0, &priv->release_x, &priv->release_y);
-                                             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 = clutter_gesture_action_get_velocity (gesture, 0, &velocity_x, &velocity_y);
-                                                  &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) *
+  duration = - tau * logf (min_velocity / (ABS (velocity) * priv->acceleration_factor));
-                                           priv->acceleration_factor));
 
   /* Target point: x(t) = v(0) * tau * [1 - exp(-t/tau)] */
-  priv->target_x = (velocity_x * priv->acceleration_factor * tau *
+  priv->target_x = velocity_x * priv->acceleration_factor * tau * (1 - exp ((float)-duration / tau));
-                    (1 - exp ((float)-duration / tau)));
+  priv->target_y = velocity_y * 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 &&
+  if (ABS (velocity) * priv->acceleration_factor > min_velocity && duration > FLOAT_EPSILON)
-      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,
+      priv->deceleration_timeline = clutter_timeline_new (duration);
-                                                                    duration);
+      clutter_timeline_set_progress_mode (priv->deceleration_timeline, CLUTTER_EASE_OUT_EXPO);
-      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,
+      clutter_pan_action_set_acceleration_factor (self, g_value_get_double (value));
-                                                  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, CLUTTER_GESTURE_TRIGGER_EDGE_AFTER);
-  clutter_gesture_action_set_threshold_trigger_edge (gesture, edge);
 }
 
 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,
+  CLUTTER_ACTOR_META_CLASS (clutter_pan_action_parent_class)->set_actor (meta, actor);
-                                                                         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,
+  distance = clutter_pan_action_get_motion_delta (self, point, &delta_x, &delta_y);
-                                                  &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);