clutter: Always snoop key events for a11y

In the case a11y is required, the screen reader is very much
interested in getting an uniterrupted flow of key events. It attempts
so by setting a ::captured-event callback on the ClutterStage, but
that falls short with our MetaDisplay event handler, as clutter events
can be stopped before a11y gets a chance to see them.

This kind of selective amnesia wrt key events is not new, in X11 those
go unheard of by the WM as long as a client is focused and no grabs hold,
so it is clients' responsibility to talk with AT bridge.

This commit doesn't yet change that for X11, but we can do this right
away from the compositor on Wayland, and without any chance to be
tampered by clients.

https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1328

.gitlab-ci.yml

@@ -4,6 +4,7 @@ stages:
  - review
  - build
  - test
+ - coverage
 
 check-commit-log:
   stage: review
@@ -17,7 +18,7 @@ check-commit-log:
 build-mutter:
   stage: build
   script:
-    - meson . build -Dbuildtype=debugoptimized -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
+    - meson . build -Dbuildtype=debugoptimized -Db_coverage=true -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
     - ninja -C build
     - ninja -C build install
   artifacts:
@@ -35,9 +36,8 @@ build-without-opengl-and-glx:
     - ninja -C build
     - ninja -C build install
   artifacts:
-    expire_in: 1 day
     paths:
-      - build
+      - build/meson-logs
   only:
     - merge_requests
     - /^.*$/
@@ -49,9 +49,8 @@ build-without-native-backend-and-wayland:
     - ninja -C build
     - ninja -C build install
   artifacts:
-    expire_in: 1 day
     paths:
-      - build
+      - build/meson-logs
   only:
     - merge_requests
     - /^.*$/
@@ -66,7 +65,6 @@ 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
@@ -74,10 +72,30 @@ test-mutter:
     - >
       dbus-run-session -- xvfb-run -s '+iglx -noreset'
       meson test -C build --no-rebuild -t 10 --verbose --no-stdsplit --print-errorlogs --wrap catchsegv
+  artifacts:
+    expire_in: 1 day
+    paths:
+      - build
   only:
     - merge_requests
     - /^.*$/
 
+test-mutter-coverage:
+  stage: coverage
+  dependencies:
+    - test-mutter
+  script:
+    - ninja -C build coverage
+    - cat build/meson-logs/coverage.txt
+  artifacts:
+    paths:
+      - build/meson-logs
+  when: manual
+  except:
+    refs:
+      - tags
+      - master
+
 can-build-gnome-shell:
   stage: test
   dependencies:

.gitlab-ci/Dockerfile

@@ -16,7 +16,7 @@ RUN dnf -y update && dnf -y upgrade && \
 
     # For running unit tests
     dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 \
-        '*/xvfb-run' gdm-lib accountsservice-libs gnome-control-center \
+        '*/xvfb-run' gdm-lib accountsservice-libs gnome-control-center gcovr \
         --setopt=install_weak_deps=False && \
 
     # GNOME Shell

NEWS

@@ -1,3 +1,63 @@
+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]

clutter/clutter/cally/cally-util.c

@@ -60,17 +60,6 @@ static const gchar *         cally_util_get_toolkit_name		    (void);
 static const gchar *         cally_util_get_toolkit_version          (void);
 
 /* private */
-static void                  cally_util_simulate_snooper_install     (void);
-static void                  cally_util_simulate_snooper_remove      (void);
-static gboolean              cally_key_snooper                       (ClutterActor *actor,
-                                                                      ClutterEvent *event,
-                                                                      gpointer      user_data);
-static void                  cally_util_stage_added_cb               (ClutterStageManager *stage_manager,
-                                                                      ClutterStage *stage,
-                                                                      gpointer data);
-static void                  cally_util_stage_removed_cb             (ClutterStageManager *stage_manager,
-                                                                      ClutterStage *stage,
-                                                                      gpointer data);
 static gboolean              notify_hf                               (gpointer key,
                                                                       gpointer value,
                                                                       gpointer data);
@@ -153,12 +142,8 @@ cally_util_add_key_event_listener (AtkKeySnoopFunc  listener,
   CallyKeyEventInfo *event_info = NULL;
 
   if (!key_listener_list)
-  {
     key_listener_list = g_hash_table_new_full (NULL, NULL, NULL, g_free);
 
-    cally_util_simulate_snooper_install ();
-  }
-
   event_info = g_new (CallyKeyEventInfo, 1);
   event_info->listener = listener;
   event_info->func_data = data;
@@ -179,75 +164,11 @@ cally_util_remove_key_event_listener (guint remove_listener)
     {
       g_hash_table_destroy (key_listener_list);
       key_listener_list = NULL;
-      cally_util_simulate_snooper_remove ();
     }
 }
 
 /* ------------------------------ PRIVATE FUNCTIONS ------------------------- */
 
-/* Trying to emulate gtk_key_snooper install (a kind of wrapper). This
-   could be implemented without it, but I will maintain it in this
-   way, so if in the future clutter implements it natively it would be
-   easier the transition */
-static void
-cally_util_simulate_snooper_install (void)
-{
-  ClutterStageManager *stage_manager = NULL;
-  ClutterStage *stage = NULL;
-  GSList *stage_list = NULL;
-  GSList *iter = NULL;
-
-  stage_manager = clutter_stage_manager_get_default ();
-  stage_list = clutter_stage_manager_list_stages (stage_manager);
-
-  for (iter = stage_list; iter != NULL; iter = g_slist_next (iter))
-    {
-      stage = CLUTTER_STAGE (iter->data);
-
-      g_signal_connect (G_OBJECT (stage), "captured-event",
-                        G_CALLBACK (cally_key_snooper), NULL);
-    }
-
-  g_signal_connect (G_OBJECT (stage_manager), "stage-added",
-                    G_CALLBACK (cally_util_stage_added_cb), cally_key_snooper);
-  g_signal_connect (G_OBJECT (stage_manager), "stage-removed",
-                    G_CALLBACK (cally_util_stage_removed_cb), cally_key_snooper);
-
-  g_slist_free (stage_list);
-}
-
-static void
-cally_util_simulate_snooper_remove (void)
-{
-  ClutterStageManager *stage_manager = NULL;
-  ClutterStage *stage = NULL;
-  GSList *stage_list = NULL;
-  GSList *iter = NULL;
-  gint num = 0;
-
-  stage_manager = clutter_stage_manager_get_default ();
-  stage_list = clutter_stage_manager_list_stages (stage_manager);
-
-  for (iter = stage_list; iter != NULL; iter = g_slist_next (iter))
-    {
-      stage = CLUTTER_STAGE (iter->data);
-
-      num += g_signal_handlers_disconnect_by_func (stage, cally_key_snooper, NULL);
-    }
-
-  g_signal_handlers_disconnect_by_func (G_OBJECT (stage_manager),
-                                        G_CALLBACK (cally_util_stage_added_cb),
-                                        cally_key_snooper);
-
-  g_signal_handlers_disconnect_by_func (G_OBJECT (stage_manager),
-                                        G_CALLBACK (cally_util_stage_removed_cb),
-                                        cally_key_snooper);
-
-#ifdef CALLY_DEBUG
-  g_print ("Number of snooper callbacks disconnected: %i\n", num);
-#endif
-}
-
 static AtkKeyEventStruct *
 atk_key_event_from_clutter_event_key (ClutterKeyEvent *clutter_event,
                                       gunichar         password_char)
@@ -384,59 +305,34 @@ check_key_visibility (ClutterEvent *event)
     return DEFAULT_PASSWORD_CHAR;
 }
 
-static gboolean
-cally_key_snooper (ClutterActor *actor,
-                   ClutterEvent *event,
-                   gpointer      user_data)
+gboolean
+cally_snoop_key_event (ClutterKeyEvent *key)
 {
+  ClutterEvent *event = (ClutterEvent *) key;
   AtkKeyEventStruct *key_event = NULL;
-  gint consumed = 0;
+  gboolean consumed = FALSE;
   gunichar password_char = 0;
 
   /* filter key events */
   if ((event->type != CLUTTER_KEY_PRESS) && (event->type != CLUTTER_KEY_RELEASE))
-    {
-      return FALSE;
-    }
-
-  password_char = check_key_visibility (event);
+    return FALSE;
 
   if (key_listener_list)
     {
       GHashTable *new_hash = g_hash_table_new (NULL, NULL);
 
       g_hash_table_foreach (key_listener_list, insert_hf, new_hash);
-      key_event = atk_key_event_from_clutter_event_key ((ClutterKeyEvent *)event,
-                                                        password_char);
+      password_char = check_key_visibility (event);
+      key_event = atk_key_event_from_clutter_event_key (key, password_char);
       /* func data is inside the hash table */
-      consumed = g_hash_table_foreach_steal (new_hash, notify_hf, key_event);
+      consumed = g_hash_table_foreach_steal (new_hash, notify_hf, key_event) > 0;
       g_hash_table_destroy (new_hash);
 
       g_free (key_event->string);
       g_free (key_event);
     }
 
-  return (consumed ? 1 : 0);
-}
-
-static void
-cally_util_stage_added_cb (ClutterStageManager *stage_manager,
-                           ClutterStage *stage,
-                           gpointer data)
-{
-  GCallback cally_key_snooper_cb = G_CALLBACK (data);
-
-  g_signal_connect (G_OBJECT (stage), "captured-event", cally_key_snooper_cb, NULL);
-}
-
-static void
-cally_util_stage_removed_cb (ClutterStageManager *stage_manager,
-                             ClutterStage *stage,
-                             gpointer data)
-{
-  GCallback cally_key_snooper_cb = G_CALLBACK (data);
-
-  g_signal_handlers_disconnect_by_func (stage, cally_key_snooper_cb, NULL);
+  return consumed;
 }
 
 void

clutter/clutter/cally/cally-util.h

@@ -79,6 +79,8 @@ GType cally_util_get_type (void) G_GNUC_CONST;
 
 void _cally_util_override_atk_util (void);
 
+gboolean cally_snoop_key_event (ClutterKeyEvent *key);
+
 G_END_DECLS
 
 #endif /* __CALLY_UTIL_H__ */

clutter/clutter/clutter-action.h

@@ -33,28 +33,11 @@
 
 G_BEGIN_DECLS
 
-#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))
+#define CLUTTER_TYPE_ACTION (clutter_action_get_type ())
 
-typedef struct _ClutterActionClass      ClutterActionClass;
-
-/**
- * ClutterAction:
- *
- * The #ClutterAction structure contains only private data and
- * should be accessed using the provided API.
- *
- * Since: 1.4
- */
-struct _ClutterAction
-{
-  /*< private >*/
-  ClutterActorMeta parent_instance;
-};
+CLUTTER_EXPORT
+G_DECLARE_DERIVABLE_TYPE (ClutterAction, clutter_action,
+                          CLUTTER, ACTION, ClutterActorMeta);
 
 /**
  * ClutterActionClass:
@@ -78,9 +61,6 @@ 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,6 +615,32 @@ 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,38 +81,47 @@ static void
 on_actor_destroy (ClutterActor     *actor,
                   ClutterActorMeta *meta)
 {
-  meta->priv->actor = NULL;
+  ClutterActorMetaPrivate *priv =
+    clutter_actor_meta_get_instance_private (meta);
+
+  priv->actor = NULL;
 }
 
 static void
 clutter_actor_meta_real_set_actor (ClutterActorMeta *meta,
                                    ClutterActor     *actor)
 {
-  g_warn_if_fail (!meta->priv->actor ||
-                  !CLUTTER_ACTOR_IN_PAINT (meta->priv->actor));
+  ClutterActorMetaPrivate *priv =
+    clutter_actor_meta_get_instance_private (meta);
+
+  g_warn_if_fail (!priv->actor ||
+                  !CLUTTER_ACTOR_IN_PAINT (priv->actor));
   g_warn_if_fail (!actor || !CLUTTER_ACTOR_IN_PAINT (actor));
 
-  if (meta->priv->actor == actor)
+  if (priv->actor == actor)
     return;
 
-  g_clear_signal_handler (&meta->priv->destroy_id, meta->priv->actor);
+  g_clear_signal_handler (&priv->destroy_id, priv->actor);
 
-  meta->priv->actor = actor;
+  priv->actor = actor;
 
-  if (meta->priv->actor != NULL)
-    meta->priv->destroy_id = g_signal_connect (meta->priv->actor, "destroy",
-                                               G_CALLBACK (on_actor_destroy),
-                                               meta);
+  if (priv->actor != NULL)
+    priv->destroy_id = g_signal_connect (priv->actor, "destroy",
+                                         G_CALLBACK (on_actor_destroy),
+                                         meta);
 }
 
 static void
 clutter_actor_meta_real_set_enabled (ClutterActorMeta *meta,
                                      gboolean          is_enabled)
 {
-  g_warn_if_fail (!meta->priv->actor ||
-                  !CLUTTER_ACTOR_IN_PAINT (meta->priv->actor));
+  ClutterActorMetaPrivate *priv =
+    clutter_actor_meta_get_instance_private (meta);
 
-  meta->priv->is_enabled = is_enabled;
+  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]);
 }
@@ -147,20 +156,21 @@ clutter_actor_meta_get_property (GObject    *gobject,
                                  GValue     *value,
                                  GParamSpec *pspec)
 {
-  ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject);
+  ClutterActorMetaPrivate *priv =
+    clutter_actor_meta_get_instance_private (CLUTTER_ACTOR_META (gobject));
 
   switch (prop_id)
     {
     case PROP_ACTOR:
-      g_value_set_object (value, meta->priv->actor);
+      g_value_set_object (value, priv->actor);
       break;
 
     case PROP_NAME:
-      g_value_set_string (value, meta->priv->name);
+      g_value_set_string (value, priv->name);
       break;
 
     case PROP_ENABLED:
-      g_value_set_boolean (value, meta->priv->is_enabled);
+      g_value_set_boolean (value, priv->is_enabled);
       break;
 
     default:
@@ -172,7 +182,8 @@ clutter_actor_meta_get_property (GObject    *gobject,
 static void
 clutter_actor_meta_finalize (GObject *gobject)
 {
-  ClutterActorMetaPrivate *priv = CLUTTER_ACTOR_META (gobject)->priv;
+  ClutterActorMetaPrivate *priv =
+    clutter_actor_meta_get_instance_private (CLUTTER_ACTOR_META (gobject));
 
   if (priv->actor != NULL)
     g_clear_signal_handler (&priv->destroy_id, priv->actor);
@@ -243,9 +254,11 @@ clutter_actor_meta_class_init (ClutterActorMetaClass *klass)
 void
 clutter_actor_meta_init (ClutterActorMeta *self)
 {
-  self->priv = clutter_actor_meta_get_instance_private (self);
-  self->priv->is_enabled = TRUE;
-  self->priv->priority = CLUTTER_ACTOR_META_PRIORITY_DEFAULT;
+  ClutterActorMetaPrivate *priv =
+    clutter_actor_meta_get_instance_private (self);
+
+  priv->is_enabled = TRUE;
+  priv->priority = CLUTTER_ACTOR_META_PRIORITY_DEFAULT;
 }
 
 /**
@@ -263,13 +276,17 @@ void
 clutter_actor_meta_set_name (ClutterActorMeta *meta,
                              const gchar      *name)
 {
+  ClutterActorMetaPrivate *priv;
+
   g_return_if_fail (CLUTTER_IS_ACTOR_META (meta));
 
-  if (g_strcmp0 (meta->priv->name, name) == 0)
+  priv = clutter_actor_meta_get_instance_private (meta);
+
+  if (g_strcmp0 (priv->name, name) == 0)
     return;
 
-  g_free (meta->priv->name);
-  meta->priv->name = g_strdup (name);
+  g_free (priv->name);
+  priv->name = g_strdup (name);
 
   g_object_notify_by_pspec (G_OBJECT (meta), obj_props[PROP_NAME]);
 }
@@ -290,9 +307,13 @@ 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);
 
-  return meta->priv->name;
+  priv = clutter_actor_meta_get_instance_private (meta);
+
+  return priv->name;
 }
 
 /**
@@ -308,11 +329,14 @@ 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 (meta->priv->is_enabled == is_enabled)
+  if (priv->is_enabled == is_enabled)
     return;
 
   CLUTTER_ACTOR_META_GET_CLASS (meta)->set_enabled (meta, is_enabled);
@@ -331,9 +355,13 @@ 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);
 
-  return meta->priv->is_enabled;
+  priv = clutter_actor_meta_get_instance_private (meta);
+
+  return priv->is_enabled;
 }
 
 /*
@@ -369,40 +397,54 @@ _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);
 
-  return meta->priv->actor;
+  priv = clutter_actor_meta_get_instance_private (meta);
+
+  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 (meta->priv->actor == NULL);
+  g_return_if_fail (priv->actor == NULL);
 
-  meta->priv->priority = priority;
+  priv->priority = priority;
 }
 
 gint
 _clutter_actor_meta_get_priority (ClutterActorMeta *meta)
 {
+  ClutterActorMetaPrivate *priv;
+
   g_return_val_if_fail (CLUTTER_IS_ACTOR_META (meta), 0);
 
-  return meta->priv->priority;
+  priv = clutter_actor_meta_get_instance_private (meta);
+
+  return priv->priority;
 }
 
 gboolean
 _clutter_actor_meta_is_internal (ClutterActorMeta *meta)
 {
-  gint priority = meta->priv->priority;
+  ClutterActorMetaPrivate *priv =
+    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);
@@ -449,19 +491,21 @@ void
 _clutter_meta_group_add_meta (ClutterMetaGroup *group,
                               ClutterActorMeta *meta)
 {
+  ClutterActorMetaPrivate *priv =
+    clutter_actor_meta_get_instance_private (meta);
   GList *prev = NULL, *l;
 
-  if (meta->priv->actor != NULL)
+  if (priv->actor != NULL)
     {
       g_warning ("The meta of type '%s' with name '%s' is "
                  "already attached to actor '%s'",
                  G_OBJECT_TYPE_NAME (meta),
-                 meta->priv->name != NULL
-                   ? meta->priv->name
+                 priv->name != NULL
+                   ? priv->name
                    : "<unknown>",
-                 clutter_actor_get_name (meta->priv->actor) != NULL
-                   ? clutter_actor_get_name (meta->priv->actor)
-                   : G_OBJECT_TYPE_NAME (meta->priv->actor));
+                 clutter_actor_get_name (priv->actor) != NULL
+                   ? clutter_actor_get_name (priv->actor)
+                   : G_OBJECT_TYPE_NAME (priv->actor));
       return;
     }
 
@@ -497,13 +541,16 @@ void
 _clutter_meta_group_remove_meta (ClutterMetaGroup *group,
                                  ClutterActorMeta *meta)
 {
-  if (meta->priv->actor != group->actor)
+  ClutterActorMetaPrivate *priv =
+    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),
-                 meta->priv->name != NULL
-                   ? meta->priv->name
+                 priv->name != NULL
+                   ? priv->name
                    : "<unknown>",
                  clutter_actor_get_name (group->actor) != NULL
                    ? clutter_actor_get_name (group->actor)
@@ -646,8 +693,10 @@ _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 (meta->priv->name, name) == 0)
+      if (g_strcmp0 (priv->name, name) == 0)
         return meta;
     }
 
@@ -667,6 +716,8 @@ _clutter_meta_group_get_meta (ClutterMetaGroup *group,
 const gchar *
 _clutter_actor_meta_get_debug_name (ClutterActorMeta *meta)
 {
-  return meta->priv->name != NULL ? meta->priv->name
-                                  : G_OBJECT_TYPE_NAME (meta);
+  ClutterActorMetaPrivate *priv =
+    clutter_actor_meta_get_instance_private (meta);
+
+  return priv->name != NULL ? priv->name : G_OBJECT_TYPE_NAME (meta);
 }

clutter/clutter/clutter-actor-meta.h

@@ -33,31 +33,13 @@
 
 G_BEGIN_DECLS
 
-#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))
+#define CLUTTER_TYPE_ACTOR_META (clutter_actor_meta_get_type ())
 
-typedef struct _ClutterActorMetaPrivate         ClutterActorMetaPrivate;
-typedef struct _ClutterActorMetaClass           ClutterActorMetaClass;
+CLUTTER_EXPORT
+G_DECLARE_DERIVABLE_TYPE (ClutterActorMeta, clutter_actor_meta,
+                          CLUTTER, ACTOR_META, GInitiallyUnowned);
 
-/**
- * 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;
-};
+typedef struct _ClutterActorMetaPrivate ClutterActorMetaPrivate;
 
 /**
  * ClutterActorMetaClass:
@@ -99,9 +81,6 @@ struct _ClutterActorMetaClass
   void (* _clutter_meta6) (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

@@ -313,7 +313,7 @@ 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_queue_update_resource_scale_recursive    (ClutterActor *actor);
+void                            clutter_actor_clear_stage_views_recursive               (ClutterActor *actor);
 
 gboolean                        _clutter_actor_get_real_resource_scale                  (ClutterActor *actor,
                                                                                          float        *resource_scale);
@@ -321,6 +321,8 @@ gboolean                        _clutter_actor_get_real_resource_scale
 ClutterPaintNode *              clutter_actor_create_texture_paint_node                 (ClutterActor *self,
                                                                                          CoglTexture  *texture);
 
+void clutter_actor_update_stage_views (ClutterActor *self);
+
 G_END_DECLS
 
 #endif /* __CLUTTER_ACTOR_PRIVATE_H__ */

clutter/clutter/clutter-actor.h

@@ -175,9 +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 settings the coordinates of an
- *   actor; it is used by clutter_actor_allocate(); it must chain up to
- *   the parent's implementation, or call clutter_actor_set_allocation()
+ * @allocate: virtual function, used when setting the coordinates of an
+ *   actor; it is used by clutter_actor_allocate(); when overriding this
+ *   function without chaining up, clutter_actor_set_allocation() must be
+ *   called and children must be allocated by the implementation, when
+ *   chaining up though, those things will be done by the parent's
+ *   implementation.
  * @apply_transform: virtual function, used when applying the transformations
  *   to an actor before painting it or when transforming coordinates or
  *   the allocation; it must chain up to the parent's implementation
@@ -253,8 +256,7 @@ struct _ClutterActorClass
                                  gfloat                 *min_height_p,
                                  gfloat                 *natural_height_p);
   void (* allocate)             (ClutterActor           *self,
-                                 const ClutterActorBox  *box,
-                                 ClutterAllocationFlags  flags);
+                                 const ClutterActorBox  *box);
 
   /* transformations */
   void (* apply_transform)      (ClutterActor           *actor,
@@ -415,38 +417,29 @@ void                            clutter_actor_get_preferred_size
                                                                                  gfloat                      *natural_height_p);
 CLUTTER_EXPORT
 void                            clutter_actor_allocate                          (ClutterActor                *self,
-                                                                                 const ClutterActorBox       *box,
-                                                                                 ClutterAllocationFlags       flags);
+                                                                                 const ClutterActorBox       *box);
 CLUTTER_EXPORT
-void                            clutter_actor_allocate_preferred_size           (ClutterActor                *self,
-                                                                                 ClutterAllocationFlags       flags);
+void                            clutter_actor_allocate_preferred_size           (ClutterActor                *self);
 CLUTTER_EXPORT
 void                            clutter_actor_allocate_available_size           (ClutterActor                *self,
                                                                                  gfloat                       x,
                                                                                  gfloat                       y,
                                                                                  gfloat                       available_width,
-                                                                                 gfloat                       available_height,
-                                                                                 ClutterAllocationFlags       flags);
+                                                                                 gfloat                       available_height);
 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,
-                                                                                 ClutterAllocationFlags       flags);
+                                                                                 gboolean                     y_fill);
 CLUTTER_EXPORT
 void                            clutter_actor_set_allocation                    (ClutterActor                *self,
-                                                                                 const ClutterActorBox       *box,
-                                                                                 ClutterAllocationFlags       flags);
+                                                                                 const ClutterActorBox       *box);
 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,
@@ -926,6 +919,9 @@ void clutter_actor_pick_box (ClutterActor          *self,
                              ClutterPickContext    *pick_context,
                              const ClutterActorBox *box);
 
+CLUTTER_EXPORT
+GList * clutter_actor_peek_stage_views (ClutterActor *self);
+
 G_END_DECLS
 
 #endif /* __CLUTTER_ACTOR_H__ */

clutter/clutter/clutter-align-constraint.c

@@ -58,6 +58,7 @@ struct _ClutterAlignConstraint
   ClutterActor *actor;
   ClutterActor *source;
   ClutterAlignAxis align_axis;
+  graphene_point_t pivot;
   gfloat factor;
 };
 
@@ -72,6 +73,7 @@ enum
 
   PROP_SOURCE,
   PROP_ALIGN_AXIS,
+  PROP_PIVOT_POINT,
   PROP_FACTOR,
 
   PROP_LAST
@@ -84,13 +86,11 @@ G_DEFINE_TYPE (ClutterAlignConstraint,
                CLUTTER_TYPE_CONSTRAINT);
 
 static void
-source_position_changed (ClutterActor           *actor,
-                         const ClutterActorBox  *allocation,
-                         ClutterAllocationFlags  flags,
-                         ClutterAlignConstraint *align)
+source_queue_relayout (ClutterActor           *actor,
+                       ClutterAlignConstraint *align)
 {
   if (align->actor != NULL)
-    clutter_actor_queue_relayout (align->actor);
+    _clutter_actor_queue_only_relayout (align->actor);
 }
 
 static void
@@ -135,35 +135,41 @@ clutter_align_constraint_update_allocation (ClutterConstraint *constraint,
   ClutterAlignConstraint *align = CLUTTER_ALIGN_CONSTRAINT (constraint);
   gfloat source_width, source_height;
   gfloat actor_width, actor_height;
-  gfloat source_x, source_y;
+  gfloat offset_x_start, offset_y_start;
+  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 = ((source_width - actor_width) * align->factor)
-                     + source_x;
+      allocation->x1 += offset_x_start + (source_width * align->factor);
       allocation->x2 = allocation->x1 + actor_width;
       break;
 
     case CLUTTER_ALIGN_Y_AXIS:
-      allocation->y1 = ((source_height - actor_height) * align->factor)
-                     + source_y;
+      allocation->y1 += offset_y_start + (source_height * align->factor);
       allocation->y2 = allocation->y1 + actor_height;
       break;
 
     case CLUTTER_ALIGN_BOTH:
-      allocation->x1 = ((source_width - actor_width) * align->factor)
-                     + source_x;
-      allocation->y1 = ((source_height - actor_height) * align->factor)
-                     + source_y;
+      allocation->x1 += offset_x_start + (source_width * align->factor);
+      allocation->y1 += offset_y_start + (source_height * align->factor);
       allocation->x2 = allocation->x1 + actor_width;
       allocation->y2 = allocation->y1 + actor_height;
       break;
@@ -187,7 +193,7 @@ clutter_align_constraint_dispose (GObject *gobject)
                                             G_CALLBACK (source_destroyed),
                                             align);
       g_signal_handlers_disconnect_by_func (align->source,
-                                            G_CALLBACK (source_position_changed),
+                                            G_CALLBACK (source_queue_relayout),
                                             align);
       align->source = NULL;
     }
@@ -213,6 +219,10 @@ 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;
@@ -241,6 +251,16 @@ 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;
@@ -294,6 +314,30 @@ 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:
    *
@@ -326,6 +370,8 @@ 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;
 }
 
@@ -403,15 +449,15 @@ clutter_align_constraint_set_source (ClutterAlignConstraint *align,
                                             G_CALLBACK (source_destroyed),
                                             align);
       g_signal_handlers_disconnect_by_func (old_source,
-                                            G_CALLBACK (source_position_changed),
+                                            G_CALLBACK (source_queue_relayout),
                                             align);
     }
 
   align->source = source;
   if (align->source != NULL)
     {
-      g_signal_connect (align->source, "allocation-changed",
-                        G_CALLBACK (source_position_changed),
+      g_signal_connect (align->source, "queue-relayout",
+                        G_CALLBACK (source_queue_relayout),
                         align);
       g_signal_connect (align->source, "destroy",
                         G_CALLBACK (source_destroyed),
@@ -488,6 +534,60 @@ 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,6 +67,12 @@ 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,35 +27,23 @@
  * @short_description: Interface for animatable classes
  *
  * #ClutterAnimatable is an interface that allows a #GObject class
- * to control how a #ClutterAnimation will animate a property.
+ * to control how an actor 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

clutter/clutter/clutter-animatable.h

@@ -42,8 +42,6 @@ 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
@@ -53,9 +51,6 @@ G_DECLARE_INTERFACE (ClutterAnimatable, clutter_animatable,
  * @interpolate_value: virtual function for interpolating the progress
  *   of a property
  *
- * Base interface for #GObject<!-- -->s that can be animated by a
- * a #ClutterAnimation.
- *
  * Since: 1.0
  */
 struct _ClutterAnimatableInterface
@@ -64,13 +59,6 @@ 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,

clutter/clutter/clutter-autocleanups.h

@@ -30,9 +30,7 @@
 
 #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)
@@ -43,7 +41,6 @@ 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)
@@ -53,7 +50,6 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDesaturateEffect, 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-bin-layout.c

@@ -406,8 +406,7 @@ get_actor_align_factor (ClutterActorAlign alignment)
 static void
 clutter_bin_layout_allocate (ClutterLayoutManager   *manager,
                              ClutterContainer       *container,
-                             const ClutterActorBox  *allocation,
-                             ClutterAllocationFlags  flags)
+                             const ClutterActorBox  *allocation)
 {
   gfloat allocation_x, allocation_y;
   gfloat available_w, available_h;
@@ -515,8 +514,7 @@ clutter_bin_layout_allocate (ClutterLayoutManager   *manager,
 
       clutter_actor_allocate_align_fill (child, &child_alloc,
                                          x_align, y_align,
-                                         x_fill, y_fill,
-                                         flags);
+                                         x_fill, y_fill);
     }
 }
 

clutter/clutter/clutter-bind-constraint.c

@@ -165,6 +165,9 @@ clutter_bind_constraint_update_preferred_size (ClutterConstraint  *constraint,
         bind->coordinate == CLUTTER_BIND_ALL))
     return;
 
+  if (clutter_actor_contains (bind->source, actor))
+    return;
+
   switch (direction)
     {
     case CLUTTER_ORIENTATION_HORIZONTAL:

clutter/clutter/clutter-box-layout.h

@@ -105,64 +105,6 @@ 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-click-action.c

@@ -159,7 +159,8 @@ static inline void
 click_action_set_pressed (ClutterClickAction *action,
                           gboolean            is_pressed)
 {
-  ClutterClickActionPrivate *priv = action->priv;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (action);
 
   is_pressed = !!is_pressed;
 
@@ -174,7 +175,8 @@ static inline void
 click_action_set_held (ClutterClickAction *action,
                        gboolean            is_held)
 {
-  ClutterClickActionPrivate *priv = action->priv;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (action);
 
   is_held = !!is_held;
 
@@ -189,7 +191,8 @@ static gboolean
 click_action_emit_long_press (gpointer data)
 {
   ClutterClickAction *action = data;
-  ClutterClickActionPrivate *priv = action->priv;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (action);
   ClutterActor *actor;
   gboolean result;
 
@@ -213,7 +216,8 @@ click_action_emit_long_press (gpointer data)
 static inline void
 click_action_query_long_press (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv = action->priv;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (action);
   ClutterActor *actor;
   gboolean result = FALSE;
   gint timeout;
@@ -249,7 +253,8 @@ click_action_query_long_press (ClutterClickAction *action)
 static inline void
 click_action_cancel_long_press (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv = action->priv;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (action);
 
   if (priv->long_press_id != 0)
     {
@@ -272,7 +277,8 @@ on_event (ClutterActor       *actor,
           ClutterEvent       *event,
           ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv = action->priv;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (action);
   gboolean has_button = TRUE;
 
   if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (action)))
@@ -342,7 +348,8 @@ on_captured_event (ClutterActor       *stage,
                    ClutterEvent       *event,
                    ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv = action->priv;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (action);
   ClutterActor *actor;
   ClutterModifierType modifier_state;
   gboolean has_button = TRUE;
@@ -434,7 +441,8 @@ clutter_click_action_set_actor (ClutterActorMeta *meta,
                                 ClutterActor     *actor)
 {
   ClutterClickAction *action = CLUTTER_CLICK_ACTION (meta);
-  ClutterClickActionPrivate *priv = action->priv;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (action);
 
   if (priv->event_id != 0)
     {
@@ -488,7 +496,8 @@ clutter_click_action_set_property (GObject      *gobject,
                                    const GValue *value,
                                    GParamSpec   *pspec)
 {
-  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
 
   switch (prop_id)
     {
@@ -512,7 +521,8 @@ clutter_click_action_get_property (GObject    *gobject,
                                    GValue     *value,
                                    GParamSpec *pspec)
 {
-  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
 
   switch (prop_id)
     {
@@ -541,7 +551,8 @@ clutter_click_action_get_property (GObject    *gobject,
 static void
 clutter_click_action_dispose (GObject *gobject)
 {
-  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
+  ClutterClickActionPrivate *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)));
@@ -699,9 +710,11 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
 static void
 clutter_click_action_init (ClutterClickAction *self)
 {
-  self->priv = clutter_click_action_get_instance_private (self);
-  self->priv->long_press_threshold = -1;
-  self->priv->long_press_duration = -1;
+  ClutterClickActionPrivate *priv =
+    clutter_click_action_get_instance_private (self);
+
+  priv->long_press_threshold = -1;
+  priv->long_press_duration = -1;
 }
 
 /**
@@ -741,7 +754,7 @@ clutter_click_action_release (ClutterClickAction *action)
 
   g_return_if_fail (CLUTTER_IS_CLICK_ACTION (action));
 
-  priv = action->priv;
+  priv = clutter_click_action_get_instance_private (action);
 
   if (!priv->is_held)
     return;
@@ -767,9 +780,13 @@ 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);
 
-  return action->priv->press_button;
+  priv = clutter_click_action_get_instance_private (action);
+
+  return priv->press_button;
 }
 
 /**
@@ -785,9 +802,13 @@ 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);
 
-  return action->priv->modifier_state;
+  priv = clutter_click_action_get_instance_private (action);
+
+  return priv->modifier_state;
 }
 
 /**
@@ -805,11 +826,15 @@ 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 = action->priv->press_x;
+    *press_x = priv->press_x;
 
   if (press_y != NULL)
-    *press_y = action->priv->press_y;
+    *press_y = priv->press_y;
 }

clutter/clutter/clutter-click-action.h

@@ -37,32 +37,13 @@
 
 G_BEGIN_DECLS
 
-#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))
+#define CLUTTER_TYPE_CLICK_ACTION (clutter_click_action_get_type ())
 
-typedef struct _ClutterClickAction              ClutterClickAction;
-typedef struct _ClutterClickActionPrivate       ClutterClickActionPrivate;
-typedef struct _ClutterClickActionClass         ClutterClickActionClass;
+CLUTTER_EXPORT
+G_DECLARE_DERIVABLE_TYPE (ClutterClickAction, clutter_click_action,
+                          CLUTTER, CLICK_ACTION, ClutterAction);
 
-/**
- * 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;
-};
+typedef struct _ClutterClickActionPrivate ClutterClickActionPrivate;
 
 /**
  * ClutterClickActionClass:
@@ -97,9 +78,6 @@ 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,6 +52,8 @@
 struct _ClutterClonePrivate
 {
   ClutterActor *clone_source;
+  float x_scale, y_scale;
+
   gulong source_destroy_id;
 };
 
@@ -122,8 +124,6 @@ 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,21 +134,7 @@ clutter_clone_apply_transform (ClutterActor *self, CoglMatrix *matrix)
   if (priv->clone_source == NULL)
     return;
 
-  /* 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);
+  cogl_matrix_scale (matrix, priv->x_scale, priv->y_scale, 1.f);
 }
 
 static void
@@ -240,15 +226,16 @@ clutter_clone_has_overlaps (ClutterActor *actor)
 
 static void
 clutter_clone_allocate (ClutterActor           *self,
-                        const ClutterActorBox  *box,
-                        ClutterAllocationFlags  flags)
+                        const ClutterActorBox  *box)
 {
   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, flags);
+  parent_class->allocate (self, box);
 
   if (priv->clone_source == NULL)
     return;
@@ -258,7 +245,24 @@ 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);
+    clutter_actor_allocate_preferred_size (priv->clone_source);
+
+  clutter_actor_get_allocation_box (priv->clone_source, &source_box);
+
+  /* We need to scale what the clone-source actor paints to fill our own
+   * allocation...
+   */
+  x_scale = clutter_actor_box_get_width (box)
+          / clutter_actor_box_get_width (&source_box);
+  y_scale = clutter_actor_box_get_height (box)
+          / clutter_actor_box_get_height (&source_box);
+
+  if (!G_APPROX_VALUE (priv->x_scale, x_scale, FLT_EPSILON) ||
+      !G_APPROX_VALUE (priv->y_scale, y_scale, FLT_EPSILON))
+    {
+      priv->x_scale = x_scale;
+      priv->y_scale = y_scale;
+    }
 
 #if 0
   /* XXX - this is wrong: ClutterClone cannot clone unparented
@@ -273,7 +277,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, flags);
+    clutter_actor_allocate_preferred_size (priv->clone_source);
 #endif
 }
 
@@ -365,6 +369,9 @@ 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,7 +9,13 @@
 
 G_BEGIN_DECLS
 
-@CLUTTER_CONFIG_DEFINES@
+#mesondefine CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
+#mesondefine CLUTTER_WINDOWING_X11
+#mesondefine CLUTTER_INPUT_X11
+#mesondefine CLUTTER_WINDOWING_GLX
+#mesondefine CLUTTER_WINDOWING_EGL
+#mesondefine CLUTTER_INPUT_EVDEV
+#mesondefine CLUTTER_INPUT_NULL
 
 G_END_DECLS
 

clutter/clutter/clutter-damage-history.c

@@ -0,0 +1,92 @@
+/*
+ * 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

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

clutter/clutter/clutter-deprecated.h

@@ -4,14 +4,11 @@
 #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-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 #ClutterAlpha and #ClutterAnimation. This
+ * The animation modes used by #ClutterAnimatable. This
  * enumeration can be expanded in later versions of Clutter.
  *
  * <figure id="easing-modes">
@@ -554,32 +554,6 @@ typedef enum /*< prefix=CLUTTER_OFFSCREEN_REDIRECT >*/
   CLUTTER_OFFSCREEN_REDIRECT_ON_IDLE               = 1 << 2
 } ClutterOffscreenRedirect;
 
-/**
- * ClutterAllocationFlags:
- * @CLUTTER_ALLOCATION_NONE: No flag set
- * @CLUTTER_ABSOLUTE_ORIGIN_CHANGED: Whether the absolute origin of the
- *   actor has changed; this implies that any ancestor of the actor has
- *   been moved.
- * @CLUTTER_DELEGATE_LAYOUT: Whether the allocation should be delegated
- *   to the #ClutterLayoutManager instance stored inside the
- *   #ClutterActor:layout-manager property of #ClutterActor. This flag
- *   should only be used if you are subclassing #ClutterActor and
- *   overriding the #ClutterActorClass.allocate() virtual function, but
- *   you wish to use the default implementation of the virtual function
- *   inside #ClutterActor. Added in Clutter 1.10.
- *
- * Flags passed to the #ClutterActorClass.allocate() virtual function
- * and to the clutter_actor_allocate() function.
- *
- * Since: 1.0
- */
-typedef enum
-{
-  CLUTTER_ALLOCATION_NONE         = 0,
-  CLUTTER_ABSOLUTE_ORIGIN_CHANGED = 1 << 1,
-  CLUTTER_DELEGATE_LAYOUT         = 1 << 2
-} ClutterAllocationFlags;
-
 /**
  * ClutterAlignAxis:
  * @CLUTTER_ALIGN_X_AXIS: Maintain the alignment on the X axis
@@ -1343,8 +1317,6 @@ 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().
  *
@@ -1354,7 +1326,6 @@ 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,8 +131,7 @@ clutter_fixed_layout_get_preferred_height (ClutterLayoutManager *manager,
 static void
 clutter_fixed_layout_allocate (ClutterLayoutManager   *manager,
                                ClutterContainer       *container,
-                               const ClutterActorBox  *allocation,
-                               ClutterAllocationFlags  flags)
+                               const ClutterActorBox  *allocation)
 {
   ClutterActor *child;
 
@@ -140,7 +139,7 @@ clutter_fixed_layout_allocate (ClutterLayoutManager   *manager,
        child != NULL;
        child = clutter_actor_get_next_sibling (child))
     {
-      clutter_actor_allocate_preferred_size (child, flags);
+      clutter_actor_allocate_preferred_size (child);
     }
 }
 

clutter/clutter/clutter-flow-layout.c

@@ -566,8 +566,7 @@ clutter_flow_layout_get_preferred_height (ClutterLayoutManager *manager,
 static void
 clutter_flow_layout_allocate (ClutterLayoutManager   *manager,
                               ClutterContainer       *container,
-                              const ClutterActorBox  *allocation,
-                              ClutterAllocationFlags  flags)
+                              const ClutterActorBox  *allocation)
 {
   ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (manager)->priv;
   ClutterActor *actor, *child;
@@ -729,7 +728,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, flags);
+      clutter_actor_allocate (child, &child_alloc);
 
       if (priv->orientation == CLUTTER_FLOW_HORIZONTAL)
         item_x = new_x;

clutter/clutter/clutter-gesture-action.c

@@ -157,7 +157,8 @@ G_DEFINE_TYPE_WITH_PRIVATE (ClutterGestureAction, clutter_gesture_action, CLUTTE
 static GesturePoint *
 gesture_register_point (ClutterGestureAction *action, ClutterEvent *event)
 {
-  ClutterGestureActionPrivate *priv = action->priv;
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (action);
   GesturePoint *point = NULL;
 
   if (priv->points->len >= MAX_GESTURE_POINTS)
@@ -190,7 +191,8 @@ gesture_find_point (ClutterGestureAction *action,
                     ClutterEvent *event,
                     gint *position)
 {
-  ClutterGestureActionPrivate *priv = action->priv;
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (action);
   GesturePoint *point = NULL;
   ClutterEventType type = clutter_event_type (event);
   ClutterInputDevice *device = clutter_event_get_device (event);
@@ -220,9 +222,10 @@ gesture_find_point (ClutterGestureAction *action,
 static void
 gesture_unregister_point (ClutterGestureAction *action, gint position)
 {
-  ClutterGestureActionPrivate *priv = action->priv;
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (action);
 
-  if (action->priv->points->len == 0)
+  if (priv->points->len == 0)
     return;
 
   g_array_remove_index (priv->points, position);
@@ -303,7 +306,8 @@ gesture_point_unset (GesturePoint *point)
 static void
 cancel_gesture (ClutterGestureAction *action)
 {
-  ClutterGestureActionPrivate *priv = action->priv;
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (action);
   ClutterActor *actor;
 
   priv->in_gesture = FALSE;
@@ -313,14 +317,15 @@ 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 (action->priv->points, 0);
+  g_array_set_size (priv->points, 0);
 }
 
 static gboolean
 begin_gesture (ClutterGestureAction *action,
                ClutterActor         *actor)
 {
-  ClutterGestureActionPrivate *priv = action->priv;
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (action);
   gboolean return_value;
 
   priv->in_gesture = TRUE;
@@ -353,7 +358,8 @@ stage_captured_event_cb (ClutterActor         *stage,
                          ClutterEvent         *event,
                          ClutterGestureAction *action)
 {
-  ClutterGestureActionPrivate *priv = action->priv;
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (action);
   ClutterActor *actor;
   gint position;
   float threshold_x, threshold_y;
@@ -488,7 +494,8 @@ actor_captured_event_cb (ClutterActor *actor,
                          ClutterEvent *event,
                          ClutterGestureAction *action)
 {
-  ClutterGestureActionPrivate *priv = action->priv;
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (action);
   GesturePoint *point G_GNUC_UNUSED;
 
   if ((clutter_event_type (event) != CLUTTER_BUTTON_PRESS) &&
@@ -522,7 +529,8 @@ static void
 clutter_gesture_action_set_actor (ClutterActorMeta *meta,
                                   ClutterActor     *actor)
 {
-  ClutterGestureActionPrivate *priv = CLUTTER_GESTURE_ACTION (meta)->priv;
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (CLUTTER_GESTURE_ACTION (meta));
   ClutterActorMetaClass *meta_class =
     CLUTTER_ACTOR_META_CLASS (clutter_gesture_action_parent_class);
 
@@ -563,7 +571,8 @@ clutter_gesture_action_set_enabled (ClutterActorMeta *meta,
   ClutterActorMetaClass *meta_class =
     CLUTTER_ACTOR_META_CLASS (clutter_gesture_action_parent_class);
   ClutterGestureAction *gesture_action = CLUTTER_GESTURE_ACTION (meta);
-  ClutterGestureActionPrivate *priv = gesture_action->priv;
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (gesture_action);
 
   if (!is_enabled && priv->in_gesture)
     cancel_gesture (gesture_action);
@@ -585,6 +594,8 @@ 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)
     {
@@ -597,11 +608,15 @@ clutter_gesture_action_set_property (GObject      *gobject,
       break;
 
     case PROP_THRESHOLD_TRIGGER_DISTANCE_X:
-      clutter_gesture_action_set_threshold_trigger_distance (self, g_value_get_float (value), self->priv->distance_y);
+      clutter_gesture_action_set_threshold_trigger_distance (self,
+                                                             g_value_get_float (value),
+                                                             priv->distance_y);
       break;
 
     case PROP_THRESHOLD_TRIGGER_DISTANCE_Y:
-      clutter_gesture_action_set_threshold_trigger_distance (self, self->priv->distance_x, g_value_get_float (value));
+      clutter_gesture_action_set_threshold_trigger_distance (self,
+                                                             priv->distance_x,
+                                                             g_value_get_float (value));
       break;
 
     default:
@@ -616,28 +631,29 @@ clutter_gesture_action_get_property (GObject    *gobject,
                                      GValue     *value,
                                      GParamSpec *pspec)
 {
-  ClutterGestureAction *self = CLUTTER_GESTURE_ACTION (gobject);
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (CLUTTER_GESTURE_ACTION (gobject));
 
   switch (prop_id)
     {
     case PROP_N_TOUCH_POINTS:
-      g_value_set_int (value, self->priv->requested_nb_points);
+      g_value_set_int (value, priv->requested_nb_points);
       break;
 
     case PROP_THRESHOLD_TRIGGER_EDGE:
-      g_value_set_enum (value, self->priv->edge);
+      g_value_set_enum (value, priv->edge);
       break;
 
     case PROP_THRESHOLD_TRIGGER_DISTANCE_X:
-      if (self->priv->distance_x > 0.0)
-        g_value_set_float (value, self->priv->distance_x);
+      if (priv->distance_x > 0.0)
+        g_value_set_float (value, priv->distance_x);
       else
         g_value_set_float (value, gesture_get_default_threshold ());
       break;
 
     case PROP_THRESHOLD_TRIGGER_DISTANCE_Y:
-      if (self->priv->distance_y > 0.0)
-        g_value_set_float (value, self->priv->distance_y);
+      if (priv->distance_y > 0.0)
+        g_value_set_float (value, priv->distance_y);
       else
         g_value_set_float (value, gesture_get_default_threshold ());
       break;
@@ -651,7 +667,8 @@ clutter_gesture_action_get_property (GObject    *gobject,
 static void
 clutter_gesture_action_finalize (GObject *gobject)
 {
-  ClutterGestureActionPrivate *priv = CLUTTER_GESTURE_ACTION (gobject)->priv;
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (CLUTTER_GESTURE_ACTION (gobject));
 
   g_array_unref (priv->points);
 
@@ -843,13 +860,14 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
 static void
 clutter_gesture_action_init (ClutterGestureAction *self)
 {
-  self->priv = clutter_gesture_action_get_instance_private (self);
+  ClutterGestureActionPrivate *priv =
+    clutter_gesture_action_get_instance_private (self);
 
-  self->priv->points = g_array_sized_new (FALSE, TRUE, sizeof (GesturePoint), 3);
-  g_array_set_clear_func (self->priv->points, (GDestroyNotify) gesture_point_unset);
+  priv->points = g_array_sized_new (FALSE, TRUE, sizeof (GesturePoint), 3);
+  g_array_set_clear_func (priv->points, (GDestroyNotify) gesture_point_unset);
 
-  self->priv->requested_nb_points = 1;
-  self->priv->edge = CLUTTER_GESTURE_TRIGGER_EDGE_NONE;
+  priv->requested_nb_points = 1;
+  priv->edge = CLUTTER_GESTURE_TRIGGER_EDGE_NONE;
 }
 
 /**
@@ -888,16 +906,21 @@ 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 (action->priv->points,
+    *press_x = g_array_index (priv->points,
                               GesturePoint,
                               point).press_x;
 
   if (press_y)
-    *press_y = g_array_index (action->priv->points,
+    *press_y = g_array_index (priv->points,
                               GesturePoint,
                               point).press_y;
 }
@@ -923,16 +946,21 @@ 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 (action->priv->points,
+    *motion_x = g_array_index (priv->points,
                                GesturePoint,
                                point).last_motion_x;
 
   if (motion_y)
-    *motion_y = g_array_index (action->priv->points,
+    *motion_y = g_array_index (priv->points,
                                GesturePoint,
                                point).last_motion_y;
 }
@@ -960,15 +988,19 @@ 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);
 
-  d_x = g_array_index (action->priv->points,
+  priv = clutter_gesture_action_get_instance_private (action);
+
+  g_return_val_if_fail (priv->points->len > point, 0);
+
+  d_x = g_array_index (priv->points,
                        GesturePoint,
                        point).last_delta_x;
-  d_y = g_array_index (action->priv->points,
+  d_y = g_array_index (priv->points,
                        GesturePoint,
                        point).last_delta_y;
 
@@ -1002,16 +1034,21 @@ 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 (action->priv->points,
+    *release_x = g_array_index (priv->points,
                                 GesturePoint,
                                 point).release_x;
 
   if (release_y)
-    *release_y = g_array_index (action->priv->points,
+    *release_y = g_array_index (priv->points,
                                 GesturePoint,
                                 point).release_y;
 }
@@ -1037,16 +1074,20 @@ 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 (action->priv->points,
+  d_t = g_array_index (priv->points,
                        GesturePoint,
                        point).last_delta_time;
 
@@ -1073,9 +1114,13 @@ 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);
 
-  return action->priv->requested_nb_points;
+  priv = clutter_gesture_action_get_instance_private (action);
+
+  return priv->requested_nb_points;
 }
 
 /**
@@ -1096,7 +1141,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 = action->priv;
+  priv = clutter_gesture_action_get_instance_private (action);
 
   if (priv->requested_nb_points == nb_points)
     return;
@@ -1150,9 +1195,13 @@ 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);
 
-  return action->priv->points->len;
+  priv = clutter_gesture_action_get_instance_private (action);
+
+  return priv->points->len;
 }
 
 /**
@@ -1170,10 +1219,15 @@ ClutterEventSequence *
 clutter_gesture_action_get_sequence (ClutterGestureAction *action,
                                      guint                 point)
 {
-  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), NULL);
-  g_return_val_if_fail (action->priv->points->len > point, NULL);
+  ClutterGestureActionPrivate *priv;
 
-  return g_array_index (action->priv->points, GesturePoint, point).sequence;
+  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), NULL);
+
+  priv = clutter_gesture_action_get_instance_private (action);
+
+  g_return_val_if_fail (priv->points->len > point, NULL);
+
+  return g_array_index (priv->points, GesturePoint, point).sequence;
 }
 
 /**
@@ -1192,10 +1246,15 @@ ClutterInputDevice *
 clutter_gesture_action_get_device (ClutterGestureAction *action,
                                    guint                 point)
 {
-  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), NULL);
-  g_return_val_if_fail (action->priv->points->len > point, NULL);
+  ClutterGestureActionPrivate *priv;
 
-  return g_array_index (action->priv->points, GesturePoint, point).device;
+  g_return_val_if_fail (CLUTTER_IS_GESTURE_ACTION (action), NULL);
+
+  priv = clutter_gesture_action_get_instance_private (action);
+
+  g_return_val_if_fail (priv->points->len > point, NULL);
+
+  return g_array_index (priv->points, GesturePoint, point).device;
 }
 
 /**
@@ -1215,11 +1274,15 @@ 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);
 
-  gesture_point = &g_array_index (action->priv->points, GesturePoint, point);
+  priv = clutter_gesture_action_get_instance_private (action);
+
+  g_return_val_if_fail (priv->points->len > point, NULL);
+
+  gesture_point = &g_array_index (priv->points, GesturePoint, point);
 
   return gesture_point->last_event;
 }
@@ -1256,12 +1319,16 @@ void
 clutter_gesture_action_set_threshold_trigger_edge (ClutterGestureAction      *action,
                                                    ClutterGestureTriggerEdge  edge)
 {
+  ClutterGestureActionPrivate *priv;
+
   g_return_if_fail (CLUTTER_IS_GESTURE_ACTION (action));
 
-  if (action->priv->edge == edge)
+  priv = clutter_gesture_action_get_instance_private (action);
+
+  if (priv->edge == edge)
     return;
 
-  action->priv->edge = edge;
+  priv->edge = edge;
 
   g_object_notify_by_pspec (G_OBJECT (action), gesture_props[PROP_THRESHOLD_TRIGGER_EDGE]);
 }
@@ -1280,10 +1347,14 @@ 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);
 
-  return action->priv->edge;
+  priv = clutter_gesture_action_get_instance_private (action);
+
+  return priv->edge;
 }
 
 /**
@@ -1323,17 +1394,21 @@ clutter_gesture_action_set_threshold_trigger_distance (ClutterGestureAction
                                                        float                      x,
                                                        float                      y)
 {
+  ClutterGestureActionPrivate *priv;
+
   g_return_if_fail (CLUTTER_IS_GESTURE_ACTION (action));
 
-  if (fabsf (x - action->priv->distance_x) > FLOAT_EPSILON)
+  priv = clutter_gesture_action_get_instance_private (action);
+
+  if (fabsf (x - priv->distance_x) > FLOAT_EPSILON)
     {
-      action->priv->distance_x = x;
+      priv->distance_x = x;
       g_object_notify_by_pspec (G_OBJECT (action), gesture_props[PROP_THRESHOLD_TRIGGER_DISTANCE_X]);
     }
 
-  if (fabsf (y - action->priv->distance_y) > FLOAT_EPSILON)
+  if (fabsf (y - priv->distance_y) > FLOAT_EPSILON)
     {
-      action->priv->distance_y = y;
+      priv->distance_y = y;
       g_object_notify_by_pspec (G_OBJECT (action), gesture_props[PROP_THRESHOLD_TRIGGER_DISTANCE_Y]);
     }
 }
@@ -1354,19 +1429,23 @@ 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 (action->priv->distance_x > 0.0)
-        *x = action->priv->distance_x;
+      if (priv->distance_x > 0.0)
+        *x = priv->distance_x;
       else
         *x = gesture_get_default_threshold ();
     }
   if (y != NULL)
     {
-      if (action->priv->distance_y > 0.0)
-        *y = action->priv->distance_y;
+      if (priv->distance_y > 0.0)
+        *y = priv->distance_y;
       else
         *y = gesture_get_default_threshold ();
     }

clutter/clutter/clutter-gesture-action.h

@@ -34,32 +34,13 @@
 
 G_BEGIN_DECLS
 
-#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))
+#define CLUTTER_TYPE_GESTURE_ACTION (clutter_gesture_action_get_type ())
 
-typedef struct _ClutterGestureAction              ClutterGestureAction;
-typedef struct _ClutterGestureActionPrivate       ClutterGestureActionPrivate;
-typedef struct _ClutterGestureActionClass         ClutterGestureActionClass;
+CLUTTER_EXPORT
+G_DECLARE_DERIVABLE_TYPE (ClutterGestureAction, clutter_gesture_action,
+                          CLUTTER, GESTURE_ACTION, ClutterAction);
 
-/**
- * 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;
-};
+typedef struct _ClutterGestureActionPrivate ClutterGestureActionPrivate;
 
 /**
  * ClutterGestureActionClass:
@@ -101,9 +82,6 @@ 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,8 +1391,7 @@ allocate_child (ClutterGridRequest *request,
 static void
 clutter_grid_layout_allocate (ClutterLayoutManager   *layout,
                               ClutterContainer       *container,
-                              const ClutterActorBox  *allocation,
-                              ClutterAllocationFlags  flags)
+                              const ClutterActorBox  *allocation)
 {
   ClutterGridLayout *self = CLUTTER_GRID_LAYOUT (layout);
   ClutterOrientation orientation;
@@ -1453,7 +1452,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, flags);
+      clutter_actor_allocate (child, &child_allocation);
     }
 }
 

clutter/clutter/clutter-input-device.c

@@ -692,20 +692,6 @@ _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,
@@ -815,7 +801,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;
@@ -850,7 +836,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);
@@ -1054,7 +1040,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);
 
@@ -1085,22 +1071,33 @@ clutter_input_device_update (ClutterInputDevice   *device,
 }
 
 /**
- * clutter_input_device_get_pointer_actor:
- * @device: a #ClutterInputDevice of type %CLUTTER_POINTER_DEVICE
+ * clutter_input_device_get_actor:
+ * @device: a #ClutterInputDevice
+ * @sequence: (allow-none): an optional #ClutterEventSequence
  *
- * Retrieves the #ClutterActor underneath the pointer of @device
+ * Retrieves the #ClutterActor underneath the pointer or touchpoint
+ * of @device and @sequence.
  *
  * Return value: (transfer none): a pointer to the #ClutterActor or %NULL
  *
  * Since: 1.2
  */
 ClutterActor *
-clutter_input_device_get_pointer_actor (ClutterInputDevice *device)
+clutter_input_device_get_actor (ClutterInputDevice   *device,
+                                ClutterEventSequence *sequence)
 {
-  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), NULL);
-  g_return_val_if_fail (device->device_type == CLUTTER_POINTER_DEVICE, NULL);
+  ClutterTouchInfo *info;
 
-  return device->cursor_actor;
+  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), NULL);
+
+  if (sequence == NULL)
+    return device->cursor_actor;
+
+  info = g_hash_table_lookup (device->touch_sequences_info, sequence);
+
+  g_return_val_if_fail (info != NULL, NULL);
+
+  return info->actor;
 }
 
 /**

clutter/clutter/clutter-input-device.h

@@ -92,7 +92,8 @@ 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_pointer_actor  (ClutterInputDevice  *device);
+ClutterActor *          clutter_input_device_get_actor (ClutterInputDevice   *device,
+                                                        ClutterEventSequence *sequence);
 CLUTTER_EXPORT
 ClutterStage *          clutter_input_device_get_pointer_stage  (ClutterInputDevice  *device);
 CLUTTER_EXPORT

clutter/clutter/clutter-interval.c

@@ -37,9 +37,6 @@
  * any object taking a reference on a #ClutterInterval instance should
  * also take ownership of the interval by using g_object_ref_sink().
  *
- * #ClutterInterval is used by #ClutterAnimation to define the
- * interval of values that an implicit animation should tween over.
- *
  * #ClutterInterval can be subclassed to override the validation
  * and value computation.
  *

clutter/clutter/clutter-layout-manager.c

@@ -136,7 +136,6 @@
 
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "deprecated/clutter-container.h"
-#include "deprecated/clutter-alpha.h"
 
 #include "clutter-debug.h"
 #include "clutter-layout-manager.h"
@@ -164,7 +163,6 @@ 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, };
 
@@ -255,8 +253,7 @@ layout_manager_real_get_preferred_height (ClutterLayoutManager *manager,
 static void
 layout_manager_real_allocate (ClutterLayoutManager   *manager,
                               ClutterContainer       *container,
-                              const ClutterActorBox  *allocation,
-                              ClutterAllocationFlags  flags)
+                              const ClutterActorBox  *allocation)
 {
   LAYOUT_MANAGER_WARN_NOT_IMPLEMENTED (manager, "allocate");
 }
@@ -301,96 +298,12 @@ 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;
@@ -398,9 +311,6 @@ 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;
 
   /**
@@ -523,7 +433,6 @@ 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
  *
@@ -534,8 +443,7 @@ clutter_layout_manager_get_preferred_height (ClutterLayoutManager *manager,
 void
 clutter_layout_manager_allocate (ClutterLayoutManager   *manager,
                                  ClutterContainer       *container,
-                                 const ClutterActorBox  *allocation,
-                                 ClutterAllocationFlags  flags)
+                                 const ClutterActorBox  *allocation)
 {
   ClutterLayoutManagerClass *klass;
 
@@ -544,7 +452,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, flags);
+  klass->allocate (manager, container, allocation);
 }
 
 /**

clutter/clutter/clutter-layout-manager.h

@@ -115,8 +115,7 @@ struct _ClutterLayoutManagerClass
                                                  gfloat                 *nat_height_p);
   void               (* allocate)               (ClutterLayoutManager   *manager,
                                                  ClutterContainer       *container,
-                                                 const ClutterActorBox  *allocation,
-                                                 ClutterAllocationFlags  flags);
+                                                 const ClutterActorBox  *allocation);
 
   void               (* set_container)          (ClutterLayoutManager   *manager,
                                                  ClutterContainer       *container);
@@ -126,15 +125,6 @@ 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 >*/
@@ -167,8 +157,7 @@ void               clutter_layout_manager_get_preferred_height  (ClutterLayoutMa
 CLUTTER_EXPORT
 void               clutter_layout_manager_allocate              (ClutterLayoutManager   *manager,
                                                                  ClutterContainer       *container,
-                                                                 const ClutterActorBox  *allocation,
-                                                                 ClutterAllocationFlags  flags);
+                                                                 const ClutterActorBox  *allocation);
 
 CLUTTER_EXPORT
 void               clutter_layout_manager_set_container         (ClutterLayoutManager   *manager,

clutter/clutter/clutter-main.c

@@ -1653,6 +1653,8 @@ static inline void
 emit_keyboard_event (ClutterEvent       *event,
                      ClutterInputDevice *device)
 {
+  cally_snoop_key_event ((ClutterKeyEvent *) event);
+
   if (_clutter_event_process_filters (event))
     return;
 
@@ -2049,7 +2051,8 @@ _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;
@@ -2084,7 +2087,8 @@ _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;
@@ -2392,8 +2396,7 @@ clutter_threads_add_repaint_func_full (ClutterRepaintFlags flags,
 
   repaint_func->id = context->last_repaint_id++;
 
-  /* 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->flags = flags;
   repaint_func->func = func;
   repaint_func->data = data;
   repaint_func->notify = notify;
@@ -2403,13 +2406,6 @@ clutter_threads_add_repaint_func_full (ClutterRepaintFlags flags,
 
   _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

@@ -199,7 +199,7 @@ master_clock_schedule_stage_updates (ClutterMasterClockDefault *master_clock)
   stages = clutter_stage_manager_peek_stages (stage_manager);
 
   for (l = stages; l != NULL; l = l->next)
-    _clutter_stage_schedule_update (l->data);
+    clutter_stage_schedule_update (l->data);
 }
 
 static GSList *
@@ -252,7 +252,7 @@ master_clock_reschedule_stage_updates (ClutterMasterClockDefault *master_clock,
       if (master_clock->timelines ||
           _clutter_stage_has_queued_events (l->data) ||
           _clutter_stage_needs_update (l->data))
-        _clutter_stage_schedule_update (l->data);
+        clutter_stage_schedule_update (l->data);
     }
 }
 

clutter/clutter/clutter-mutter.h

@@ -36,6 +36,9 @@
 #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
 void clutter_set_custom_backend_func (ClutterBackend *(* func) (void));
 
@@ -48,6 +51,23 @@ void clutter_stage_capture_into (ClutterStage          *stage,
                                  cairo_rectangle_int_t *rect,
                                  uint8_t               *data);
 
+CLUTTER_EXPORT
+void clutter_stage_paint_to_framebuffer (ClutterStage                *stage,
+                                         CoglFramebuffer             *framebuffer,
+                                         const cairo_rectangle_int_t *rect,
+                                         float                        scale,
+                                         ClutterPaintFlag             paint_flags);
+
+CLUTTER_EXPORT
+gboolean clutter_stage_paint_to_buffer (ClutterStage                 *stage,
+                                        const cairo_rectangle_int_t  *rect,
+                                        float                         scale,
+                                        uint8_t                      *data,
+                                        int                           stride,
+                                        CoglPixelFormat               format,
+                                        ClutterPaintFlag              paint_flags,
+                                        GError                      **error);
+
 CLUTTER_EXPORT
 void clutter_stage_freeze_updates (ClutterStage *stage);
 
@@ -55,11 +75,18 @@ CLUTTER_EXPORT
 void clutter_stage_thaw_updates (ClutterStage *stage);
 
 CLUTTER_EXPORT
-void clutter_stage_update_resource_scales (ClutterStage *stage);
+void clutter_stage_clear_stage_views (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-paint-context-private.h

@@ -21,7 +21,8 @@
 #include "clutter-paint-context.h"
 
 ClutterPaintContext * clutter_paint_context_new_for_view (ClutterStageView     *view,
-                                                          const cairo_region_t *redraw_clip);
+                                                          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,6 +23,8 @@ struct _ClutterPaintContext
 {
   grefcount ref_count;
 
+  ClutterPaintFlag paint_flags;
+
   GList *framebuffers;
 
   ClutterStageView *view;
@@ -36,7 +38,8 @@ G_DEFINE_BOXED_TYPE (ClutterPaintContext, clutter_paint_context,
 
 ClutterPaintContext *
 clutter_paint_context_new_for_view (ClutterStageView     *view,
-                                    const cairo_region_t *redraw_clip)
+                                    const cairo_region_t *redraw_clip,
+                                    ClutterPaintFlag      paint_flags)
 {
   ClutterPaintContext *paint_context;
   CoglFramebuffer *framebuffer;
@@ -45,6 +48,7 @@ clutter_paint_context_new_for_view (ClutterStageView     *view,
   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);
@@ -56,12 +60,16 @@ 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);
 
@@ -170,3 +178,12 @@ 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,13 +29,21 @@
 
 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);
@@ -62,4 +70,7 @@ 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-pan-action.c

@@ -136,7 +136,8 @@ enum
 
 static guint pan_signals[LAST_SIGNAL] = { 0, };
 
-G_DEFINE_TYPE_WITH_PRIVATE (ClutterPanAction, clutter_pan_action, CLUTTER_TYPE_GESTURE_ACTION)
+G_DEFINE_TYPE_WITH_PRIVATE (ClutterPanAction, clutter_pan_action,
+                            CLUTTER_TYPE_GESTURE_ACTION)
 
 static void
 emit_pan (ClutterPanAction *self,
@@ -156,14 +157,18 @@ emit_pan (ClutterPanAction *self,
           gfloat scroll_threshold = G_PI_4/2;
           gfloat drag_angle;
 
-          clutter_gesture_action_get_motion_delta (CLUTTER_GESTURE_ACTION (self), 0, &delta_x, &delta_y);
+          clutter_gesture_action_get_motion_delta (CLUTTER_GESTURE_ACTION (self),
+                                                   0,
+                                                   &delta_x,
+                                                   &delta_y);
 
           if (delta_x != 0.0f)
             drag_angle = atanf (delta_y / delta_x);
           else
             drag_angle = G_PI_2;
 
-          if ((drag_angle > -scroll_threshold) && (drag_angle < scroll_threshold))
+          if ((drag_angle > -scroll_threshold) &&
+              (drag_angle < scroll_threshold))
             priv->pin_state = SCROLL_PINNED_HORIZONTAL;
           else if ((drag_angle > (G_PI_2 - scroll_threshold)) ||
                     (drag_angle < -(G_PI_2 - scroll_threshold)))
@@ -282,7 +287,10 @@ gesture_end (ClutterGestureAction *gesture,
   gfloat tau;
   gint duration;
 
-  clutter_gesture_action_get_release_coords (CLUTTER_GESTURE_ACTION (self), 0, &priv->release_x, &priv->release_y);
+  clutter_gesture_action_get_release_coords (CLUTTER_GESTURE_ACTION (self),
+                                             0,
+                                             &priv->release_x,
+                                             &priv->release_y);
 
   if (!priv->should_interpolate)
     {
@@ -293,7 +301,9 @@ gesture_end (ClutterGestureAction *gesture,
   priv->state = PAN_STATE_INTERPOLATING;
 
   clutter_gesture_action_get_motion_delta (gesture, 0, &delta_x, &delta_y);
-  velocity = clutter_gesture_action_get_velocity (gesture, 0, &velocity_x, &velocity_y);
+  velocity = clutter_gesture_action_get_velocity (gesture, 0,
+                                                  &velocity_x,
+                                                  &velocity_y);
 
   /* Exponential timing constant v(t) = v(0) * exp(-t/tau)
    * tau = 1000ms / (frame_per_second * - ln(decay_per_frame))
@@ -304,17 +314,22 @@ gesture_end (ClutterGestureAction *gesture,
   /* See where the decreasing velocity reaches $min_velocity px/ms
    * v(t) = v(0) * exp(-t/tau) = min_velocity
    * t = - tau * ln( min_velocity / |v(0)|) */
-  duration = - tau * logf (min_velocity / (ABS (velocity) * priv->acceleration_factor));
+  duration = - tau * logf (min_velocity / (ABS (velocity) *
+                                           priv->acceleration_factor));
 
   /* Target point: x(t) = v(0) * tau * [1 - exp(-t/tau)] */
-  priv->target_x = velocity_x * priv->acceleration_factor * tau * (1 - exp ((float)-duration / tau));
-  priv->target_y = velocity_y * priv->acceleration_factor * tau * (1 - exp ((float)-duration / tau));
+  priv->target_x = (velocity_x * priv->acceleration_factor * tau *
+                    (1 - exp ((float)-duration / tau)));
+  priv->target_y = (velocity_y * priv->acceleration_factor * tau *
+                    (1 - exp ((float)-duration / tau)));
 
-  if (ABS (velocity) * priv->acceleration_factor > min_velocity && duration > FLOAT_EPSILON)
+  if (ABS (velocity) * priv->acceleration_factor > min_velocity &&
+      duration > FLOAT_EPSILON)
     {
       priv->interpolated_x = priv->interpolated_y = 0.0f;
       priv->deceleration_timeline = clutter_timeline_new (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);
@@ -367,7 +382,8 @@ clutter_pan_action_set_property (GObject      *gobject,
       break;
 
     case PROP_ACCELERATION_FACTOR :
-      clutter_pan_action_set_acceleration_factor (self, g_value_get_double (value));
+      clutter_pan_action_set_acceleration_factor (self,
+                                                  g_value_get_double (value));
       break;
 
     default:
@@ -411,9 +427,11 @@ static void
 clutter_pan_action_constructed (GObject *gobject)
 {
   ClutterGestureAction *gesture;
+  ClutterGestureTriggerEdge edge;
 
   gesture = CLUTTER_GESTURE_ACTION (gobject);
-  clutter_gesture_action_set_threshold_trigger_edge (gesture, CLUTTER_GESTURE_TRIGGER_EDGE_AFTER);
+  edge = CLUTTER_GESTURE_TRIGGER_EDGE_AFTER;
+  clutter_gesture_action_set_threshold_trigger_edge (gesture, edge);
 }
 
 static void
@@ -442,7 +460,8 @@ clutter_pan_action_set_actor (ClutterActorMeta *meta,
         g_clear_object (&priv->deceleration_timeline);
     }
 
-  CLUTTER_ACTOR_META_CLASS (clutter_pan_action_parent_class)->set_actor (meta, actor);
+  CLUTTER_ACTOR_META_CLASS (clutter_pan_action_parent_class)->set_actor (meta,
+                                                                         actor);
 }
 
 
@@ -880,7 +899,9 @@ clutter_pan_action_get_constrained_motion_delta (ClutterPanAction *self,
 
   priv = self->priv;
 
-  distance = clutter_pan_action_get_motion_delta (self, point, &delta_x, &delta_y);
+  distance = clutter_pan_action_get_motion_delta (self, point,
+                                                  &delta_x,
+                                                  &delta_y);
 
   switch (priv->pan_axis)
     {

clutter/clutter/clutter-private.h

@@ -65,7 +65,6 @@ 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)
@@ -99,7 +98,6 @@ 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,
 

clutter/clutter/clutter-script-parser.c

@@ -34,7 +34,6 @@
 
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "deprecated/clutter-container.h"
-#include "deprecated/clutter-alpha.h"
 
 #include "clutter-actor.h"
 #include "clutter-debug.h"
@@ -799,232 +798,6 @@ 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)
@@ -1750,7 +1523,7 @@ clutter_script_construct_parameters (ClutterScript  *script,
           continue;
         }
 
-      if (!(pspec->flags & G_PARAM_CONSTRUCT_ONLY))
+      if (!(pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY)))
         {
           unparsed = g_list_prepend (unparsed, pinfo);
           continue;

clutter/clutter/clutter-script-private.h

@@ -110,8 +110,6 @@ 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);
@@ -128,8 +126,6 @@ gboolean _clutter_script_parse_rect        (ClutterScript   *script,
 gboolean _clutter_script_parse_color       (ClutterScript   *script,
                                             JsonNode        *node,
                                             ClutterColor    *color);
-GObject *_clutter_script_parse_alpha       (ClutterScript   *script,
-                                            JsonNode        *node);
 gboolean _clutter_script_parse_point       (ClutterScript    *script,
                                             JsonNode         *node,
                                             graphene_point_t *point);

clutter/clutter/clutter-script.c

@@ -98,49 +98,6 @@
  * respectively) and the "object" string member for calling
  * g_signal_connect_object() instead of g_signal_connect().
  *
- * Signals can also be directly attached to a specific state defined
- * inside a #ClutterState instance, for instance:
- *
- * |[
- *   ...
- *   "signals" : [
- *     {
- *       "name" : "enter-event",
- *       "states" : "button-states",
- *       "target-state" : "hover"
- *     },
- *     {
- *       "name" : "leave-event",
- *       "states" : "button-states",
- *       "target-state" : "base"
- *     },
- *     {
- *       "name" : "button-press-event",
- *       "states" : "button-states",
- *       "target-state" : "active",
- *     },
- *     {
- *       "name" : "key-press-event",
- *       "states" : "button-states",
- *       "target-state" : "key-focus",
- *       "warp" : true
- *     }
- *   ],
- *   ...
- * ]|
- *
- * The "states" key defines the #ClutterState instance to be used to
- * resolve the "target-state" key; it can be either a script id for a
- * #ClutterState built by the same #ClutterScript instance, or to a
- * #ClutterState built in code and associated to the #ClutterScript
- * instance through the clutter_script_add_states() function. If no
- * "states" key is present, then the default #ClutterState associated to
- * the #ClutterScript instance will be used; the default #ClutterState
- * can be set using clutter_script_add_states() using a %NULL name. The
- * "warp" key can be used to warp to a specific state instead of
- * animating to it. State changes on signal emission will not affect
- * the signal emission chain.
- *
  * Clutter reserves the following names, so classes defining properties
  * through the usual GObject registration process should avoid using these
  * names to avoid collisions:
@@ -184,9 +141,7 @@
 #include "clutter-private.h"
 #include "clutter-debug.h"
 
-#include "deprecated/clutter-alpha.h"
 #include "deprecated/clutter-container.h"
-#include "deprecated/clutter-state.h"
 
 enum
 {
@@ -210,8 +165,6 @@ struct _ClutterScriptPrivate
 
   ClutterScriptParser *parser;
 
-  GHashTable *states;
-
   gchar **search_paths;
 
   gchar *translation_domain;
@@ -264,7 +217,6 @@ signal_info_free (gpointer data)
       g_free (sinfo->name);
       g_free (sinfo->handler);
       g_free (sinfo->object);
-      g_free (sinfo->state);
       g_free (sinfo->target);
 
       g_slice_free (SignalInfo, sinfo);
@@ -319,7 +271,6 @@ clutter_script_finalize (GObject *gobject)
   g_hash_table_destroy (priv->objects);
   g_strfreev (priv->search_paths);
   g_free (priv->filename);
-  g_hash_table_destroy (priv->states);
   g_free (priv->translation_domain);
 
   G_OBJECT_CLASS (clutter_script_parent_class)->finalize (gobject);
@@ -454,9 +405,6 @@ clutter_script_init (ClutterScript *script)
   priv->objects = g_hash_table_new_full (g_str_hash, g_str_equal,
                                          NULL,
                                          object_info_free);
-  priv->states = g_hash_table_new_full (g_str_hash, g_str_equal,
-                                        g_free,
-                                        (GDestroyNotify) g_object_unref);
 }
 
 /**
@@ -972,65 +920,12 @@ clutter_script_connect_signals (ClutterScript *script,
   g_free (cd);
 }
 
-typedef struct {
-  ClutterState *state;
-  GObject *emitter;
-  gchar *target;
-  gulong signal_id;
-  gulong hook_id;
-  gboolean warp_to;
-} HookData;
-
 typedef struct {
   ClutterScript *script;
   ClutterScriptConnectFunc func;
   gpointer user_data;
 } SignalConnectData;
 
-static void
-hook_data_free (gpointer data)
-{
-  if (G_LIKELY (data != NULL))
-    {
-      HookData *hook_data = data;
-
-      g_free (hook_data->target);
-      g_slice_free (HookData, hook_data);
-    }
-}
-
-static gboolean
-clutter_script_state_change_hook (GSignalInvocationHint *ihint,
-                                  guint                  n_params,
-                                  const GValue          *params,
-                                  gpointer               user_data)
-{
-  HookData *hook_data = user_data;
-  GObject *emitter;
-
-  emitter = g_value_get_object (&params[0]);
-
-  if (emitter == hook_data->emitter)
-    {
-      if (hook_data->warp_to)
-        clutter_state_warp_to_state (hook_data->state, hook_data->target);
-      else
-        clutter_state_set_state (hook_data->state, hook_data->target);
-    }
-
-  return TRUE;
-}
-
-static void
-clutter_script_remove_state_change_hook (gpointer  user_data,
-                                         GObject  *object_p)
-{
-  HookData *hook_data = user_data;
-
-  g_signal_remove_emission_hook (hook_data->signal_id,
-                                 hook_data->hook_id);
-}
-
 static void
 connect_each_object (gpointer key,
                      gpointer value,
@@ -1070,64 +965,7 @@ connect_each_object (gpointer key,
         }
       else
         {
-          GObject *state_object = NULL;
-          const gchar *signal_name, *signal_detail;
-          gchar **components;
-          GQuark signal_quark;
-          guint signal_id;
-          HookData *hook_data;
-
-          if (sinfo->state == NULL)
-            state_object = (GObject *) clutter_script_get_states (script, NULL);
-          else
-            {
-              state_object = clutter_script_get_object (script, sinfo->state);
-              if (state_object == NULL)
-                state_object = (GObject *) clutter_script_get_states (script, sinfo->state);
-            }
-
-          if (state_object == NULL)
-            continue;
-
-          components = g_strsplit (sinfo->name, "::", 2);
-          if (g_strv_length (components) == 2)
-            {
-              signal_name = components[0];
-              signal_detail = components[1];
-            }
-          else
-            {
-              signal_name = components[0];
-              signal_detail = NULL;
-            }
-
-          signal_id = g_signal_lookup (signal_name, G_OBJECT_TYPE (object));
-          if (signal_id == 0)
-            {
-              g_strfreev (components);
-              continue;
-            }
-
-          if (signal_detail != NULL)
-            signal_quark = g_quark_from_string (signal_detail);
-          else
-            signal_quark = 0;
-
-          hook_data = g_slice_new (HookData);
-          hook_data->emitter = object;
-          hook_data->state = CLUTTER_STATE (state_object);
-          hook_data->target = g_strdup (sinfo->target);
-          hook_data->warp_to = sinfo->warp_to;
-          hook_data->signal_id = signal_id;
-          hook_data->hook_id =
-            g_signal_add_emission_hook (signal_id, signal_quark,
-                                        clutter_script_state_change_hook,
-                                        hook_data,
-                                        hook_data_free);
-
-          g_object_weak_ref (hook_data->emitter,
-                             clutter_script_remove_state_change_hook,
-                             hook_data);
+          g_warn_if_reached ();
         }
 
       signal_info_free (sinfo);
@@ -1352,72 +1190,6 @@ clutter_script_list_objects (ClutterScript *script)
   return retval;
 }
 
-/**
- * clutter_script_add_states:
- * @script: a #ClutterScript
- * @name: (allow-none): a name for the @state, or %NULL to
- *   set the default #ClutterState
- * @state: a #ClutterState
- *
- * Associates a #ClutterState to the #ClutterScript instance using the given
- * name.
- *
- * The #ClutterScript instance will use @state to resolve target states when
- * connecting signal handlers.
- *
- * The #ClutterScript instance will take a reference on the #ClutterState
- * passed to this function.
- *
- * Since: 1.8
- *
- * Deprecated: 1.12
- */
-void
-clutter_script_add_states (ClutterScript *script,
-                           const gchar   *name,
-                           ClutterState  *state)
-{
-  g_return_if_fail (CLUTTER_IS_SCRIPT (script));
-  g_return_if_fail (CLUTTER_IS_STATE (state));
-
-  if (name == NULL || *name == '\0')
-    name = "__clutter_script_default_state";
-
-  g_hash_table_replace (script->priv->states,
-                        g_strdup (name),
-                        g_object_ref (state));
-}
-
-/**
- * clutter_script_get_states:
- * @script: a #ClutterScript
- * @name: (allow-none): the name of the #ClutterState, or %NULL
- *
- * Retrieves the #ClutterState for the given @state_name.
- *
- * If @name is %NULL, this function will return the default
- * #ClutterState instance.
- *
- * Return value: (transfer none): a pointer to the #ClutterState for the
- *   given name. The #ClutterState is owned by the #ClutterScript instance
- *   and it should not be unreferenced
- *
- * Since: 1.8
- *
- * Deprecated: 1.12
- */
-ClutterState *
-clutter_script_get_states (ClutterScript *script,
-                           const gchar   *name)
-{
-  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), NULL);
-
-  if (name == NULL || *name == '\0')
-    name = "__clutter_script_default_state";
-
-  return g_hash_table_lookup (script->priv->states, name);
-}
-
 /**
  * clutter_script_set_translation_domain:
  * @script: a #ClutterScript

clutter/clutter/clutter-script.h

@@ -179,15 +179,6 @@ void            clutter_script_unmerge_objects          (ClutterScript
 CLUTTER_EXPORT
 void            clutter_script_ensure_objects           (ClutterScript             *script);
 
-CLUTTER_DEPRECATED
-void            clutter_script_add_states               (ClutterScript             *script,
-                                                         const gchar               *name,
-                                                         ClutterState              *state);
-
-CLUTTER_DEPRECATED
-ClutterState *  clutter_script_get_states               (ClutterScript             *script,
-                                                         const gchar               *name);
-
 CLUTTER_EXPORT
 void            clutter_script_connect_signals          (ClutterScript             *script,
                                                          gpointer                   user_data);

clutter/clutter/clutter-seat.c

@@ -354,6 +354,17 @@ clutter_seat_get_keyboard (ClutterSeat *seat)
   return CLUTTER_SEAT_GET_CLASS (seat)->get_keyboard (seat);
 }
 
+/**
+ * clutter_seat_peek_devices: (skip)
+ **/
+const GList *
+clutter_seat_peek_devices (ClutterSeat *seat)
+{
+  g_return_val_if_fail (CLUTTER_IS_SEAT (seat), NULL);
+
+  return CLUTTER_SEAT_GET_CLASS (seat)->peek_devices (seat);
+}
+
 /**
  * clutter_seat_list_devices:
  * @seat: a #ClutterSeat
@@ -370,7 +381,7 @@ clutter_seat_list_devices (ClutterSeat *seat)
 {
   g_return_val_if_fail (CLUTTER_IS_SEAT (seat), NULL);
 
-  return CLUTTER_SEAT_GET_CLASS (seat)->list_devices (seat);
+  return g_list_copy ((GList *)clutter_seat_peek_devices (seat));
 }
 
 void
@@ -634,8 +645,8 @@ clutter_seat_create_virtual_device (ClutterSeat            *seat,
 }
 
 /**
- * clutter_seat_supported_virtual_device_types: (skip)
- */
+ * clutter_seat_get_supported_virtual_device_types: (skip)
+ **/
 ClutterVirtualDeviceType
 clutter_seat_get_supported_virtual_device_types (ClutterSeat *seat)
 {
@@ -682,7 +693,6 @@ clutter_seat_warp_pointer (ClutterSeat *seat,
  * requirements are fulfilled:
  *
  *  - A touchscreen is available
- *  - No external keyboard is attached to the device
  *  - A tablet mode switch, if present, is enabled
  *
  * Returns: %TRUE if the device is a tablet that doesn't have an external

clutter/clutter/clutter-seat.h

@@ -96,7 +96,7 @@ struct _ClutterSeatClass
   ClutterInputDevice * (* get_pointer)  (ClutterSeat *seat);
   ClutterInputDevice * (* get_keyboard) (ClutterSeat *seat);
 
-  GList * (* list_devices) (ClutterSeat *seat);
+  const GList * (* peek_devices) (ClutterSeat *seat);
 
   void (* bell_notify) (ClutterSeat *seat);
 
@@ -133,6 +133,7 @@ CLUTTER_EXPORT
 ClutterInputDevice * clutter_seat_get_keyboard (ClutterSeat *seat);
 CLUTTER_EXPORT
 GList * clutter_seat_list_devices (ClutterSeat *seat);
+const GList * clutter_seat_peek_devices (ClutterSeat *seat);
 CLUTTER_EXPORT
 void clutter_seat_bell_notify (ClutterSeat *seat);
 

clutter/clutter/clutter-stage-private.h

@@ -50,11 +50,6 @@ ClutterStageWindow *_clutter_stage_get_window            (ClutterStage
 void                _clutter_stage_get_projection_matrix (ClutterStage          *stage,
                                                           CoglMatrix            *projection);
 void                _clutter_stage_dirty_projection      (ClutterStage          *stage);
-void                _clutter_stage_set_viewport          (ClutterStage          *stage,
-                                                          float                  x,
-                                                          float                  y,
-                                                          float                  width,
-                                                          float                  height);
 void                _clutter_stage_get_viewport          (ClutterStage          *stage,
                                                           float                 *x,
                                                           float                 *y,
@@ -74,7 +69,6 @@ void     _clutter_stage_queue_event                       (ClutterStage *stage,
 gboolean _clutter_stage_has_queued_events                 (ClutterStage *stage);
 void     _clutter_stage_process_queued_events             (ClutterStage *stage);
 void     _clutter_stage_update_input_devices              (ClutterStage *stage);
-void     _clutter_stage_schedule_update                   (ClutterStage *stage);
 gint64    _clutter_stage_get_update_time                  (ClutterStage *stage);
 void     _clutter_stage_clear_update_time                 (ClutterStage *stage);
 gboolean _clutter_stage_has_full_redraw_queued            (ClutterStage *stage);
@@ -131,19 +125,17 @@ gboolean                _clutter_stage_update_state     (ClutterStage      *stag
 
 void                    _clutter_stage_set_scale_factor (ClutterStage      *stage,
                                                          int                factor);
-gboolean                _clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage    *stage,
-                                                                           graphene_rect_t *rect,
-                                                                           float           *view_scale);
 
 void            _clutter_stage_presented                (ClutterStage      *stage,
                                                          CoglFrameEvent     frame_event,
                                                          ClutterFrameInfo  *frame_info);
 
-GList *         _clutter_stage_peek_stage_views         (ClutterStage *stage);
-
 void            clutter_stage_queue_actor_relayout      (ClutterStage *stage,
                                                          ClutterActor *actor);
 
+GList * clutter_stage_get_views_for_rect (ClutterStage          *stage,
+                                          const graphene_rect_t *rect);
+
 G_END_DECLS
 
 #endif /* __CLUTTER_STAGE_PRIVATE_H__ */

clutter/clutter/clutter-stage-view-private.h

@@ -20,17 +20,28 @@
 
 #include "clutter/clutter-stage-view.h"
 
-void clutter_stage_view_after_paint (ClutterStageView *view);
+void clutter_stage_view_after_paint (ClutterStageView *view,
+                                     cairo_region_t   *redraw_clip);
+
+void clutter_stage_view_before_swap_buffer (ClutterStageView     *view,
+                                            const cairo_region_t *swap_region);
 
 gboolean clutter_stage_view_is_dirty_viewport (ClutterStageView *view);
 
-void clutter_stage_view_set_dirty_viewport (ClutterStageView *view,
-                                            gboolean          dirty);
+void clutter_stage_view_invalidate_viewport (ClutterStageView *view);
+
+void clutter_stage_view_set_viewport (ClutterStageView *view,
+                                      float             x,
+                                      float             y,
+                                      float             width,
+                                      float             height);
 
 gboolean clutter_stage_view_is_dirty_projection (ClutterStageView *view);
 
-void clutter_stage_view_set_dirty_projection (ClutterStageView *view,
-                                              gboolean          dirty);
+void clutter_stage_view_invalidate_projection (ClutterStageView *view);
+
+void clutter_stage_view_set_projection (ClutterStageView *view,
+                                        const CoglMatrix *matrix);
 
 void clutter_stage_view_add_redraw_clip (ClutterStageView            *view,
                                          const cairo_rectangle_int_t *clip);
@@ -43,4 +54,12 @@ const cairo_region_t * clutter_stage_view_peek_redraw_clip (ClutterStageView *vi
 
 cairo_region_t * clutter_stage_view_take_redraw_clip (ClutterStageView *view);
 
+CoglScanout * clutter_stage_view_take_scanout (ClutterStageView *view);
+
+void clutter_stage_view_transform_rect_to_onscreen (ClutterStageView            *view,
+                                                    const cairo_rectangle_int_t *src_rect,
+                                                    int                          dst_width,
+                                                    int                          dst_height,
+                                                    cairo_rectangle_int_t       *dst_rect);
+
 #endif /* __CLUTTER_STAGE_VIEW_PRIVATE_H__ */

clutter/clutter/clutter-stage-view.c

@@ -23,16 +23,20 @@
 #include <cairo-gobject.h>
 #include <math.h>
 
+#include "clutter/clutter-damage-history.h"
 #include "clutter/clutter-private.h"
+#include "clutter/clutter-mutter.h"
+#include "cogl/cogl.h"
 
 enum
 {
   PROP_0,
 
+  PROP_NAME,
   PROP_LAYOUT,
   PROP_FRAMEBUFFER,
   PROP_OFFSCREEN,
-  PROP_SHADOWFB,
+  PROP_USE_SHADOWFB,
   PROP_SCALE,
 
   PROP_LAST
@@ -42,6 +46,8 @@ static GParamSpec *obj_props[PROP_LAST];
 
 typedef struct _ClutterStageViewPrivate
 {
+  char *name;
+
   cairo_rectangle_int_t layout;
   float scale;
   CoglFramebuffer *framebuffer;
@@ -49,8 +55,18 @@ typedef struct _ClutterStageViewPrivate
   CoglOffscreen *offscreen;
   CoglPipeline *offscreen_pipeline;
 
-  CoglOffscreen *shadowfb;
-  CoglPipeline *shadowfb_pipeline;
+  gboolean use_shadowfb;
+  struct {
+    struct {
+      CoglDmaBufHandle *handles[2];
+      int current_idx;
+      ClutterDamageHistory *damage_history;
+    } dma_buf;
+
+    CoglOffscreen *framebuffer;
+  } shadow;
+
+  CoglScanout *next_scanout;
 
   gboolean has_redraw_clip;
   cairo_region_t *redraw_clip;
@@ -87,8 +103,8 @@ clutter_stage_view_get_framebuffer (ClutterStageView *view)
 
   if (priv->offscreen)
     return priv->offscreen;
-  else if (priv->shadowfb)
-    return priv->shadowfb;
+  else if (priv->shadow.framebuffer)
+    return priv->shadow.framebuffer;
   else
     return priv->framebuffer;
 }
@@ -148,19 +164,6 @@ clutter_stage_view_ensure_offscreen_blit_pipeline (ClutterStageView *view)
     view_class->setup_offscreen_blit_pipeline (view, priv->offscreen_pipeline);
 }
 
-static void
-clutter_stage_view_ensure_shadowfb_blit_pipeline (ClutterStageView *view)
-{
-  ClutterStageViewPrivate *priv =
-    clutter_stage_view_get_instance_private (view);
-
-  if (priv->shadowfb_pipeline)
-    return;
-
-  priv->shadowfb_pipeline =
-    clutter_stage_view_create_framebuffer_pipeline (priv->shadowfb);
-}
-
 void
 clutter_stage_view_invalidate_offscreen_blit_pipeline (ClutterStageView *view)
 {
@@ -170,85 +173,563 @@ clutter_stage_view_invalidate_offscreen_blit_pipeline (ClutterStageView *view)
   g_clear_pointer (&priv->offscreen_pipeline, cogl_object_unref);
 }
 
+void
+clutter_stage_view_transform_rect_to_onscreen (ClutterStageView            *view,
+                                               const cairo_rectangle_int_t *src_rect,
+                                               int                          dst_width,
+                                               int                          dst_height,
+                                               cairo_rectangle_int_t       *dst_rect)
+{
+  ClutterStageViewClass *view_class = CLUTTER_STAGE_VIEW_GET_CLASS (view);
+
+  return view_class->transform_rect_to_onscreen (view,
+                                                 src_rect,
+                                                 dst_width,
+                                                 dst_height,
+                                                 dst_rect);
+}
+
 static void
-clutter_stage_view_copy_to_framebuffer (ClutterStageView *view,
-                                        CoglPipeline     *pipeline,
-                                        CoglFramebuffer  *src_framebuffer,
-                                        CoglFramebuffer  *dst_framebuffer,
-                                        gboolean          can_blit)
+paint_transformed_framebuffer (ClutterStageView     *view,
+                               CoglPipeline         *pipeline,
+                               CoglFramebuffer      *src_framebuffer,
+                               CoglFramebuffer      *dst_framebuffer,
+                               const cairo_region_t *redraw_clip)
 {
   CoglMatrix matrix;
+  unsigned int n_rectangles, i;
+  int dst_width, dst_height;
+  cairo_rectangle_int_t view_layout;
+  cairo_rectangle_int_t onscreen_layout;
+  float view_scale;
+  float *coordinates;
 
-  /* First, try with blit */
-  if (can_blit)
-    {
-      if (cogl_blit_framebuffer (src_framebuffer,
-                                 dst_framebuffer,
-                                 0, 0,
-                                 0, 0,
-                                 cogl_framebuffer_get_width (dst_framebuffer),
-                                 cogl_framebuffer_get_height (dst_framebuffer),
-                                 NULL))
-        return;
-    }
+  dst_width = cogl_framebuffer_get_width (dst_framebuffer);
+  dst_height = cogl_framebuffer_get_height (dst_framebuffer);
+  clutter_stage_view_get_layout (view, &view_layout);
+  clutter_stage_view_transform_rect_to_onscreen (view,
+                                                 &(cairo_rectangle_int_t) {
+                                                   .width = view_layout.width,
+                                                   .height = view_layout.height,
+                                                 },
+                                                 view_layout.width,
+                                                 view_layout.height,
+                                                 &onscreen_layout);
+  view_scale = clutter_stage_view_get_scale (view);
 
-  /* If blit fails, fallback to the slower painting method */
   cogl_framebuffer_push_matrix (dst_framebuffer);
 
   cogl_matrix_init_identity (&matrix);
-  cogl_matrix_translate (&matrix, -1, 1, 0);
-  cogl_matrix_scale (&matrix, 2, -2, 0);
+  cogl_matrix_scale (&matrix,
+                     1.0 / (dst_width / 2.0),
+                     -1.0 / (dst_height / 2.0), 0);
+  cogl_matrix_translate (&matrix,
+                         -(dst_width / 2.0),
+                         -(dst_height / 2.0), 0);
   cogl_framebuffer_set_projection_matrix (dst_framebuffer, &matrix);
+  cogl_framebuffer_set_viewport (dst_framebuffer,
+                                 0, 0, dst_width, dst_height);
 
-  cogl_framebuffer_draw_rectangle (dst_framebuffer,
-                                   pipeline,
-                                   0, 0, 1, 1);
+  n_rectangles = cairo_region_num_rectangles (redraw_clip);
+  coordinates = g_newa (float, 2 * 4 * n_rectangles);
+
+  for (i = 0; i < n_rectangles; i++)
+    {
+      cairo_rectangle_int_t src_rect;
+      cairo_rectangle_int_t dst_rect;
+
+      cairo_region_get_rectangle (redraw_clip, i, &src_rect);
+      _clutter_util_rectangle_offset (&src_rect,
+                                      -view_layout.x,
+                                      -view_layout.y,
+                                      &src_rect);
+
+      clutter_stage_view_transform_rect_to_onscreen (view,
+                                                     &src_rect,
+                                                     onscreen_layout.width,
+                                                     onscreen_layout.height,
+                                                     &dst_rect);
+
+      coordinates[i * 8 + 0] = (float) dst_rect.x * view_scale;
+      coordinates[i * 8 + 1] = (float) dst_rect.y * view_scale;
+      coordinates[i * 8 + 2] = ((float) (dst_rect.x + dst_rect.width) *
+                                view_scale);
+      coordinates[i * 8 + 3] = ((float) (dst_rect.y + dst_rect.height) *
+                                view_scale);
+
+      coordinates[i * 8 + 4] = (((float) dst_rect.x / (float) dst_width) *
+                                view_scale);
+      coordinates[i * 8 + 5] = (((float) dst_rect.y / (float) dst_height) *
+                                view_scale);
+      coordinates[i * 8 + 6] = ((float) (dst_rect.x + dst_rect.width) /
+                                (float) dst_width) * view_scale;
+      coordinates[i * 8 + 7] = ((float) (dst_rect.y + dst_rect.height) /
+                                (float) dst_height) * view_scale;
+    }
+
+  cogl_framebuffer_draw_textured_rectangles (dst_framebuffer,
+                                             pipeline,
+                                             coordinates,
+                                             n_rectangles);
 
   cogl_framebuffer_pop_matrix (dst_framebuffer);
 }
 
+static gboolean
+is_shadowfb_double_buffered (ClutterStageView *view)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+
+  return priv->shadow.dma_buf.handles[0] && priv->shadow.dma_buf.handles[1];
+}
+
+static gboolean
+init_dma_buf_shadowfbs (ClutterStageView  *view,
+                        CoglContext       *cogl_context,
+                        int                width,
+                        int                height,
+                        GError           **error)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+  CoglRenderer *cogl_renderer = cogl_context_get_renderer (cogl_context);
+  CoglFramebuffer *initial_shadowfb;
+
+  if (!cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_BUFFER_AGE))
+    {
+      g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+                   "Buffer age not supported");
+      return FALSE;
+    }
+
+  if (!cogl_is_onscreen (priv->framebuffer))
+    {
+      g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+                   "Tried to use shadow buffer without onscreen");
+      return FALSE;
+    }
+
+  priv->shadow.dma_buf.handles[0] = cogl_renderer_create_dma_buf (cogl_renderer,
+                                                                  width, height,
+                                                                  error);
+  if (!priv->shadow.dma_buf.handles[0])
+    return FALSE;
+
+  priv->shadow.dma_buf.handles[1] = cogl_renderer_create_dma_buf (cogl_renderer,
+                                                                  width, height,
+                                                                  error);
+  if (!priv->shadow.dma_buf.handles[1])
+    {
+      g_clear_pointer (&priv->shadow.dma_buf.handles[0],
+                       cogl_dma_buf_handle_free);
+      return FALSE;
+    }
+
+  priv->shadow.dma_buf.damage_history = clutter_damage_history_new ();
+
+  initial_shadowfb =
+    cogl_dma_buf_handle_get_framebuffer (priv->shadow.dma_buf.handles[0]);
+  priv->shadow.framebuffer = cogl_object_ref (initial_shadowfb);
+
+  return TRUE;
+}
+
+static CoglOffscreen *
+create_offscreen_framebuffer (CoglContext  *context,
+                              int           width,
+                              int           height,
+                              GError      **error)
+{
+  CoglOffscreen *framebuffer;
+  CoglTexture2D *texture;
+
+  texture = cogl_texture_2d_new_with_size (context, width, height);
+  cogl_primitive_texture_set_auto_mipmap (COGL_PRIMITIVE_TEXTURE (texture),
+                                          FALSE);
+
+  if (!cogl_texture_allocate (COGL_TEXTURE (texture), error))
+    {
+      cogl_object_unref (texture);
+      return FALSE;
+    }
+
+  framebuffer = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture));
+  cogl_object_unref (texture);
+  if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (framebuffer), error))
+    {
+      cogl_object_unref (framebuffer);
+      return FALSE;
+    }
+
+  return framebuffer;
+}
+
+static gboolean
+init_fallback_shadowfb (ClutterStageView  *view,
+                        CoglContext       *cogl_context,
+                        int                width,
+                        int                height,
+                        GError           **error)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+  CoglOffscreen *offscreen;
+
+  offscreen = create_offscreen_framebuffer (cogl_context, width, height, error);
+  if (!offscreen)
+    return FALSE;
+
+  priv->shadow.framebuffer = offscreen;
+  return TRUE;
+}
+
+static void
+init_shadowfb (ClutterStageView *view)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+  g_autoptr (GError) error = NULL;
+  int width;
+  int height;
+  CoglContext *cogl_context;
+
+  width = cogl_framebuffer_get_width (priv->framebuffer);
+  height = cogl_framebuffer_get_height (priv->framebuffer);
+  cogl_context = cogl_framebuffer_get_context (priv->framebuffer);
+
+  if (init_dma_buf_shadowfbs (view, cogl_context, width, height, &error))
+    {
+      g_message ("Initialized double buffered shadow fb for %s", priv->name);
+      return;
+    }
+
+  g_warning ("Failed to initialize double buffered shadow fb for %s: %s",
+             priv->name, error->message);
+  g_clear_error (&error);
+
+  if (!init_fallback_shadowfb (view, cogl_context, width, height, &error))
+    {
+      g_warning ("Failed to initialize single buffered shadow fb for %s: %s",
+                 priv->name, error->message);
+    }
+  else
+    {
+      g_message ("Initialized single buffered shadow fb for %s", priv->name);
+    }
+}
+
 void
-clutter_stage_view_after_paint (ClutterStageView *view)
+clutter_stage_view_after_paint (ClutterStageView *view,
+                                cairo_region_t   *redraw_clip)
 {
   ClutterStageViewPrivate *priv =
     clutter_stage_view_get_instance_private (view);
 
   if (priv->offscreen)
     {
-      gboolean can_blit;
-      CoglMatrix matrix;
-
       clutter_stage_view_ensure_offscreen_blit_pipeline (view);
-      clutter_stage_view_get_offscreen_transformation_matrix (view, &matrix);
-      can_blit = cogl_matrix_is_identity (&matrix);
 
-      if (priv->shadowfb)
+      if (priv->shadow.framebuffer)
         {
-          clutter_stage_view_copy_to_framebuffer (view,
-                                                  priv->offscreen_pipeline,
-                                                  priv->offscreen,
-                                                  priv->shadowfb,
-                                                  can_blit);
+          paint_transformed_framebuffer (view,
+                                         priv->offscreen_pipeline,
+                                         priv->offscreen,
+                                         priv->shadow.framebuffer,
+                                         redraw_clip);
         }
       else
         {
-          clutter_stage_view_copy_to_framebuffer (view,
-                                                  priv->offscreen_pipeline,
-                                                  priv->offscreen,
-                                                  priv->framebuffer,
-                                                  can_blit);
+          paint_transformed_framebuffer (view,
+                                         priv->offscreen_pipeline,
+                                         priv->offscreen,
+                                         priv->framebuffer,
+                                         redraw_clip);
+        }
+    }
+}
+
+static gboolean
+is_tile_dirty (cairo_rectangle_int_t *tile,
+               uint8_t               *current_data,
+               uint8_t               *prev_data,
+               int                    bpp,
+               int                    stride)
+{
+  int y;
+
+  for (y = tile->y; y < tile->y + tile->height; y++)
+    {
+      if (memcmp (prev_data + y * stride + tile->x * bpp,
+                  current_data + y * stride + tile->x * bpp,
+                  tile->width * bpp) != 0)
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+static int
+flip_dma_buf_idx (int idx)
+{
+  return (idx + 1) % 2;
+}
+
+static cairo_region_t *
+find_damaged_tiles (ClutterStageView      *view,
+                    const cairo_region_t  *damage_region,
+                    GError               **error)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+  cairo_region_t *tile_damage_region;
+  cairo_rectangle_int_t damage_extents;
+  cairo_rectangle_int_t fb_rect;
+  int prev_dma_buf_idx;
+  CoglDmaBufHandle *prev_dma_buf_handle;
+  uint8_t *prev_data;
+  int current_dma_buf_idx;
+  CoglDmaBufHandle *current_dma_buf_handle;
+  uint8_t *current_data;
+  int width, height, stride, bpp;
+  int tile_x_min, tile_x_max;
+  int tile_y_min, tile_y_max;
+  int tile_x, tile_y;
+  const int tile_size = 16;
+
+  prev_dma_buf_idx = flip_dma_buf_idx (priv->shadow.dma_buf.current_idx);
+  prev_dma_buf_handle = priv->shadow.dma_buf.handles[prev_dma_buf_idx];
+
+  current_dma_buf_idx = priv->shadow.dma_buf.current_idx;
+  current_dma_buf_handle = priv->shadow.dma_buf.handles[current_dma_buf_idx];
+
+  width = cogl_dma_buf_handle_get_width (current_dma_buf_handle);
+  height = cogl_dma_buf_handle_get_height (current_dma_buf_handle);
+  stride = cogl_dma_buf_handle_get_stride (current_dma_buf_handle);
+  bpp = cogl_dma_buf_handle_get_bpp (current_dma_buf_handle);
+
+  cogl_framebuffer_finish (priv->shadow.framebuffer);
+
+  if (!cogl_dma_buf_handle_sync_read_start (prev_dma_buf_handle, error))
+    return NULL;
+
+  if (!cogl_dma_buf_handle_sync_read_start (current_dma_buf_handle, error))
+    goto err_sync_read_current;
+
+  prev_data = cogl_dma_buf_handle_mmap (prev_dma_buf_handle, error);
+  if (!prev_data)
+    goto err_mmap_prev;
+  current_data = cogl_dma_buf_handle_mmap (current_dma_buf_handle, error);
+  if (!current_data)
+    goto err_mmap_current;
+
+  fb_rect = (cairo_rectangle_int_t) {
+    .width = width,
+    .height = height,
+  };
+
+  cairo_region_get_extents (damage_region, &damage_extents);
+
+  tile_x_min = damage_extents.x / tile_size;
+  tile_x_max = ((damage_extents.x + damage_extents.width + tile_size - 1) /
+                tile_size);
+  tile_y_min = damage_extents.y / tile_size;
+  tile_y_max = ((damage_extents.y + damage_extents.height + tile_size - 1) /
+                tile_size);
+
+  tile_damage_region = cairo_region_create ();
+
+  for (tile_y = tile_y_min; tile_y <= tile_y_max; tile_y++)
+    {
+      for (tile_x = tile_x_min; tile_x <= tile_x_max; tile_x++)
+        {
+          cairo_rectangle_int_t tile = {
+            .x = tile_x * tile_size,
+            .y = tile_y * tile_size,
+            .width = tile_size,
+            .height = tile_size,
+          };
+
+          if (cairo_region_contains_rectangle (damage_region, &tile) ==
+              CAIRO_REGION_OVERLAP_OUT)
+            continue;
+
+          _clutter_util_rectangle_intersection (&tile, &fb_rect, &tile);
+
+          if (is_tile_dirty (&tile, current_data, prev_data, bpp, stride))
+            cairo_region_union_rectangle (tile_damage_region, &tile);
         }
     }
 
-  if (priv->shadowfb)
+  if (!cogl_dma_buf_handle_sync_read_end (prev_dma_buf_handle, error))
     {
-      clutter_stage_view_ensure_shadowfb_blit_pipeline (view);
-      clutter_stage_view_copy_to_framebuffer (view,
-                                              priv->shadowfb_pipeline,
-                                              priv->shadowfb,
-                                              priv->framebuffer,
-                                              TRUE);
+      g_warning ("Failed to end DMA buffer read synchronization: %s",
+                 (*error)->message);
+      g_clear_error (error);
     }
+
+  if (!cogl_dma_buf_handle_sync_read_end (current_dma_buf_handle, error))
+    {
+      g_warning ("Failed to end DMA buffer read synchronization: %s",
+                 (*error)->message);
+      g_clear_error (error);
+    }
+
+  cogl_dma_buf_handle_munmap (prev_dma_buf_handle, prev_data, NULL);
+  cogl_dma_buf_handle_munmap (current_dma_buf_handle, current_data, NULL);
+
+  cairo_region_intersect (tile_damage_region, damage_region);
+
+  return tile_damage_region;
+
+err_mmap_current:
+  cogl_dma_buf_handle_munmap (prev_dma_buf_handle, prev_data, NULL);
+
+err_mmap_prev:
+  cogl_dma_buf_handle_sync_read_end (current_dma_buf_handle, NULL);
+
+err_sync_read_current:
+  cogl_dma_buf_handle_sync_read_end (prev_dma_buf_handle, NULL);
+
+  return NULL;
+}
+
+static void
+swap_dma_buf_framebuffer (ClutterStageView *view)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+  int next_idx;
+  CoglDmaBufHandle *next_dma_buf_handle;
+  CoglOffscreen *next_framebuffer;
+
+  next_idx = ((priv->shadow.dma_buf.current_idx + 1) %
+              G_N_ELEMENTS (priv->shadow.dma_buf.handles));
+  priv->shadow.dma_buf.current_idx = next_idx;
+
+  next_dma_buf_handle = priv->shadow.dma_buf.handles[next_idx];
+  next_framebuffer =
+    cogl_dma_buf_handle_get_framebuffer (next_dma_buf_handle);
+  cogl_clear_object (&priv->shadow.framebuffer);
+  priv->shadow.framebuffer = cogl_object_ref (next_framebuffer);
+}
+
+static void
+copy_shadowfb_to_onscreen (ClutterStageView     *view,
+                           const cairo_region_t *swap_region)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+  ClutterDamageHistory *damage_history = priv->shadow.dma_buf.damage_history;
+  cairo_region_t *damage_region;
+  int age;
+  int i;
+
+  if (cairo_region_is_empty (swap_region))
+    {
+      cairo_rectangle_int_t full_damage = {
+        .width = cogl_framebuffer_get_width (priv->framebuffer),
+        .height = cogl_framebuffer_get_height (priv->framebuffer),
+      };
+      damage_region = cairo_region_create_rectangle (&full_damage);
+    }
+  else
+    {
+      damage_region = cairo_region_copy (swap_region);
+    }
+
+  if (is_shadowfb_double_buffered (view))
+    {
+      CoglOnscreen *onscreen = COGL_ONSCREEN (priv->framebuffer);
+      cairo_region_t *changed_region;
+
+      if (cogl_onscreen_get_frame_counter (onscreen) >= 1)
+        {
+          g_autoptr (GError) error = NULL;
+
+          changed_region = find_damaged_tiles (view, damage_region, &error);
+          if (!changed_region)
+            {
+              int other_dma_buf_idx;
+
+              g_warning ("Disabling actual damage detection: %s",
+                         error->message);
+
+              other_dma_buf_idx =
+                flip_dma_buf_idx (priv->shadow.dma_buf.current_idx);
+              g_clear_pointer (&priv->shadow.dma_buf.handles[other_dma_buf_idx],
+                               cogl_dma_buf_handle_free);
+            }
+        }
+      else
+        {
+          changed_region = cairo_region_copy (damage_region);
+        }
+
+      if (changed_region)
+        {
+          int buffer_age;
+
+          clutter_damage_history_record (damage_history, changed_region);
+
+          buffer_age = cogl_onscreen_get_buffer_age (onscreen);
+          if (clutter_damage_history_is_age_valid (damage_history, buffer_age))
+            {
+              for (age = 1; age <= buffer_age; age++)
+                {
+                  const cairo_region_t *old_damage;
+
+                  old_damage = clutter_damage_history_lookup (damage_history, age);
+                  cairo_region_union (changed_region, old_damage);
+                }
+
+              cairo_region_destroy (damage_region);
+              damage_region = g_steal_pointer (&changed_region);
+            }
+          else
+            {
+              cairo_region_destroy (changed_region);
+            }
+
+          clutter_damage_history_step (damage_history);
+        }
+    }
+
+  for (i = 0; i < cairo_region_num_rectangles (damage_region); i++)
+    {
+      g_autoptr (GError) error = NULL;
+      cairo_rectangle_int_t rect;
+
+      cairo_region_get_rectangle (damage_region, i, &rect);
+
+      if (!cogl_blit_framebuffer (priv->shadow.framebuffer,
+                                  priv->framebuffer,
+                                  rect.x, rect.y,
+                                  rect.x, rect.y,
+                                  rect.width, rect.height,
+                                  &error))
+        {
+          g_warning ("Failed to blit shadow buffer: %s", error->message);
+          cairo_region_destroy (damage_region);
+          return;
+        }
+    }
+
+  cairo_region_destroy (damage_region);
+
+  if (is_shadowfb_double_buffered (view))
+    swap_dma_buf_framebuffer (view);
+}
+
+void
+clutter_stage_view_before_swap_buffer (ClutterStageView     *view,
+                                       const cairo_region_t *swap_region)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+
+  if (priv->shadow.framebuffer)
+    copy_shadowfb_to_onscreen (view, swap_region);
 }
 
 float
@@ -260,6 +741,47 @@ clutter_stage_view_get_scale (ClutterStageView *view)
   return priv->scale;
 }
 
+typedef void (*FrontBufferCallback) (CoglFramebuffer *framebuffer,
+                                     gconstpointer    user_data);
+
+static void
+clutter_stage_view_foreach_front_buffer (ClutterStageView    *view,
+                                         FrontBufferCallback  callback,
+                                         gconstpointer        user_data)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+
+  if (priv->offscreen)
+    {
+      callback (priv->offscreen, user_data);
+    }
+  else if (priv->shadow.framebuffer)
+    {
+      if (is_shadowfb_double_buffered (view))
+        {
+          int i;
+
+          for (i = 0; i < G_N_ELEMENTS (priv->shadow.dma_buf.handles); i++)
+            {
+              CoglDmaBufHandle *handle = priv->shadow.dma_buf.handles[i];
+              CoglFramebuffer *framebuffer =
+                cogl_dma_buf_handle_get_framebuffer (handle);
+
+              callback (framebuffer, user_data);
+            }
+        }
+      else
+        {
+          callback (priv->shadow.framebuffer, user_data);
+        }
+    }
+  else
+    {
+      callback (priv->framebuffer, user_data);
+    }
+}
+
 gboolean
 clutter_stage_view_is_dirty_viewport (ClutterStageView *view)
 {
@@ -270,13 +792,47 @@ clutter_stage_view_is_dirty_viewport (ClutterStageView *view)
 }
 
 void
-clutter_stage_view_set_dirty_viewport (ClutterStageView *view,
-                                       gboolean          dirty)
+clutter_stage_view_invalidate_viewport (ClutterStageView *view)
 {
   ClutterStageViewPrivate *priv =
     clutter_stage_view_get_instance_private (view);
 
-  priv->dirty_viewport = dirty;
+  priv->dirty_viewport = TRUE;
+}
+
+static void
+set_framebuffer_viewport (CoglFramebuffer *framebuffer,
+                          gconstpointer    user_data)
+{
+  const graphene_rect_t *rect = user_data;
+
+  cogl_framebuffer_set_viewport (framebuffer,
+                                 rect->origin.x,
+                                 rect->origin.y,
+                                 rect->size.width,
+                                 rect->size.height);
+}
+
+void
+clutter_stage_view_set_viewport (ClutterStageView *view,
+                                 float             x,
+                                 float             y,
+                                 float             width,
+                                 float             height)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+  graphene_rect_t rect;
+
+  priv->dirty_viewport = FALSE;
+
+  rect = (graphene_rect_t) {
+    .origin = { .x = x, .y = y },
+    .size = { .width = width, .height = height },
+  };
+  clutter_stage_view_foreach_front_buffer (view,
+                                           set_framebuffer_viewport,
+                                           &rect);
 }
 
 gboolean
@@ -288,14 +844,33 @@ clutter_stage_view_is_dirty_projection (ClutterStageView *view)
   return priv->dirty_projection;
 }
 
+static void
+set_framebuffer_projection_matrix (CoglFramebuffer *framebuffer,
+                                   gconstpointer    user_data)
+{
+  cogl_framebuffer_set_projection_matrix (framebuffer, user_data);
+}
+
 void
-clutter_stage_view_set_dirty_projection (ClutterStageView *view,
-                                         gboolean          dirty)
+clutter_stage_view_invalidate_projection (ClutterStageView *view)
 {
   ClutterStageViewPrivate *priv =
     clutter_stage_view_get_instance_private (view);
 
-  priv->dirty_projection = dirty;
+  priv->dirty_projection = TRUE;
+}
+
+void
+clutter_stage_view_set_projection (ClutterStageView *view,
+                                   const CoglMatrix *matrix)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+
+  priv->dirty_projection = FALSE;
+  clutter_stage_view_foreach_front_buffer (view,
+                                           set_framebuffer_projection_matrix,
+                                           matrix);
 }
 
 void
@@ -387,19 +962,6 @@ clutter_stage_view_take_redraw_clip (ClutterStageView *view)
   return g_steal_pointer (&priv->redraw_clip);
 }
 
-void
-clutter_stage_view_transform_to_onscreen (ClutterStageView *view,
-                                          gfloat           *x,
-                                          gfloat           *y)
-{
-  gfloat z = 0, w = 1;
-  CoglMatrix matrix;
-
-  clutter_stage_view_get_offscreen_transformation_matrix (view, &matrix);
-  cogl_matrix_get_inverse (&matrix, &matrix);
-  cogl_matrix_transform_point (&matrix, x, y, &z, &w);
-}
-
 static void
 clutter_stage_default_get_offscreen_transformation_matrix (ClutterStageView *view,
                                                            CoglMatrix       *matrix)
@@ -407,6 +969,25 @@ clutter_stage_default_get_offscreen_transformation_matrix (ClutterStageView *vie
   cogl_matrix_init_identity (matrix);
 }
 
+void
+clutter_stage_view_assign_next_scanout (ClutterStageView *view,
+                                        CoglScanout      *scanout)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+
+  g_set_object (&priv->next_scanout, scanout);
+}
+
+CoglScanout *
+clutter_stage_view_take_scanout (ClutterStageView *view)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+
+  return g_steal_pointer (&priv->next_scanout);
+}
+
 static void
 clutter_stage_view_get_property (GObject    *object,
                                  guint       prop_id,
@@ -419,6 +1000,9 @@ clutter_stage_view_get_property (GObject    *object,
 
   switch (prop_id)
     {
+    case PROP_NAME:
+      g_value_set_string (value, priv->name);
+      break;
     case PROP_LAYOUT:
       g_value_set_boxed (value, &priv->layout);
       break;
@@ -428,8 +1012,8 @@ clutter_stage_view_get_property (GObject    *object,
     case PROP_OFFSCREEN:
       g_value_set_boxed (value, priv->offscreen);
       break;
-    case PROP_SHADOWFB:
-      g_value_set_boxed (value, priv->shadowfb);
+    case PROP_USE_SHADOWFB:
+      g_value_set_boolean (value, priv->use_shadowfb);
       break;
     case PROP_SCALE:
       g_value_set_float (value, priv->scale);
@@ -452,6 +1036,9 @@ clutter_stage_view_set_property (GObject      *object,
 
   switch (prop_id)
     {
+    case PROP_NAME:
+      priv->name = g_value_dup_string (value);
+      break;
     case PROP_LAYOUT:
       layout = g_value_get_boxed (value);
       priv->layout = *layout;
@@ -476,8 +1063,8 @@ clutter_stage_view_set_property (GObject      *object,
     case PROP_OFFSCREEN:
       priv->offscreen = g_value_dup_boxed (value);
       break;
-    case PROP_SHADOWFB:
-      priv->shadowfb = g_value_dup_boxed (value);
+    case PROP_USE_SHADOWFB:
+      priv->use_shadowfb = g_value_get_boolean (value);
       break;
     case PROP_SCALE:
       priv->scale = g_value_get_float (value);
@@ -488,17 +1075,40 @@ clutter_stage_view_set_property (GObject      *object,
 }
 
 static void
-clutter_stage_view_dispose (GObject *object)
+clutter_stage_view_constructed (GObject *object)
 {
   ClutterStageView *view = CLUTTER_STAGE_VIEW (object);
   ClutterStageViewPrivate *priv =
     clutter_stage_view_get_instance_private (view);
 
+  if (priv->use_shadowfb)
+    init_shadowfb (view);
+
+  G_OBJECT_CLASS (clutter_stage_view_parent_class)->constructed (object);
+}
+
+static void
+clutter_stage_view_dispose (GObject *object)
+{
+  ClutterStageView *view = CLUTTER_STAGE_VIEW (object);
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+  int i;
+
+  g_clear_pointer (&priv->name, g_free);
   g_clear_pointer (&priv->framebuffer, cogl_object_unref);
-  g_clear_pointer (&priv->shadowfb, cogl_object_unref);
+
+  g_clear_pointer (&priv->shadow.framebuffer, cogl_object_unref);
+  for (i = 0; i < G_N_ELEMENTS (priv->shadow.dma_buf.handles); i++)
+    {
+      g_clear_pointer (&priv->shadow.dma_buf.handles[i],
+                       cogl_dma_buf_handle_free);
+    }
+  g_clear_pointer (&priv->shadow.dma_buf.damage_history,
+                   clutter_damage_history_free);
+
   g_clear_pointer (&priv->offscreen, cogl_object_unref);
   g_clear_pointer (&priv->offscreen_pipeline, cogl_object_unref);
-  g_clear_pointer (&priv->shadowfb_pipeline, cogl_object_unref);
   g_clear_pointer (&priv->redraw_clip, cairo_region_destroy);
 
   G_OBJECT_CLASS (clutter_stage_view_parent_class)->dispose (object);
@@ -525,8 +1135,17 @@ clutter_stage_view_class_init (ClutterStageViewClass *klass)
 
   object_class->get_property = clutter_stage_view_get_property;
   object_class->set_property = clutter_stage_view_set_property;
+  object_class->constructed = clutter_stage_view_constructed;
   object_class->dispose = clutter_stage_view_dispose;
 
+  obj_props[PROP_NAME] =
+    g_param_spec_string ("name",
+                         "Name",
+                         "Name of view",
+                         NULL,
+                         G_PARAM_READWRITE |
+                         G_PARAM_CONSTRUCT_ONLY |
+                         G_PARAM_STATIC_STRINGS);
   obj_props[PROP_LAYOUT] =
     g_param_spec_boxed ("layout",
                         "View layout",
@@ -554,14 +1173,14 @@ clutter_stage_view_class_init (ClutterStageViewClass *klass)
                         G_PARAM_CONSTRUCT_ONLY |
                         G_PARAM_STATIC_STRINGS);
 
-  obj_props[PROP_SHADOWFB] =
-    g_param_spec_boxed ("shadowfb",
-                        "Shadow framebuffer",
-                        "Framebuffer used as intermediate shadow buffer",
-                        COGL_TYPE_HANDLE,
-                        G_PARAM_READWRITE |
-                        G_PARAM_CONSTRUCT_ONLY |
-                        G_PARAM_STATIC_STRINGS);
+  obj_props[PROP_USE_SHADOWFB] =
+    g_param_spec_boolean ("use-shadowfb",
+                          "Use shadowfb",
+                          "Whether to use one or more shadow framebuffers",
+                          FALSE,
+                          G_PARAM_READWRITE |
+                          G_PARAM_CONSTRUCT_ONLY |
+                          G_PARAM_STATIC_STRINGS);
 
   obj_props[PROP_SCALE] =
     g_param_spec_float ("scale",

clutter/clutter/clutter-stage-view.h

@@ -43,6 +43,12 @@ struct _ClutterStageViewClass
 
   void (* get_offscreen_transformation_matrix) (ClutterStageView *view,
                                                 CoglMatrix       *matrix);
+
+  void (* transform_rect_to_onscreen) (ClutterStageView            *view,
+                                       const cairo_rectangle_int_t *src_rect,
+                                       int                          dst_width,
+                                       int                          dst_height,
+                                       cairo_rectangle_int_t       *dst_rect);
 };
 
 CLUTTER_EXPORT
@@ -56,11 +62,6 @@ CoglFramebuffer *clutter_stage_view_get_onscreen (ClutterStageView *view);
 CLUTTER_EXPORT
 void             clutter_stage_view_invalidate_offscreen_blit_pipeline (ClutterStageView *view);
 
-CLUTTER_EXPORT
-void             clutter_stage_view_transform_to_onscreen (ClutterStageView *view,
-                                                           gfloat           *x,
-                                                           gfloat           *y);
-
 CLUTTER_EXPORT
 float clutter_stage_view_get_scale (ClutterStageView *view);
 

clutter/clutter/clutter-stage.c

@@ -45,7 +45,7 @@
 #include "clutter-build-config.h"
 
 #include <math.h>
-#include <cairo.h>
+#include <cairo-gobject.h>
 
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
@@ -119,8 +119,7 @@ struct _ClutterStagePrivate
 
   ClutterPlane current_clip_planes[4];
 
-  GHashTable *pending_relayouts;
-  unsigned int pending_relayouts_version;
+  GSList *pending_relayouts;
   GList *pending_queue_redraws;
 
   gint sync_delay;
@@ -142,6 +141,8 @@ struct _ClutterStagePrivate
 
   int update_freeze_count;
 
+  gboolean needs_update;
+
   guint redraw_pending         : 1;
   guint throttle_motion_events : 1;
   guint min_size_changed       : 1;
@@ -187,6 +188,9 @@ static void capture_view_into (ClutterStage          *stage,
                                uint8_t               *data,
                                int                    stride);
 static void clutter_stage_update_view_perspective (ClutterStage *stage);
+static void clutter_stage_set_viewport (ClutterStage *stage,
+                                        float         width,
+                                        float         height);
 
 static void clutter_container_iface_init (ClutterContainerIface *iface);
 
@@ -552,7 +556,7 @@ clutter_stage_add_redraw_clip (ClutterStage          *stage,
 {
   GList *l;
 
-  for (l = _clutter_stage_peek_stage_views (stage); l; l = l->next)
+  for (l = clutter_stage_peek_stage_views (stage); l; l = l->next)
     {
       ClutterStageView *view = l->data;
 
@@ -613,23 +617,18 @@ stage_is_default (ClutterStage *stage)
 
 static void
 clutter_stage_allocate (ClutterActor           *self,
-                        const ClutterActorBox  *box,
-                        ClutterAllocationFlags  flags)
+                        const ClutterActorBox  *box)
 {
   ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
   ClutterActorBox alloc = CLUTTER_ACTOR_BOX_INIT_ZERO;
-  float old_width, old_height;
   float new_width, new_height;
   float width, height;
   cairo_rectangle_int_t window_size;
+  ClutterLayoutManager *layout_manager = clutter_actor_get_layout_manager (self);
 
   if (priv->impl == NULL)
     return;
 
-  /* our old allocation */
-  clutter_actor_get_allocation_box (self, &alloc);
-  clutter_actor_box_get_size (&alloc, &old_width, &old_height);
-
   /* the current allocation */
   clutter_actor_box_get_size (box, &width, &height);
 
@@ -643,15 +642,21 @@ clutter_stage_allocate (ClutterActor           *self,
    */
   if (!clutter_feature_available (CLUTTER_FEATURE_STAGE_STATIC))
     {
-      CLUTTER_NOTE (LAYOUT,
-                    "Following allocation to %.2fx%.2f (absolute origin %s)",
-                    width, height,
-                    (flags & CLUTTER_ABSOLUTE_ORIGIN_CHANGED)
-                      ? "changed"
-                      : "not changed");
+      ClutterActorBox children_box;
 
-      clutter_actor_set_allocation (self, box,
-                                    flags | CLUTTER_DELEGATE_LAYOUT);
+      children_box.x1 = children_box.y1 = 0.f;
+      children_box.x2 = box->x2 - box->x1;
+      children_box.y2 = box->y2 - box->y1;
+
+      CLUTTER_NOTE (LAYOUT,
+                    "Following allocation to %.2fx%.2f",
+                    width, height);
+
+      clutter_actor_set_allocation (self, box);
+
+      clutter_layout_manager_allocate (layout_manager,
+                                       CLUTTER_CONTAINER (self),
+                                       &children_box);
 
       /* Ensure the window is sized correctly */
       if (priv->min_size_changed)
@@ -699,39 +704,23 @@ clutter_stage_allocate (ClutterActor           *self,
 
       CLUTTER_NOTE (LAYOUT,
                     "Overriding original allocation of %.2fx%.2f "
-                    "with %.2fx%.2f (absolute origin %s)",
+                    "with %.2fx%.2f",
                     width, height,
-                    override.x2, override.y2,
-                    (flags & CLUTTER_ABSOLUTE_ORIGIN_CHANGED)
-                      ? "changed"
-                      : "not changed");
+                    override.x2, override.y2);
 
       /* and store the overridden allocation */
-      clutter_actor_set_allocation (self, &override,
-                                    flags | CLUTTER_DELEGATE_LAYOUT);
+      clutter_actor_set_allocation (self, &override);
+
+      clutter_layout_manager_allocate (layout_manager,
+                                       CLUTTER_CONTAINER (self),
+                                       &override);
     }
 
-  /* reset the viewport if the allocation effectively changed */
+  /* set the viewport to the new allocation */
   clutter_actor_get_allocation_box (self, &alloc);
   clutter_actor_box_get_size (&alloc, &new_width, &new_height);
 
-  if (CLUTTER_NEARBYINT (old_width) != CLUTTER_NEARBYINT (new_width) ||
-      CLUTTER_NEARBYINT (old_height) != CLUTTER_NEARBYINT (new_height))
-    {
-      int real_width = CLUTTER_NEARBYINT (new_width);
-      int real_height = CLUTTER_NEARBYINT (new_height);
-
-      _clutter_stage_set_viewport (CLUTTER_STAGE (self),
-                                   0, 0,
-                                   real_width,
-                                   real_height);
-
-      /* Note: we don't assume that set_viewport will queue a full redraw
-       * since it may bail-out early if something preemptively set the
-       * viewport before the stage was really allocated its new size.
-       */
-      queue_full_redraw (CLUTTER_STAGE (self));
-    }
+  clutter_stage_set_viewport (CLUTTER_STAGE (self), new_width, new_height);
 }
 
 typedef struct _Vector4
@@ -924,7 +913,8 @@ clutter_stage_do_paint_view (ClutterStage         *stage,
   ClutterPaintContext *paint_context;
   cairo_rectangle_int_t clip_rect;
 
-  paint_context = clutter_paint_context_new_for_view (view, redraw_clip);
+  paint_context = clutter_paint_context_new_for_view (view, redraw_clip,
+                                                      CLUTTER_PAINT_FLAG_NONE);
 
   cairo_region_get_extents (redraw_clip, &clip_rect);
   setup_view_for_pick_or_paint (stage, view, &clip_rect);
@@ -1080,6 +1070,7 @@ clutter_stage_hide (ClutterActor *self)
   ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
 
   g_assert (priv->impl != NULL);
+  _clutter_stage_clear_pick_stack (CLUTTER_STAGE (self));
   _clutter_stage_window_hide (priv->impl);
 
   CLUTTER_ACTOR_CLASS (clutter_stage_parent_class)->hide (self);
@@ -1138,7 +1129,6 @@ _clutter_stage_queue_event (ClutterStage *stage,
       event->type != CLUTTER_PROXIMITY_IN &&
       event->type != CLUTTER_PROXIMITY_OUT)
     {
-      ClutterModifierType event_state = clutter_event_get_state (event);
       ClutterEventSequence *sequence = clutter_event_get_event_sequence (event);
       guint32 event_time = clutter_event_get_time (event);
       gfloat event_x, event_y;
@@ -1146,7 +1136,6 @@ _clutter_stage_queue_event (ClutterStage *stage,
       clutter_event_get_coords (event, &event_x, &event_y);
 
       _clutter_input_device_set_coords (device, sequence, event_x, event_y, stage);
-      _clutter_input_device_set_state (device, event_state);
       _clutter_input_device_set_time (device, event_time);
     }
 
@@ -1169,7 +1158,7 @@ _clutter_stage_queue_event (ClutterStage *stage,
     {
       ClutterMasterClock *master_clock = _clutter_master_clock_get_default ();
       _clutter_master_clock_start_running (master_clock);
-      _clutter_stage_schedule_update (stage);
+      clutter_stage_schedule_update (stage);
     }
 }
 
@@ -1301,7 +1290,9 @@ _clutter_stage_needs_update (ClutterStage *stage)
 
   priv = stage->priv;
 
-  return priv->redraw_pending || g_hash_table_size (priv->pending_relayouts) > 0;
+  return (priv->redraw_pending ||
+          priv->needs_update ||
+          priv->pending_relayouts != NULL);
 }
 
 void
@@ -1310,11 +1301,11 @@ clutter_stage_queue_actor_relayout (ClutterStage *stage,
 {
   ClutterStagePrivate *priv = stage->priv;
 
-  if (g_hash_table_size (priv->pending_relayouts) == 0)
-    _clutter_stage_schedule_update (stage);
+  if (priv->pending_relayouts == NULL)
+    clutter_stage_schedule_update (stage);
 
-  g_hash_table_add (priv->pending_relayouts, g_object_ref (actor));
-  priv->pending_relayouts_version++;
+  priv->pending_relayouts = g_slist_prepend (priv->pending_relayouts,
+                                             g_object_ref (actor));
 }
 
 void
@@ -1322,24 +1313,20 @@ _clutter_stage_maybe_relayout (ClutterActor *actor)
 {
   ClutterStage *stage = CLUTTER_STAGE (actor);
   ClutterStagePrivate *priv = stage->priv;
-  GHashTableIter iter;
-  gpointer key;
+  g_autoptr (GSList) stolen_list = NULL;
+  GSList *l;
   int count = 0;
 
   /* No work to do? Avoid the extraneous debug log messages too. */
-  if (g_hash_table_size (priv->pending_relayouts) == 0)
+  if (priv->pending_relayouts == NULL)
     return;
 
   CLUTTER_NOTE (ACTOR, ">>> Recomputing layout");
 
-  g_hash_table_iter_init (&iter, priv->pending_relayouts);
-  while (g_hash_table_iter_next (&iter, &key, NULL))
+  stolen_list = g_steal_pointer (&priv->pending_relayouts);
+  for (l = stolen_list; l; l = l->next)
     {
-      g_autoptr (ClutterActor) queued_actor = key;
-      unsigned int old_version;
-
-      g_hash_table_iter_steal (&iter);
-      priv->pending_relayouts_version++;
+      g_autoptr (ClutterActor) queued_actor = l->data;
 
       if (CLUTTER_ACTOR_IN_RELAYOUT (queued_actor))  /* avoid reentrancy */
         continue;
@@ -1357,17 +1344,11 @@ _clutter_stage_maybe_relayout (ClutterActor *actor)
 
       CLUTTER_SET_PRIVATE_FLAGS (queued_actor, CLUTTER_IN_RELAYOUT);
 
-      old_version = priv->pending_relayouts_version;
-      clutter_actor_allocate_preferred_size (queued_actor,
-                                             CLUTTER_ALLOCATION_NONE);
+      clutter_actor_allocate_preferred_size (queued_actor);
 
       CLUTTER_UNSET_PRIVATE_FLAGS (queued_actor, CLUTTER_IN_RELAYOUT);
 
       count++;
-
-      /* Prevent using an iterator that's been invalidated */
-      if (old_version != priv->pending_relayouts_version)
-        g_hash_table_iter_init (&iter, priv->pending_relayouts);
     }
 
   CLUTTER_NOTE (ACTOR, "<<< Completed recomputing layout of %d subtrees", count);
@@ -1426,12 +1407,12 @@ _clutter_stage_check_updated_pointers (ClutterStage *stage)
   ClutterBackend *backend;
   ClutterSeat *seat;
   GSList *updating = NULL;
-  GList *l, *devices;
+  const GList *l, *devices;
   graphene_point_t point;
 
   backend = clutter_get_default_backend ();
   seat = clutter_backend_get_default_seat (backend);
-  devices = clutter_seat_list_devices (seat);
+  devices = clutter_seat_peek_devices (seat);
 
   for (l = devices; l; l = l->next)
     {
@@ -1471,11 +1452,17 @@ _clutter_stage_check_updated_pointers (ClutterStage *stage)
         }
     }
 
-  g_list_free (devices);
-
   return updating;
 }
 
+static void
+update_actor_stage_views (ClutterStage *stage)
+{
+  ClutterActor *actor = CLUTTER_ACTOR (stage);
+
+  clutter_actor_update_stage_views (actor);
+}
+
 /**
  * _clutter_stage_do_update:
  * @stage: A #ClutterStage
@@ -1493,6 +1480,8 @@ _clutter_stage_do_update (ClutterStage *stage)
 
   priv->stage_was_relayout = FALSE;
 
+  priv->needs_update = FALSE;
+
   /* if the stage is being destroyed, or if the destruction already
    * happened and we don't have an StageWindow any more, then we
    * should bail out
@@ -1521,6 +1510,10 @@ _clutter_stage_do_update (ClutterStage *stage)
   if (stage_was_relayout)
     pointers = _clutter_stage_check_updated_pointers (stage);
 
+  COGL_TRACE_BEGIN (ClutterStageUpdateActorStageViews, "Actor stage-views");
+  update_actor_stage_views (stage);
+  COGL_TRACE_END (ClutterStageUpdateActorStageViews);
+
   COGL_TRACE_BEGIN (ClutterStagePaint, "Paint");
 
   clutter_stage_maybe_finish_queue_redraws (stage);
@@ -1572,7 +1565,7 @@ is_full_stage_redraw_queued (ClutterStage *stage)
 {
   GList *l;
 
-  for (l = _clutter_stage_peek_stage_views (stage); l; l = l->next)
+  for (l = clutter_stage_peek_stage_views (stage); l; l = l->next)
     {
       ClutterStageView *view = l->data;
 
@@ -1916,7 +1909,9 @@ clutter_stage_dispose (GObject *object)
                     (GDestroyNotify) free_queue_redraw_entry);
   priv->pending_queue_redraws = NULL;
 
-  g_clear_pointer (&priv->pending_relayouts, g_hash_table_destroy);
+  g_slist_free_full (priv->pending_relayouts,
+                     (GDestroyNotify) g_object_unref);
+  priv->pending_relayouts = NULL;
 
   /* this will release the reference on the stage */
   stage_manager = clutter_stage_manager_get_default ();
@@ -2153,7 +2148,7 @@ clutter_stage_class_init (ClutterStageClass *klass)
                   NULL, NULL, NULL,
                   G_TYPE_NONE, 2,
                   CLUTTER_TYPE_STAGE_VIEW,
-                  G_TYPE_POINTER);
+                  CAIRO_GOBJECT_TYPE_REGION);
 
   /**
    * ClutterStage::presented: (skip)
@@ -2230,10 +2225,6 @@ clutter_stage_init (ClutterStage *self)
   clutter_actor_set_background_color (CLUTTER_ACTOR (self),
                                       &default_stage_color);
 
-  priv->pending_relayouts = g_hash_table_new_full (NULL,
-                                                   NULL,
-                                                   g_object_unref,
-                                                   NULL);
   clutter_stage_queue_actor_relayout (self, CLUTTER_ACTOR (self));
 
   clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
@@ -2245,10 +2236,7 @@ clutter_stage_init (ClutterStage *self)
   g_signal_connect (self, "notify::min-height",
                     G_CALLBACK (clutter_stage_notify_min_size), NULL);
 
-  _clutter_stage_set_viewport (self,
-                               0, 0,
-                               geom.width,
-                               geom.height);
+  clutter_stage_set_viewport (self, geom.width, geom.height);
 
   priv->paint_volume_stack =
     g_array_new (FALSE, FALSE, sizeof (ClutterPaintVolume));
@@ -2428,15 +2416,13 @@ _clutter_stage_dirty_projection (ClutterStage *stage)
     {
       ClutterStageView *view = l->data;
 
-      clutter_stage_view_set_dirty_projection (view, TRUE);
+      clutter_stage_view_invalidate_projection (view);
     }
 }
 
 /*
  * clutter_stage_set_viewport:
  * @stage: A #ClutterStage
- * @x: The X postition to render the stage at, in window coordinates
- * @y: The Y position to render the stage at, in window coordinates
  * @width: The width to render the stage at, in window coordinates
  * @height: The height to render the stage at, in window coordinates
  *
@@ -2469,19 +2455,22 @@ _clutter_stage_dirty_projection (ClutterStage *stage)
  *
  * Since: 1.6
  */
-void
-_clutter_stage_set_viewport (ClutterStage *stage,
-                             float         x,
-                             float         y,
-                             float         width,
-                             float         height)
+static void
+clutter_stage_set_viewport (ClutterStage *stage,
+                            float         width,
+                            float         height)
 {
   ClutterStagePrivate *priv;
+  float x, y;
 
   g_return_if_fail (CLUTTER_IS_STAGE (stage));
 
   priv = stage->priv;
 
+  x = 0.f;
+  y = 0.f;
+  width = roundf (width);
+  height = roundf (height);
 
   if (x == priv->viewport[0] &&
       y == priv->viewport[1] &&
@@ -2518,7 +2507,7 @@ _clutter_stage_dirty_viewport (ClutterStage *stage)
     {
       ClutterStageView *view = l->data;
 
-      clutter_stage_view_set_dirty_viewport (view, TRUE);
+      clutter_stage_view_invalidate_viewport (view);
     }
 }
 
@@ -3141,7 +3130,6 @@ _clutter_stage_maybe_setup_viewport (ClutterStage     *stage,
                                      ClutterStageView *view)
 {
   ClutterStagePrivate *priv = stage->priv;
-  CoglFramebuffer *fb = clutter_stage_view_get_framebuffer (view);
 
   if (clutter_stage_view_is_dirty_viewport (view))
     {
@@ -3168,54 +3156,18 @@ _clutter_stage_maybe_setup_viewport (ClutterStage     *stage,
       viewport_y = roundf (priv->viewport[1] * fb_scale - viewport_offset_y);
       viewport_width = roundf (priv->viewport[2] * fb_scale);
       viewport_height = roundf (priv->viewport[3] * fb_scale);
-      cogl_framebuffer_set_viewport (fb,
-                                     viewport_x, viewport_y,
-                                     viewport_width, viewport_height);
 
-      clutter_stage_view_set_dirty_viewport (view, FALSE);
+      clutter_stage_view_set_viewport (view,
+                                       viewport_x, viewport_y,
+                                       viewport_width, viewport_height);
     }
 
   if (clutter_stage_view_is_dirty_projection (view))
-    {
-      cogl_framebuffer_set_projection_matrix (fb, &priv->projection);
-
-      clutter_stage_view_set_dirty_projection (view, FALSE);
-    }
+    clutter_stage_view_set_projection (view, &priv->projection);
 }
 
 #undef _DEG_TO_RAD
 
-/**
- * clutter_stage_ensure_redraw:
- * @stage: a #ClutterStage
- *
- * Ensures that @stage is redrawn
- *
- * This function should not be called by applications: it is
- * used when embedding a #ClutterStage into a toolkit with
- * another windowing system, like GTK+.
- *
- * Since: 1.0
- */
-void
-clutter_stage_ensure_redraw (ClutterStage *stage)
-{
-  ClutterMasterClock *master_clock;
-  ClutterStagePrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_STAGE (stage));
-
-  priv = stage->priv;
-
-  if (!_clutter_stage_needs_update (stage))
-    _clutter_stage_schedule_update (stage);
-
-  priv->redraw_pending = TRUE;
-
-  master_clock = _clutter_master_clock_get_default ();
-  _clutter_master_clock_start_running (master_clock);
-}
-
 /**
  * clutter_stage_is_redraw_queued: (skip)
  */
@@ -3436,13 +3388,13 @@ clutter_stage_get_minimum_size (ClutterStage *stage,
 }
 
 /**
- * _clutter_stage_schedule_update:
- * @window: a #ClutterStage actor
+ * clutter_stage_schedule_update:
+ * @stage: a #ClutterStage actor
  *
  * Schedules a redraw of the #ClutterStage at the next optimal timestamp.
  */
 void
-_clutter_stage_schedule_update (ClutterStage *stage)
+clutter_stage_schedule_update (ClutterStage *stage)
 {
   ClutterStageWindow *stage_window;
 
@@ -3453,6 +3405,8 @@ _clutter_stage_schedule_update (ClutterStage *stage)
   if (stage_window == NULL)
     return;
 
+  stage->priv->needs_update = TRUE;
+
   return _clutter_stage_window_schedule_update (stage_window,
                                                 stage->priv->sync_delay);
 }
@@ -3462,7 +3416,7 @@ _clutter_stage_schedule_update (ClutterStage *stage)
  * @stage: a #ClutterStage actor
  *
  * Returns the earliest time in which the stage is ready to update. The update
- * time is set when _clutter_stage_schedule_update() is called. This can then
+ * time is set when clutter_stage_schedule_update() is called. This can then
  * be used by e.g. the #ClutterMasterClock to know when the stage needs to be
  * redrawn.
  *
@@ -3572,7 +3526,7 @@ _clutter_stage_queue_actor_redraw (ClutterStage                 *stage,
 
       CLUTTER_NOTE (PAINT, "First redraw request");
 
-      _clutter_stage_schedule_update (stage);
+      clutter_stage_schedule_update (stage);
       priv->redraw_pending = TRUE;
 
       master_clock = _clutter_master_clock_get_default ();
@@ -4119,20 +4073,29 @@ clutter_stage_get_capture_final_size (ClutterStage          *stage,
                                       int                   *out_height,
                                       float                 *out_scale)
 {
-  float max_scale;
+  float max_scale = 1.0;
 
   g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
 
   if (rect)
     {
       graphene_rect_t capture_rect;
+      g_autoptr (GList) views = NULL;
+      GList *l;
 
       _clutter_util_rect_from_rectangle (rect, &capture_rect);
-      if (!_clutter_stage_get_max_view_scale_factor_for_rect (stage,
-                                                              &capture_rect,
-                                                              &max_scale))
+      views = clutter_stage_get_views_for_rect (stage, &capture_rect);
+
+      if (!views)
         return FALSE;
 
+      for (l = views; l; l = l->next)
+        {
+          ClutterStageView *view = l->data;
+
+          max_scale = MAX (clutter_stage_view_get_scale (view), max_scale);
+        }
+
       if (out_width)
         *out_width = (gint) roundf (rect->width * max_scale);
 
@@ -4163,6 +4126,97 @@ clutter_stage_get_capture_final_size (ClutterStage          *stage,
   return TRUE;
 }
 
+void
+clutter_stage_paint_to_framebuffer (ClutterStage                *stage,
+                                    CoglFramebuffer             *framebuffer,
+                                    const cairo_rectangle_int_t *rect,
+                                    float                        scale,
+                                    ClutterPaintFlag             paint_flags)
+{
+  ClutterStagePrivate *priv = stage->priv;
+  ClutterPaintContext *paint_context;
+  cairo_region_t *redraw_clip;
+
+  redraw_clip = cairo_region_create_rectangle (rect);
+  paint_context =
+    clutter_paint_context_new_for_framebuffer (framebuffer,
+                                               redraw_clip,
+                                               paint_flags);
+  cairo_region_destroy (redraw_clip);
+
+  cogl_framebuffer_push_matrix (framebuffer);
+  cogl_framebuffer_set_projection_matrix (framebuffer, &priv->projection);
+  cogl_framebuffer_set_viewport (framebuffer,
+                                 -(rect->x * scale),
+                                 -(rect->y * scale),
+                                 priv->viewport[2] * scale,
+                                 priv->viewport[3] * scale);
+  clutter_actor_paint (CLUTTER_ACTOR (stage), paint_context);
+  cogl_framebuffer_pop_matrix (framebuffer);
+
+  clutter_paint_context_destroy (paint_context);
+}
+
+gboolean
+clutter_stage_paint_to_buffer (ClutterStage                 *stage,
+                               const cairo_rectangle_int_t  *rect,
+                               float                         scale,
+                               uint8_t                      *data,
+                               int                           stride,
+                               CoglPixelFormat               format,
+                               ClutterPaintFlag              paint_flags,
+                               GError                      **error)
+{
+  ClutterBackend *clutter_backend = clutter_get_default_backend ();
+  CoglContext *cogl_context =
+    clutter_backend_get_cogl_context (clutter_backend);
+  int texture_width, texture_height;
+  CoglTexture2D *texture;
+  CoglOffscreen *offscreen;
+  CoglFramebuffer *framebuffer;
+  CoglBitmap *bitmap;
+
+  texture_width = (int) roundf (rect->width * scale);
+  texture_height = (int) roundf (rect->height * scale);
+  texture = cogl_texture_2d_new_with_size (cogl_context,
+                                           texture_width,
+                                           texture_height);
+  if (!texture)
+    {
+      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
+                   "Failed to create %dx%d texture",
+                   texture_width, texture_height);
+      return FALSE;
+    }
+
+  offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture));
+  framebuffer = COGL_FRAMEBUFFER (offscreen);
+
+  cogl_object_unref (texture);
+
+  if (!cogl_framebuffer_allocate (framebuffer, error))
+    return FALSE;
+
+  clutter_stage_paint_to_framebuffer (stage, framebuffer,
+                                      rect, scale, paint_flags);
+
+  bitmap = cogl_bitmap_new_for_data (cogl_context,
+                                     texture_width, texture_height,
+                                     format,
+                                     stride,
+                                     data);
+
+  cogl_framebuffer_read_pixels_into_bitmap (framebuffer,
+                                            0, 0,
+                                            COGL_READ_PIXELS_COLOR_BUFFER,
+                                            bitmap);
+
+  cogl_object_unref (bitmap);
+  cogl_object_unref (framebuffer);
+
+  return TRUE;
+}
+
 static void
 capture_view_into (ClutterStage          *stage,
                    gboolean               paint,
@@ -4310,8 +4364,11 @@ clutter_stage_thaw_updates (ClutterStage *stage)
     }
 }
 
+/**
+ * clutter_stage_peek_stage_views: (skip)
+ */
 GList *
-_clutter_stage_peek_stage_views (ClutterStage *stage)
+clutter_stage_peek_stage_views (ClutterStage *stage)
 {
   ClutterStagePrivate *priv = stage->priv;
 
@@ -4319,18 +4376,17 @@ _clutter_stage_peek_stage_views (ClutterStage *stage)
 }
 
 void
-clutter_stage_update_resource_scales (ClutterStage *stage)
+clutter_stage_clear_stage_views (ClutterStage *stage)
 {
-  _clutter_actor_queue_update_resource_scale_recursive (CLUTTER_ACTOR (stage));
+  clutter_actor_clear_stage_views_recursive (CLUTTER_ACTOR (stage));
 }
 
-gboolean
-_clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage    *stage,
-                                                   graphene_rect_t *rect,
-                                                   float           *view_scale)
+GList *
+clutter_stage_get_views_for_rect (ClutterStage          *stage,
+                                  const graphene_rect_t *rect)
 {
   ClutterStagePrivate *priv = stage->priv;
-  float scale = 0.0f;
+  GList *views_for_rect = NULL;
   GList *l;
 
   for (l = _clutter_stage_window_get_views (priv->impl); l; l = l->next)
@@ -4343,12 +4399,8 @@ _clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage    *stage,
       _clutter_util_rect_from_rectangle (&view_layout, &view_rect);
 
       if (graphene_rect_intersection (&view_rect, rect, NULL))
-        scale = MAX (clutter_stage_view_get_scale (view), scale);
+        views_for_rect = g_list_prepend (views_for_rect, view);
     }
 
-  if (scale == 0.0)
-    return FALSE;
-
-  *view_scale = scale;
-  return TRUE;
+  return views_for_rect;
 }

clutter/clutter/clutter-stage.h

@@ -195,8 +195,6 @@ guchar *        clutter_stage_read_pixels                       (ClutterStage
 
 CLUTTER_EXPORT
 void            clutter_stage_ensure_viewport                   (ClutterStage          *stage);
-CLUTTER_EXPORT
-void            clutter_stage_ensure_redraw                     (ClutterStage          *stage);
 
 CLUTTER_EXPORT
 gboolean        clutter_stage_is_redraw_queued                  (ClutterStage          *stage);
@@ -209,6 +207,9 @@ CLUTTER_EXPORT
 void            clutter_stage_skip_sync_delay                   (ClutterStage          *stage);
 #endif
 
+CLUTTER_EXPORT
+void clutter_stage_schedule_update (ClutterStage *stage);
+
 CLUTTER_EXPORT
 gboolean clutter_stage_get_capture_final_size (ClutterStage          *stage,
                                                cairo_rectangle_int_t *rect,

clutter/clutter/clutter-text.c

@@ -3037,8 +3037,7 @@ clutter_text_get_preferred_height (ClutterActor *self,
 
 static void
 clutter_text_allocate (ClutterActor           *self,
-                       const ClutterActorBox  *box,
-                       ClutterAllocationFlags  flags)
+                       const ClutterActorBox  *box)
 {
   ClutterText *text = CLUTTER_TEXT (self);
   ClutterActorClass *parent_class;
@@ -3058,7 +3057,7 @@ clutter_text_allocate (ClutterActor           *self,
                                                   box->y2 - box->y1);
 
   parent_class = CLUTTER_ACTOR_CLASS (clutter_text_parent_class);
-  parent_class->allocate (self, box, flags);
+  parent_class->allocate (self, box);
 }
 
 static gboolean
@@ -4787,11 +4786,11 @@ clutter_text_queue_redraw_or_relayout (ClutterText *self)
   clutter_text_get_preferred_height (actor, preferred_width, NULL, &preferred_height);
 
   if (clutter_actor_has_allocation (actor) &&
-      (fabsf (preferred_width - clutter_actor_get_width (actor)) > 0.001 ||
-       fabsf (preferred_height - clutter_actor_get_height (actor)) > 0.001))
-    clutter_actor_queue_relayout (actor);
-  else
+      fabsf (preferred_width - clutter_actor_get_width (actor)) <= 0.001 &&
+      fabsf (preferred_height - clutter_actor_get_height (actor)) <= 0.001)
     clutter_text_queue_redraw (actor);
+  else
+    clutter_actor_queue_relayout (actor);
 }
 
 static void

clutter/clutter/clutter-timeline.c

@@ -24,7 +24,6 @@
 /**
  * SECTION:clutter-timeline
  * @short_description: A class for time-based events
- * @see_also: #ClutterAnimation, #ClutterAnimator, #ClutterState
  *
  * #ClutterTimeline is a base class for managing time-based event that cause
  * Clutter to redraw a stage, such as animations.
@@ -71,7 +70,7 @@
  * when reaching completion by using the #ClutterTimeline:auto-reverse property.
  *
  * Timelines are used in the Clutter animation framework by classes like
- * #ClutterAnimation, #ClutterAnimator, and #ClutterState.
+ * #ClutterTransition.
  *
  * ## Defining Timelines in ClutterScript
  *
@@ -173,7 +172,6 @@ enum
 {
   PROP_0,
 
-  PROP_LOOP,
   PROP_DELAY,
   PROP_DURATION,
   PROP_DIRECTION,
@@ -291,23 +289,6 @@ clutter_timeline_add_marker_internal (ClutterTimeline *timeline,
   g_hash_table_insert (priv->markers_by_name, marker->name, marker);
 }
 
-static inline void
-clutter_timeline_set_loop_internal (ClutterTimeline *timeline,
-                                    gboolean         loop)
-{
-  gint old_repeat_count;
-
-  old_repeat_count = timeline->priv->repeat_count;
-
-  if (loop)
-    clutter_timeline_set_repeat_count (timeline, -1);
-  else
-    clutter_timeline_set_repeat_count (timeline, 0);
-
-  if (old_repeat_count != timeline->priv->repeat_count)
-    g_object_notify_by_pspec (G_OBJECT (timeline), obj_props[PROP_LOOP]);
-}
-
 /* Scriptable */
 typedef struct _ParseClosure {
   ClutterTimeline *timeline;
@@ -449,10 +430,6 @@ clutter_timeline_set_property (GObject      *object,
 
   switch (prop_id)
     {
-    case PROP_LOOP:
-      clutter_timeline_set_loop_internal (timeline, g_value_get_boolean (value));
-      break;
-
     case PROP_DELAY:
       clutter_timeline_set_delay (timeline, g_value_get_uint (value));
       break;
@@ -494,10 +471,6 @@ clutter_timeline_get_property (GObject    *object,
 
   switch (prop_id)
     {
-    case PROP_LOOP:
-      g_value_set_boolean (value, priv->repeat_count != 0);
-      break;
-
     case PROP_DELAY:
       g_value_set_uint (value, priv->delay);
       break;
@@ -573,25 +546,6 @@ clutter_timeline_class_init (ClutterTimelineClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  /**
-   * ClutterTimeline:loop:
-   *
-   * Whether the timeline should automatically rewind and restart.
-   *
-   * As a side effect, setting this property to %TRUE will set the
-   * #ClutterTimeline:repeat-count property to -1, while setting this
-   * property to %FALSE will set the #ClutterTimeline:repeat-count
-   * property to 0.
-   *
-   * Deprecated: 1.10: Use the #ClutterTimeline:repeat-count property instead.
-   */
-  obj_props[PROP_LOOP] =
-    g_param_spec_boolean ("loop",
-                          P_("Loop"),
-                          P_("Should the timeline automatically restart"),
-                          FALSE,
-                          CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
-
   /**
    * ClutterTimeline:delay:
    *
@@ -1252,45 +1206,6 @@ clutter_timeline_stop (ClutterTimeline *timeline)
     g_signal_emit (timeline, timeline_signals[STOPPED], 0, FALSE);
 }
 
-/**
- * clutter_timeline_set_loop:
- * @timeline: a #ClutterTimeline
- * @loop: %TRUE for enable looping
- *
- * Sets whether @timeline should loop.
- *
- * This function is equivalent to calling clutter_timeline_set_repeat_count()
- * with -1 if @loop is %TRUE, and with 0 if @loop is %FALSE.
- *
- * Deprecated: 1.10: Use clutter_timeline_set_repeat_count() instead.
- */
-void
-clutter_timeline_set_loop (ClutterTimeline *timeline,
-			   gboolean         loop)
-{
-  g_return_if_fail (CLUTTER_IS_TIMELINE (timeline));
-
-  clutter_timeline_set_loop_internal (timeline, loop);
-}
-
-/**
- * clutter_timeline_get_loop:
- * @timeline: a #ClutterTimeline
- *
- * Gets whether @timeline is looping
- *
- * Return value: %TRUE if the timeline is looping
- *
- * Deprecated: 1.10: Use clutter_timeline_get_repeat_count() instead.
- */
-gboolean
-clutter_timeline_get_loop (ClutterTimeline *timeline)
-{
-  g_return_val_if_fail (CLUTTER_IS_TIMELINE (timeline), FALSE);
-
-  return timeline->priv->repeat_count != 0;
-}
-
 /**
  * clutter_timeline_rewind:
  * @timeline: A #ClutterTimeline
@@ -1406,49 +1321,11 @@ clutter_timeline_is_playing (ClutterTimeline *timeline)
   return timeline->priv->is_playing;
 }
 
-/**
- * clutter_timeline_clone:
- * @timeline: #ClutterTimeline to duplicate.
- *
- * Create a new #ClutterTimeline instance which has property values
- * matching that of supplied timeline. The cloned timeline will not
- * be started and will not be positioned to the current position of
- * the original @timeline: you will have to start it with
- * clutter_timeline_start().
- *
- * The only cloned properties are:
- *
- *  - #ClutterTimeline:duration
- *  - #ClutterTimeline:loop
- *  - #ClutterTimeline:delay
- *  - #ClutterTimeline:direction
- *
- * Return value: (transfer full): a new #ClutterTimeline, cloned
- *   from @timeline
- *
- * Since: 0.4
- *
- * Deprecated: 1.10: Use clutter_timeline_new() or g_object_new()
- *   instead
- */
-ClutterTimeline *
-clutter_timeline_clone (ClutterTimeline *timeline)
-{
-  g_return_val_if_fail (CLUTTER_IS_TIMELINE (timeline), NULL);
-
-  return g_object_new (CLUTTER_TYPE_TIMELINE,
-                       "duration", timeline->priv->duration,
-                       "loop", timeline->priv->repeat_count != 0,
-                       "delay", timeline->priv->delay,
-                       "direction", timeline->priv->direction,
-                       NULL);
-}
-
 /**
  * clutter_timeline_new:
- * @msecs: Duration of the timeline in milliseconds
+ * @duration_ms: Duration of the timeline in milliseconds
  *
- * Creates a new #ClutterTimeline with a duration of @msecs.
+ * Creates a new #ClutterTimeline with a duration of @duration_ms milli seconds.
  *
  * Return value: the newly created #ClutterTimeline instance. Use
  *   g_object_unref() when done using it
@@ -1456,10 +1333,10 @@ clutter_timeline_clone (ClutterTimeline *timeline)
  * Since: 0.6
  */
 ClutterTimeline *
-clutter_timeline_new (guint msecs)
+clutter_timeline_new (guint duration_ms)
 {
   return g_object_new (CLUTTER_TYPE_TIMELINE,
-                       "duration", msecs,
+                       "duration", duration_ms,
                        NULL);
 }
 

clutter/clutter/clutter-timeline.h

@@ -119,7 +119,7 @@ CLUTTER_EXPORT
 GType clutter_timeline_get_type (void) G_GNUC_CONST;
 
 CLUTTER_EXPORT
-ClutterTimeline *               clutter_timeline_new                            (guint                     msecs);
+ClutterTimeline *               clutter_timeline_new                            (guint                     duration_ms);
 
 CLUTTER_EXPORT
 guint                           clutter_timeline_get_duration                   (ClutterTimeline          *timeline);

clutter/clutter/clutter-types.h

@@ -79,10 +79,6 @@ typedef struct _ClutterKnot                     ClutterKnot;
 typedef struct _ClutterMargin                   ClutterMargin;
 typedef struct _ClutterPerspective              ClutterPerspective;
 
-typedef struct _ClutterAlpha            	ClutterAlpha;
-typedef struct _ClutterAnimation                ClutterAnimation;
-typedef struct _ClutterState            	ClutterState;
-
 typedef struct _ClutterInputDeviceTool          ClutterInputDeviceTool;
 typedef struct _ClutterInputDevice              ClutterInputDevice;
 typedef struct _ClutterVirtualInputDevice       ClutterVirtualInputDevice;
@@ -178,6 +174,20 @@ struct _ClutterActorBox
  */
 #define CLUTTER_ACTOR_BOX_INIT_ZERO                     CLUTTER_ACTOR_BOX_INIT (0.f, 0.f, 0.f, 0.f)
 
+/**
+ * CLUTTER_ACTOR_BOX_UNINITIALIZED:
+ *
+ * A simple macro for creating a #ClutterActorBox with a size of -1 when
+ * declaring it, e.g.:
+ *
+ * |[
+ *   ClutterActorBox box = CLUTTER_ACTOR_BOX_UNINITIALIZED;
+ * ]|
+ */
+
+
+#define CLUTTER_ACTOR_BOX_UNINITIALIZED { .x1 = INFINITY, .y1 = INFINITY, .x2 = -INFINITY, .y2 = -INFINITY }
+
 CLUTTER_EXPORT
 GType            clutter_actor_box_get_type      (void) G_GNUC_CONST;
 CLUTTER_EXPORT
@@ -256,6 +266,9 @@ CLUTTER_EXPORT
 void             clutter_actor_box_scale          (ClutterActorBox       *box,
                                                    gfloat                 scale);
 
+CLUTTER_EXPORT
+gboolean         clutter_actor_box_is_initialized (ClutterActorBox       *box);
+
 /**
  * ClutterKnot:
  * @x: X coordinate of the knot

clutter/clutter/cogl/clutter-stage-cogl.c

@@ -38,6 +38,7 @@
 
 #include "clutter-actor-private.h"
 #include "clutter-backend-private.h"
+#include "clutter-damage-history.h"
 #include "clutter-debug.h"
 #include "clutter-event.h"
 #include "clutter-enum-types.h"
@@ -51,13 +52,9 @@
 
 typedef struct _ClutterStageViewCoglPrivate
 {
-  /*
-   * List of previous damaged areas in stage view framebuffer coordinate space.
+  /* Damage history, in stage view render target framebuffer coordinate space.
    */
-#define DAMAGE_HISTORY_MAX 16
-#define DAMAGE_HISTORY(x) ((x) & (DAMAGE_HISTORY_MAX - 1))
-  cairo_region_t * damage_history[DAMAGE_HISTORY_MAX];
-  unsigned int damage_index;
+  ClutterDamageHistory *damage_history;
 } ClutterStageViewCoglPrivate;
 
 G_DEFINE_TYPE_WITH_PRIVATE (ClutterStageViewCogl, clutter_stage_view_cogl,
@@ -288,26 +285,13 @@ clutter_stage_cogl_resize (ClutterStageWindow *stage_window,
 {
 }
 
-static inline gboolean
-valid_buffer_age (ClutterStageViewCogl *view_cogl,
-                  int                   age)
-{
-  ClutterStageViewCoglPrivate *view_priv =
-    clutter_stage_view_cogl_get_instance_private (view_cogl);
-
-  if (age <= 0)
-    return FALSE;
-
-  return age < MIN (view_priv->damage_index, DAMAGE_HISTORY_MAX);
-}
-
 static void
 paint_damage_region (ClutterStageWindow *stage_window,
                      ClutterStageView   *view,
                      cairo_region_t     *swap_region,
                      cairo_region_t     *queued_redraw_clip)
 {
-  CoglFramebuffer *framebuffer = clutter_stage_view_get_onscreen (view);
+  CoglFramebuffer *framebuffer = clutter_stage_view_get_framebuffer (view);
   CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
   static CoglPipeline *overlay_blue = NULL;
   ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window);
@@ -375,31 +359,29 @@ static gboolean
 swap_framebuffer (ClutterStageWindow *stage_window,
                   ClutterStageView   *view,
                   cairo_region_t     *swap_region,
-                  gboolean            swap_with_damage,
-                  cairo_region_t     *queued_redraw_clip)
+                  gboolean            swap_with_damage)
 {
   CoglFramebuffer *framebuffer = clutter_stage_view_get_onscreen (view);
-  int *damage, n_rects, i;
 
-  if (G_UNLIKELY ((clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_DAMAGE_REGION)))
-    paint_damage_region (stage_window, view, swap_region, queued_redraw_clip);
-
-  n_rects = cairo_region_num_rectangles (swap_region);
-  damage = g_newa (int, n_rects * 4);
-  for (i = 0; i < n_rects; i++)
-    {
-      cairo_rectangle_int_t rect;
-
-      cairo_region_get_rectangle (swap_region, i, &rect);
-      damage[i * 4] = rect.x;
-      damage[i * 4 + 1] = rect.y;
-      damage[i * 4 + 2] = rect.width;
-      damage[i * 4 + 3] = rect.height;
-    }
+  clutter_stage_view_before_swap_buffer (view, swap_region);
 
   if (cogl_is_onscreen (framebuffer))
     {
       CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer);
+      int *damage, n_rects, i;
+
+      n_rects = cairo_region_num_rectangles (swap_region);
+      damage = g_newa (int, n_rects * 4);
+      for (i = 0; i < n_rects; i++)
+        {
+          cairo_rectangle_int_t rect;
+
+          cairo_region_get_rectangle (swap_region, i, &rect);
+          damage[i * 4] = rect.x;
+          damage[i * 4 + 1] = rect.y;
+          damage[i * 4 + 2] = rect.width;
+          damage[i * 4 + 3] = rect.height;
+        }
 
       /* push on the screen */
       if (n_rects > 0 && !swap_with_damage)
@@ -434,18 +416,6 @@ swap_framebuffer (ClutterStageWindow *stage_window,
     }
 }
 
-static void
-scale_and_clamp_rect (const graphene_rect_t *rect,
-                      float                  scale,
-                      cairo_rectangle_int_t *dest)
-
-{
-  graphene_rect_t tmp = *rect;
-
-  graphene_rect_scale (&tmp, scale, scale, &tmp);
-  _clutter_util_rectangle_int_extents (&tmp, dest);
-}
-
 static cairo_region_t *
 offset_scale_and_clamp_region (const cairo_region_t *region,
                                int                   offset_x,
@@ -467,15 +437,52 @@ offset_scale_and_clamp_region (const cairo_region_t *region,
     rects = freeme = g_new (cairo_rectangle_int_t, n_rects);
 
   for (i = 0; i < n_rects; i++)
-    cairo_region_get_rectangle (region, i, &rects[i]);
+    {
+      cairo_rectangle_int_t *rect = &rects[i];
+      graphene_rect_t tmp;
+
+      cairo_region_get_rectangle (region, i, rect);
+
+      _clutter_util_rect_from_rectangle (rect, &tmp);
+      graphene_rect_offset (&tmp, offset_x, offset_y);
+      graphene_rect_scale (&tmp, scale, scale, &tmp);
+      _clutter_util_rectangle_int_extents (&tmp, rect);
+    }
+
+  return cairo_region_create_rectangles (rects, n_rects);
+}
+
+static cairo_region_t *
+scale_offset_and_clamp_region (const cairo_region_t *region,
+                               float                 scale,
+                               int                   offset_x,
+                               int                   offset_y)
+{
+  int n_rects, i;
+  cairo_rectangle_int_t *rects;
+  g_autofree cairo_rectangle_int_t *freeme = NULL;
+
+  n_rects = cairo_region_num_rectangles (region);
+
+  if (n_rects == 0)
+    return cairo_region_create ();
+
+  if (n_rects < MAX_STACK_RECTS)
+    rects = g_newa (cairo_rectangle_int_t, n_rects);
+  else
+    rects = freeme = g_new (cairo_rectangle_int_t, n_rects);
 
   for (i = 0; i < n_rects; i++)
     {
+      cairo_rectangle_int_t *rect = &rects[i];
       graphene_rect_t tmp;
 
-      _clutter_util_rect_from_rectangle (&rects[i], &tmp);
+      cairo_region_get_rectangle (region, i, rect);
+
+      _clutter_util_rect_from_rectangle (rect, &tmp);
+      graphene_rect_scale (&tmp, scale, scale, &tmp);
       graphene_rect_offset (&tmp, offset_x, offset_y);
-      scale_and_clamp_rect (&tmp, scale, &rects[i]);
+      _clutter_util_rectangle_int_extents (&tmp, rect);
     }
 
   return cairo_region_create_rectangles (rects, n_rects);
@@ -491,107 +498,38 @@ paint_stage (ClutterStageCogl *stage_cogl,
   _clutter_stage_maybe_setup_viewport (stage, view);
   clutter_stage_paint_view (stage, view, redraw_clip);
 
-  clutter_stage_view_after_paint (view);
-}
-
-static void
-fill_current_damage_history (ClutterStageView *view,
-                             cairo_region_t   *damage)
-{
-  ClutterStageViewCogl *view_cogl = CLUTTER_STAGE_VIEW_COGL (view);
-  ClutterStageViewCoglPrivate *view_priv =
-    clutter_stage_view_cogl_get_instance_private (view_cogl);
-  cairo_region_t **current_fb_damage;
-
-  current_fb_damage =
-    &view_priv->damage_history[DAMAGE_HISTORY (view_priv->damage_index)];
-
-  g_clear_pointer (current_fb_damage, cairo_region_destroy);
-  *current_fb_damage = cairo_region_copy (damage);
-  view_priv->damage_index++;
-}
-
-static void
-fill_current_damage_history_rectangle (ClutterStageView            *view,
-                                       const cairo_rectangle_int_t *rect)
-{
-  cairo_region_t *damage;
-
-  damage = cairo_region_create_rectangle (rect);
-  fill_current_damage_history (view, damage);
-  cairo_region_destroy (damage);
+  clutter_stage_view_after_paint (view, redraw_clip);
 }
 
 static cairo_region_t *
 transform_swap_region_to_onscreen (ClutterStageView *view,
                                    cairo_region_t   *swap_region)
 {
-  CoglFramebuffer *framebuffer;
-  cairo_rectangle_int_t layout;
-  gint width, height;
+  CoglFramebuffer *onscreen = clutter_stage_view_get_onscreen (view);
   int n_rects, i;
   cairo_rectangle_int_t *rects;
   cairo_region_t *transformed_region;
+  int width, height;
 
-  framebuffer = clutter_stage_view_get_onscreen (view);
-  clutter_stage_view_get_layout (view, &layout);
-
-  width = cogl_framebuffer_get_width (framebuffer);
-  height = cogl_framebuffer_get_height (framebuffer);
+  width = cogl_framebuffer_get_width (onscreen);
+  height = cogl_framebuffer_get_height (onscreen);
 
   n_rects = cairo_region_num_rectangles (swap_region);
   rects = g_newa (cairo_rectangle_int_t, n_rects);
   for (i = 0; i < n_rects; i++)
     {
-      gfloat x1, y1, x2, y2;
-
       cairo_region_get_rectangle (swap_region, i, &rects[i]);
-
-      x1 = (float) rects[i].x / layout.width;
-      y1 = (float) rects[i].y / layout.height;
-      x2 = (float) (rects[i].x + rects[i].width) / layout.width;
-      y2 = (float) (rects[i].y + rects[i].height) / layout.height;
-
-      clutter_stage_view_transform_to_onscreen (view, &x1, &y1);
-      clutter_stage_view_transform_to_onscreen (view, &x2, &y2);
-
-      x1 = floor (x1 * width);
-      y1 = floor (height - (y1 * height));
-      x2 = ceil (x2 * width);
-      y2 = ceil (height - (y2 * height));
-
-      rects[i].x = x1;
-      rects[i].y = y1;
-      rects[i].width = x2 - x1;
-      rects[i].height = y2 - y1;
+      clutter_stage_view_transform_rect_to_onscreen (view,
+                                                     &rects[i],
+                                                     width,
+                                                     height,
+                                                     &rects[i]);
     }
   transformed_region = cairo_region_create_rectangles (rects, n_rects);
 
   return transformed_region;
 }
 
-static void
-calculate_scissor_region (cairo_rectangle_int_t *fb_clip_region,
-                          int                    subpixel_compensation,
-                          int                    fb_width,
-                          int                    fb_height,
-                          cairo_rectangle_int_t *out_scissor_rect)
-{
-  *out_scissor_rect = *fb_clip_region;
-
-  if (subpixel_compensation == 0)
-    return;
-
-  if (fb_clip_region->x > 0)
-    out_scissor_rect->x += subpixel_compensation;
-  if (fb_clip_region->y > 0)
-    out_scissor_rect->y += subpixel_compensation;
-  if (fb_clip_region->x + fb_clip_region->width < fb_width)
-    out_scissor_rect->width -= 2 * subpixel_compensation;
-  if (fb_clip_region->y + fb_clip_region->height < fb_height)
-    out_scissor_rect->height -= 2 * subpixel_compensation;
-}
-
 static inline gboolean
 is_buffer_age_enabled (void)
 {
@@ -610,27 +548,21 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
   ClutterStageViewCoglPrivate *view_priv =
     clutter_stage_view_cogl_get_instance_private (view_cogl);
   CoglFramebuffer *fb = clutter_stage_view_get_framebuffer (view);
+  CoglFramebuffer *onscreen = clutter_stage_view_get_onscreen (view);
   cairo_rectangle_int_t view_rect;
   gboolean is_full_redraw;
-  gboolean may_use_clipped_redraw;
-  gboolean use_clipped_redraw;
+  gboolean use_clipped_redraw = TRUE;
   gboolean can_blit_sub_buffer;
   gboolean has_buffer_age;
-  gboolean do_swap_buffer;
   gboolean swap_with_damage;
-  ClutterActor *wrapper;
   cairo_region_t *redraw_clip;
-  cairo_region_t *queued_redraw_clip;
+  cairo_region_t *queued_redraw_clip = NULL;
   cairo_region_t *fb_clip_region;
   cairo_region_t *swap_region;
-  cairo_rectangle_int_t redraw_rect;
-  gboolean clip_region_empty;
   float fb_scale;
-  int subpixel_compensation = 0;
   int fb_width, fb_height;
-  int buffer_age;
-
-  wrapper = CLUTTER_ACTOR (stage_cogl->wrapper);
+  int buffer_age = 0;
+  gboolean res;
 
   clutter_stage_view_get_layout (view, &view_rect);
   fb_scale = clutter_stage_view_get_scale (view);
@@ -638,12 +570,14 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
   fb_height = cogl_framebuffer_get_height (fb);
 
   can_blit_sub_buffer =
-    cogl_is_onscreen (fb) &&
+    cogl_is_onscreen (onscreen) &&
     cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_REGION);
 
-  has_buffer_age = cogl_is_onscreen (fb) && is_buffer_age_enabled ();
+  has_buffer_age = cogl_is_onscreen (onscreen) && is_buffer_age_enabled ();
 
   redraw_clip = clutter_stage_view_take_redraw_clip (view);
+  if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_DAMAGE_REGION))
+    queued_redraw_clip = cairo_region_copy (redraw_clip);
 
   /* NB: a NULL redraw clip == full stage redraw */
   if (!redraw_clip)
@@ -651,51 +585,35 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
   else
     is_full_redraw = FALSE;
 
-  may_use_clipped_redraw =
+  if (has_buffer_age)
+    {
+      buffer_age = cogl_onscreen_get_buffer_age (COGL_ONSCREEN (onscreen));
+      if (!clutter_damage_history_is_age_valid (view_priv->damage_history,
+                                                buffer_age))
+        {
+          CLUTTER_NOTE (CLIPPING,
+                        "Invalid back buffer(age=%d): forcing full redraw\n",
+                        buffer_age);
+          use_clipped_redraw = FALSE;
+        }
+    }
+
+  use_clipped_redraw =
+    use_clipped_redraw &&
+    !(clutter_paint_debug_flags & CLUTTER_DEBUG_DISABLE_CLIPPED_REDRAWS) &&
     _clutter_stage_window_can_clip_redraws (stage_window) &&
     (can_blit_sub_buffer || has_buffer_age) &&
     !is_full_redraw &&
     /* some drivers struggle to get going and produce some junk
      * frames when starting up... */
-    cogl_onscreen_get_frame_counter (COGL_ONSCREEN (fb)) > 3;
+    cogl_onscreen_get_frame_counter (COGL_ONSCREEN (onscreen)) > 3;
 
-  if (has_buffer_age)
-    {
-      buffer_age = cogl_onscreen_get_buffer_age (COGL_ONSCREEN (fb));
-      if (!valid_buffer_age (view_cogl, buffer_age))
-        {
-          CLUTTER_NOTE (CLIPPING, "Invalid back buffer(age=%d): forcing full redraw\n", buffer_age);
-          may_use_clipped_redraw = FALSE;
-        }
-    }
-
-  if (may_use_clipped_redraw)
+  if (use_clipped_redraw)
     {
       fb_clip_region = offset_scale_and_clamp_region (redraw_clip,
                                                       -view_rect.x,
                                                       -view_rect.y,
                                                       fb_scale);
-
-      if (fb_scale != floorf (fb_scale))
-        {
-          int n_rects, i;
-          cairo_rectangle_int_t *rects;
-
-          subpixel_compensation = ceilf (fb_scale);
-
-          n_rects = cairo_region_num_rectangles (fb_clip_region);
-          rects = g_newa (cairo_rectangle_int_t, n_rects);
-          for (i = 0; i < n_rects; i++)
-            {
-              cairo_region_get_rectangle (fb_clip_region, i, &rects[i]);
-              rects[i].x -= subpixel_compensation;
-              rects[i].y -= subpixel_compensation;
-              rects[i].width += 2 * subpixel_compensation;
-              rects[i].height += 2 * subpixel_compensation;
-            }
-          cairo_region_destroy (fb_clip_region);
-          fb_clip_region = cairo_region_create_rectangles (rects, n_rects);
-        }
     }
   else
     {
@@ -711,48 +629,40 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
       redraw_clip = cairo_region_create_rectangle (&view_rect);
     }
 
-  queued_redraw_clip = cairo_region_copy (redraw_clip);
-
-  if (may_use_clipped_redraw &&
-      G_LIKELY (!(clutter_paint_debug_flags & CLUTTER_DEBUG_DISABLE_CLIPPED_REDRAWS)))
-    use_clipped_redraw = TRUE;
-  else
-    use_clipped_redraw = FALSE;
-
-  clip_region_empty = may_use_clipped_redraw && cairo_region_is_empty (fb_clip_region);
+  g_return_val_if_fail (!cairo_region_is_empty (fb_clip_region), FALSE);
 
   swap_with_damage = FALSE;
   if (has_buffer_age)
     {
-      if (use_clipped_redraw && !clip_region_empty)
+      clutter_damage_history_record (view_priv->damage_history,
+                                     fb_clip_region);
+
+      if (use_clipped_redraw)
         {
           cairo_region_t *fb_damage;
           cairo_region_t *view_damage;
-          int i;
-
-          fill_current_damage_history (view, fb_clip_region);
+          int age;
 
           fb_damage = cairo_region_create ();
 
-          for (i = 1; i <= buffer_age; i++)
+          for (age = 1; age <= buffer_age; age++)
             {
-              int damage_index;
+              const cairo_region_t *old_damage;
 
-              damage_index = DAMAGE_HISTORY (view_priv->damage_index - i - 1);
-              cairo_region_union (fb_damage,
-                                  view_priv->damage_history[damage_index]);
+              old_damage =
+                clutter_damage_history_lookup (view_priv->damage_history, age);
+              cairo_region_union (fb_damage, old_damage);
             }
 
           /* Update the fb clip region with the extra damage. */
           cairo_region_union (fb_clip_region, fb_damage);
 
-          view_damage = offset_scale_and_clamp_region (fb_damage,
-                                                       0, 0,
-                                                       1.0f / fb_scale);
-          cairo_region_translate (view_damage, view_rect.x, view_rect.y);
-          cairo_region_intersect_rectangle (view_damage, &view_rect);
+          /* Update the redraw clip with the extra damage done to the view */
+          view_damage = scale_offset_and_clamp_region (fb_damage,
+                                                       1.0f / fb_scale,
+                                                       view_rect.x,
+                                                       view_rect.y);
 
-          /* Update the redraw clip region with the extra damage. */
           cairo_region_union (redraw_clip, view_damage);
 
           cairo_region_destroy (view_damage);
@@ -764,55 +674,13 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
 
           swap_with_damage = TRUE;
         }
-      else if (!use_clipped_redraw)
-        {
-          cairo_rectangle_int_t fb_damage;
 
-          fb_damage = (cairo_rectangle_int_t) {
-            .x = 0,
-            .y = 0,
-            .width = ceilf (view_rect.width * fb_scale),
-            .height = ceilf (view_rect.height * fb_scale)
-          };
-          fill_current_damage_history_rectangle (view, &fb_damage);
-        }
+      clutter_damage_history_step (view_priv->damage_history);
     }
 
-  if (use_clipped_redraw && clip_region_empty)
+  if (use_clipped_redraw)
     {
-      CLUTTER_NOTE (CLIPPING, "Empty stage output paint\n");
-    }
-  else if (use_clipped_redraw)
-    {
-      cairo_rectangle_int_t clip_rect;
-      cairo_rectangle_int_t scissor_rect;
-
-      if (cairo_region_num_rectangles (fb_clip_region) == 1)
-        {
-          cairo_region_get_extents (fb_clip_region, &clip_rect);
-
-          calculate_scissor_region (&clip_rect,
-                                    subpixel_compensation,
-                                    fb_width, fb_height,
-                                    &scissor_rect);
-
-          CLUTTER_NOTE (CLIPPING,
-                        "Stage clip pushed: x=%d, y=%d, width=%d, height=%d\n",
-                        scissor_rect.x,
-                        scissor_rect.y,
-                        scissor_rect.width,
-                        scissor_rect.height);
-
-          cogl_framebuffer_push_scissor_clip (fb,
-                                              scissor_rect.x,
-                                              scissor_rect.y,
-                                              scissor_rect.width,
-                                              scissor_rect.height);
-        }
-      else
-        {
-          cogl_framebuffer_push_region_clip (fb, fb_clip_region);
-        }
+      cogl_framebuffer_push_region_clip (fb, fb_clip_region);
 
       paint_stage (stage_cogl, view, redraw_clip);
 
@@ -822,77 +690,7 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
     {
       CLUTTER_NOTE (CLIPPING, "Unclipped stage paint\n");
 
-      /* If we are trying to debug redraw issues then we want to pass
-       * the redraw_clip so it can be visualized */
-      if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_DISABLE_CLIPPED_REDRAWS) &&
-          may_use_clipped_redraw &&
-          !clip_region_empty)
-        {
-          cairo_rectangle_int_t clip_rect;
-          cairo_rectangle_int_t scissor_rect;
-
-          cairo_region_get_extents (fb_clip_region, &clip_rect);
-
-          calculate_scissor_region (&clip_rect,
-                                    subpixel_compensation,
-                                    fb_width, fb_height,
-                                    &scissor_rect);
-
-          cogl_framebuffer_push_scissor_clip (fb,
-                                              scissor_rect.x,
-                                              scissor_rect.y,
-                                              scissor_rect.width,
-                                              scissor_rect.height);
-
-          paint_stage (stage_cogl, view, redraw_clip);
-
-          cogl_framebuffer_pop_clip (fb);
-        }
-      else
-        {
-          paint_stage (stage_cogl, view, redraw_clip);
-        }
-    }
-
-  cairo_region_get_extents (redraw_clip, &redraw_rect);
-
-  if (may_use_clipped_redraw &&
-      G_UNLIKELY ((clutter_paint_debug_flags & CLUTTER_DEBUG_REDRAWS)))
-    {
-      CoglContext *ctx = cogl_framebuffer_get_context (fb);
-      static CoglPipeline *outline = NULL;
-      ClutterActor *actor = CLUTTER_ACTOR (wrapper);
-      float x_1 = redraw_rect.x;
-      float x_2 = redraw_rect.x + redraw_rect.width;
-      float y_1 = redraw_rect.y;
-      float y_2 = redraw_rect.y + redraw_rect.height;
-      CoglVertexP2 quad[4] = {
-        { x_1, y_1 },
-        { x_2, y_1 },
-        { x_2, y_2 },
-        { x_1, y_2 }
-      };
-      CoglPrimitive *prim;
-      CoglMatrix modelview;
-
-      if (outline == NULL)
-        {
-          outline = cogl_pipeline_new (ctx);
-          cogl_pipeline_set_color4ub (outline, 0xff, 0x00, 0x00, 0xff);
-        }
-
-      prim = cogl_primitive_new_p2 (ctx,
-                                    COGL_VERTICES_MODE_LINE_LOOP,
-                                    4, /* n_vertices */
-                                    quad);
-
-      cogl_framebuffer_push_matrix (fb);
-      cogl_matrix_init_identity (&modelview);
-      _clutter_actor_apply_modelview_transform (actor, &modelview);
-      cogl_framebuffer_set_modelview_matrix (fb, &modelview);
-      cogl_framebuffer_draw_primitive (fb, outline, prim);
-      cogl_framebuffer_pop_matrix (fb);
-      cogl_object_unref (prim);
+      paint_stage (stage_cogl, view, redraw_clip);
     }
 
   /* XXX: It seems there will be a race here in that the stage
@@ -904,59 +702,56 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
    * artefacts.
    */
   if (use_clipped_redraw)
-    {
-      if (clip_region_empty)
-        {
-          do_swap_buffer = FALSE;
-        }
-      else
-        {
-          swap_region = cairo_region_copy (fb_clip_region);
-          do_swap_buffer = TRUE;
-        }
-    }
+    swap_region = cairo_region_copy (fb_clip_region);
   else
-    {
-      swap_region = cairo_region_create ();
-      do_swap_buffer = TRUE;
-    }
+    swap_region = cairo_region_create ();
 
   g_clear_pointer (&redraw_clip, cairo_region_destroy);
-  g_clear_pointer (&queued_redraw_clip, cairo_region_destroy);
   g_clear_pointer (&fb_clip_region, cairo_region_destroy);
 
-  if (do_swap_buffer)
+  COGL_TRACE_BEGIN_SCOPED (ClutterStageCoglRedrawViewSwapFramebuffer,
+                           "Paint (swap framebuffer)");
+
+  if (clutter_stage_view_get_onscreen (view) !=
+      clutter_stage_view_get_framebuffer (view))
     {
-      gboolean res;
-
-      COGL_TRACE_BEGIN_SCOPED (ClutterStageCoglRedrawViewSwapFramebuffer,
-                               "Paint (swap framebuffer)");
-
-      if (clutter_stage_view_get_onscreen (view) !=
-          clutter_stage_view_get_framebuffer (view))
-        {
-          cairo_region_t *transformed_swap_region;
-
-          transformed_swap_region =
-            transform_swap_region_to_onscreen (view, swap_region);
-          cairo_region_destroy (swap_region);
-          swap_region = transformed_swap_region;
-        }
-
-      res = swap_framebuffer (stage_window,
-                              view,
-                              swap_region,
-                              swap_with_damage,
-                              queued_redraw_clip);
+      cairo_region_t *transformed_swap_region;
 
+      transformed_swap_region =
+        transform_swap_region_to_onscreen (view, swap_region);
       cairo_region_destroy (swap_region);
+      swap_region = transformed_swap_region;
+    }
 
-      return res;
-    }
-  else
+  if (queued_redraw_clip)
     {
-      return FALSE;
+      paint_damage_region (stage_window, view,
+                           swap_region, queued_redraw_clip);
+      cairo_region_destroy (queued_redraw_clip);
     }
+
+  res = swap_framebuffer (stage_window,
+                          view,
+                          swap_region,
+                          swap_with_damage);
+
+  cairo_region_destroy (swap_region);
+
+  return res;
+}
+
+static void
+clutter_stage_cogl_scanout_view (ClutterStageCogl *stage_cogl,
+                                 ClutterStageView *view,
+                                 CoglScanout      *scanout)
+{
+  CoglFramebuffer *framebuffer = clutter_stage_view_get_framebuffer (view);
+  CoglOnscreen *onscreen;
+
+  g_return_if_fail (cogl_is_onscreen (framebuffer));
+
+  onscreen = COGL_ONSCREEN (framebuffer);
+  cogl_onscreen_direct_scanout (onscreen, scanout);
 }
 
 static void
@@ -971,11 +766,23 @@ clutter_stage_cogl_redraw (ClutterStageWindow *stage_window)
   for (l = _clutter_stage_window_get_views (stage_window); l; l = l->next)
     {
       ClutterStageView *view = l->data;
+      g_autoptr (CoglScanout) scanout = NULL;
 
       if (!clutter_stage_view_has_redraw_clip (view))
         continue;
 
-      swap_event |= clutter_stage_cogl_redraw_view (stage_window, view);
+      scanout = clutter_stage_view_take_scanout (view);
+      if (scanout)
+        {
+          clutter_stage_cogl_scanout_view (stage_cogl,
+                                           view,
+                                           scanout);
+          swap_event = TRUE;
+        }
+      else
+        {
+          swap_event |= clutter_stage_cogl_redraw_view (stage_window, view);
+        }
     }
 
   _clutter_stage_emit_after_paint (stage_cogl->wrapper);
@@ -1055,12 +862,31 @@ _clutter_stage_cogl_init (ClutterStageCogl *stage)
   stage->update_time = -1;
 }
 
+static void
+clutter_stage_view_cogl_finalize (GObject *object)
+{
+  ClutterStageViewCogl *view_cogl = CLUTTER_STAGE_VIEW_COGL (object);
+  ClutterStageViewCoglPrivate *view_priv =
+    clutter_stage_view_cogl_get_instance_private (view_cogl);
+
+  clutter_damage_history_free (view_priv->damage_history);
+
+  G_OBJECT_CLASS (clutter_stage_view_cogl_parent_class)->finalize (object);
+}
+
 static void
 clutter_stage_view_cogl_init (ClutterStageViewCogl *view_cogl)
 {
+  ClutterStageViewCoglPrivate *view_priv =
+    clutter_stage_view_cogl_get_instance_private (view_cogl);
+
+  view_priv->damage_history = clutter_damage_history_new ();
 }
 
 static void
 clutter_stage_view_cogl_class_init (ClutterStageViewCoglClass *klass)
 {
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = clutter_stage_view_cogl_finalize;
 }

clutter/clutter/deprecated/clutter-alpha.c

@@ -1,819 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *             Jorn Baayen  <jorn@openedhand.com>
- *             Emmanuele Bassi  <ebassi@openedhand.com>
- *             Tomas Frydrych <tf@openedhand.com>
- *
- * Copyright (C) 2006, 2007, 2008 OpenedHand
- * Copyright (C) 2009, 2010 Intel Corp.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * SECTION:clutter-alpha
- * @short_description: A class for calculating a value as a function of time
- *
- * #ClutterAlpha is a class for calculating an floating point value
- * dependent only on the position of a #ClutterTimeline.
- *
- * For newly written code, it is recommended to use the
- * #ClutterTimeline:progress-mode property of #ClutterTimeline, or the
- * clutter_timeline_set_progress_func() function instead of #ClutterAlpha.
- * The #ClutterAlpha class will be deprecated in the future, and will not
- * be available any more in the next major version of Clutter.
- *
- * A #ClutterAlpha binds a #ClutterTimeline to a progress function which
- * translates the time T into an adimensional factor alpha.
- *
- * You should provide a #ClutterTimeline and bind it to the #ClutterAlpha
- * instance using clutter_alpha_set_timeline(). You should also set an
- * "animation mode", by using the #ClutterAnimationMode values that
- * Clutter provides.
- *
- * Instead of a #ClutterAnimationMode you may provide a function returning
- * the alpha value depending on the progress of the timeline, using
- * clutter_alpha_set_func() or clutter_alpha_set_closure(). The alpha
- * function will be executed each time a new frame in the #ClutterTimeline
- * is reached.
- *
- * Since the alpha function is controlled by the timeline instance, you can
- * pause, stop or resume the #ClutterAlpha from calling the alpha function by
- * using the appropriate functions of the #ClutterTimeline object.
- *
- * #ClutterAlpha is available since Clutter 0.2.
- *
- * #ClutterAlpha is deprecated since Clutter 1.12. #ClutterTimeline and
- * the #ClutterTimeline:progress-mode property replace this whole class.
- *
- * ## ClutterAlpha custom properties for #ClutterScript
- *
- * #ClutterAlpha defines a custom `function` property for
- * #ClutterScript which allows to reference a custom alpha function
- * available in the source code. Setting the `function` property
- * is equivalent to calling clutter_alpha_set_func() with the
- * specified function name. No user data or #GDestroyNotify is
- * available to be passed.
- *
- * The following JSON fragment defines a #ClutterAlpha
- * using a #ClutterTimeline with id "sine-timeline" and an alpha
- * function called `my_sine_alpha`.
- *
- * |[
- * {
- *   "id" : "sine-alpha",
- *   "timeline" : {
- *     "id" : "sine-timeline",
- *     "duration" : 500,
- *     "loop" : true
- *   },
- *   "function" : "my_sine_alpha"
- * }
- * ]|
- */
-
-#include "clutter-build-config.h"
-
-#include <math.h>
-
-#include <gmodule.h>
-
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-
-#include "clutter-alpha.h"
-#include "clutter-debug.h"
-#include "clutter-enum-types.h"
-#include "clutter-easing.h"
-#include "clutter-main.h"
-#include "clutter-marshal.h"
-#include "clutter-private.h"
-#include "clutter-scriptable.h"
-#include "clutter-script-private.h"
-
-struct _ClutterAlphaPrivate
-{
-  ClutterTimeline *timeline;
-  guint timeline_new_frame_id;
-
-  gdouble alpha;
-
-  GClosure *closure;
-
-  ClutterAlphaFunc func;
-  gpointer user_data;
-  GDestroyNotify notify;
-
-  gulong mode;
-};
-
-enum
-{
-  PROP_0,
-  
-  PROP_TIMELINE,
-  PROP_ALPHA,
-  PROP_MODE,
-
-  PROP_LAST
-};
-
-static GParamSpec *obj_props[PROP_LAST];
-
-static void clutter_scriptable_iface_init (ClutterScriptableIface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (ClutterAlpha,
-                         clutter_alpha,
-                         G_TYPE_INITIALLY_UNOWNED,
-                         G_ADD_PRIVATE (ClutterAlpha)
-                         G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_SCRIPTABLE,
-                                                clutter_scriptable_iface_init));
-
-static void
-timeline_new_frame_cb (ClutterTimeline *timeline,
-                       guint            msecs,
-                       ClutterAlpha    *alpha)
-{
-  ClutterAlphaPrivate *priv = alpha->priv;
-
-  /* Update alpha value and notify */
-  priv->alpha = clutter_alpha_get_alpha (alpha);
-  g_object_notify_by_pspec (G_OBJECT (alpha), obj_props[PROP_ALPHA]);
-}
-
-static void 
-clutter_alpha_set_property (GObject      *object, 
-			    guint         prop_id,
-			    const GValue *value, 
-			    GParamSpec   *pspec)
-{
-  ClutterAlpha *alpha = CLUTTER_ALPHA (object);
-
-  switch (prop_id) 
-    {
-    case PROP_TIMELINE:
-      clutter_alpha_set_timeline (alpha, g_value_get_object (value));
-      break;
-
-    case PROP_MODE:
-      clutter_alpha_set_mode (alpha, g_value_get_ulong (value));
-      break;
-
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-  }
-}
-
-static void 
-clutter_alpha_get_property (GObject    *object, 
-			    guint       prop_id,
-			    GValue     *value, 
-			    GParamSpec *pspec)
-{
-  ClutterAlphaPrivate *priv = CLUTTER_ALPHA (object)->priv;
-
-  switch (prop_id) 
-    {
-    case PROP_TIMELINE:
-      g_value_set_object (value, priv->timeline);
-      break;
-
-    case PROP_ALPHA:
-      g_value_set_double (value, priv->alpha);
-      break;
-
-    case PROP_MODE:
-      g_value_set_ulong (value, priv->mode);
-      break;
-
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void 
-clutter_alpha_finalize (GObject *object)
-{
-  ClutterAlphaPrivate *priv = CLUTTER_ALPHA (object)->priv;
-
-  if (priv->notify != NULL)
-    priv->notify (priv->user_data);
-  else if (priv->closure != NULL)
-    g_closure_unref (priv->closure);
-
-  G_OBJECT_CLASS (clutter_alpha_parent_class)->finalize (object);
-}
-
-static void 
-clutter_alpha_dispose (GObject *object)
-{
-  ClutterAlpha *self = CLUTTER_ALPHA(object);
-
-  clutter_alpha_set_timeline (self, NULL);
-
-  G_OBJECT_CLASS (clutter_alpha_parent_class)->dispose (object);
-}
-
-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 == NULL))
-    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;
-}
-
-static void
-clutter_alpha_set_custom_property (ClutterScriptable *scriptable,
-                                   ClutterScript     *script,
-                                   const gchar       *name,
-                                   const GValue      *value)
-{
-  if (strncmp (name, "function", 8) == 0)
-    {
-      g_assert (G_VALUE_HOLDS (value, G_TYPE_POINTER));
-      if (g_value_get_pointer (value) != NULL)
-        {
-          clutter_alpha_set_func (CLUTTER_ALPHA (scriptable),
-                                  g_value_get_pointer (value),
-                                  NULL, NULL);
-        }
-    }
-  else
-    g_object_set_property (G_OBJECT (scriptable), name, value);
-}
-
-static gboolean
-clutter_alpha_parse_custom_node (ClutterScriptable *scriptable,
-                                 ClutterScript     *script,
-                                 GValue            *value,
-                                 const gchar       *name,
-                                 JsonNode          *node)
-{
-  if (strncmp (name, "function", 8) == 0)
-    {
-      const gchar *func_name = json_node_get_string (node);
-
-      g_value_init (value, G_TYPE_POINTER);
-      g_value_set_pointer (value, resolve_alpha_func (func_name));
-
-      return TRUE;
-    }
-
-  /* we need to do this because we use gulong in place
-   * of ClutterAnimationMode for ClutterAlpha:mode
-   */
-  if (strncmp (name, "mode", 4) == 0)
-    {
-      gulong mode;
-
-      mode = _clutter_script_resolve_animation_mode (node);
-
-      g_value_init (value, G_TYPE_ULONG);
-      g_value_set_ulong (value, mode);
-
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-static void
-clutter_scriptable_iface_init (ClutterScriptableIface *iface)
-{
-  iface->parse_custom_node = clutter_alpha_parse_custom_node;
-  iface->set_custom_property = clutter_alpha_set_custom_property;
-}
-
-static void
-clutter_alpha_class_init (ClutterAlphaClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->set_property = clutter_alpha_set_property;
-  object_class->get_property = clutter_alpha_get_property;
-  object_class->finalize     = clutter_alpha_finalize;
-  object_class->dispose      = clutter_alpha_dispose;
-
-  /**
-   * ClutterAlpha:timeline:
-   *
-   * A #ClutterTimeline instance used to drive the alpha function.
-   *
-   * Since: 0.2
-   *
-   * Deprecated: 1.12
-   */
-  obj_props[PROP_TIMELINE] =
-    g_param_spec_object ("timeline",
-                               P_("Timeline"),
-                               P_("Timeline used by the alpha"),
-                               CLUTTER_TYPE_TIMELINE,
-                               CLUTTER_PARAM_READWRITE);
-
-  /**
-   * ClutterAlpha:alpha:
-   *
-   * The alpha value as computed by the alpha function. The linear
-   * interval is 0.0 to 1.0, but the Alpha allows overshooting by
-   * one unit in each direction, so the valid interval is -1.0 to 2.0.
-   *
-   * Since: 0.2
-   * Deprecated: 1.12: Use #ClutterTimeline::new-frame and
-   *   clutter_timeline_get_progress() instead
-   */
-  obj_props[PROP_ALPHA] =
-    g_param_spec_double ("alpha",
-                               P_("Alpha value"),
-                               P_("Alpha value as computed by the alpha"),
-                               -1.0, 2.0,
-                               0.0,
-                               CLUTTER_PARAM_READABLE);
-
-  /**
-   * ClutterAlpha:mode:
-   *
-   * The progress function logical id - a value from the
-   * #ClutterAnimationMode enumeration.
-   *
-   * If %CLUTTER_CUSTOM_MODE is used then the function set using
-   * clutter_alpha_set_closure() or clutter_alpha_set_func()
-   * will be used.
-   *
-   * Since: 1.0
-   * Deprecated: 1.12: Use #ClutterTimeline:progress-mode
-   */
-  obj_props[PROP_MODE] =
-    g_param_spec_ulong ("mode",
-                              P_("Mode"),
-                              P_("Progress mode"),
-                              0, G_MAXULONG,
-                              CLUTTER_CUSTOM_MODE,
-                              G_PARAM_CONSTRUCT | CLUTTER_PARAM_READWRITE);
-
-  g_object_class_install_properties (object_class,
-                                     PROP_LAST,
-                                     obj_props);
-}
-
-static void
-clutter_alpha_init (ClutterAlpha *self)
-{
-  self->priv = clutter_alpha_get_instance_private (self);
-  self->priv->mode = CLUTTER_CUSTOM_MODE;
-  self->priv->alpha = 0.0;
-}
-
-/**
- * clutter_alpha_get_alpha:
- * @alpha: A #ClutterAlpha
- *
- * Query the current alpha value.
- *
- * Return Value: The current alpha value for the alpha
- *
- * Since: 0.2
- *
- * Deprecated: 1.12: Use clutter_timeline_get_progress()
- */
-gdouble
-clutter_alpha_get_alpha (ClutterAlpha *alpha)
-{
-  ClutterAlphaPrivate *priv;
-  gdouble retval = 0;
-
-  g_return_val_if_fail (CLUTTER_IS_ALPHA (alpha), 0);
-
-  priv = alpha->priv;
-
-  if (G_LIKELY (priv->func))
-    {
-      return priv->func (alpha, priv->user_data);
-    }
-  else if (priv->closure)
-    {
-      GValue params = G_VALUE_INIT;
-      GValue result_value = G_VALUE_INIT;
-
-      g_object_ref (alpha);
-
-      g_value_init (&result_value, G_TYPE_DOUBLE);
-
-      g_value_init (&params, CLUTTER_TYPE_ALPHA);
-      g_value_set_object (&params, alpha);
-
-      g_closure_invoke (priv->closure, &result_value, 1, &params, NULL);
-
-      retval = g_value_get_double (&result_value);
-
-      g_value_unset (&result_value);
-      g_value_unset (&params);
-
-      g_object_unref (alpha);
-    }
-
-  return retval;
-}
-
-/*
- * clutter_alpha_set_closure_internal:
- * @alpha: a #ClutterAlpha
- * @closure: a #GClosure
- *
- * Sets the @closure for @alpha. This function does not
- * set the #ClutterAlpha:mode property and does not emit
- * the #GObject::notify signal for it.
- */
-static inline void
-clutter_alpha_set_closure_internal (ClutterAlpha *alpha,
-                                    GClosure     *closure)
-{
-  ClutterAlphaPrivate *priv = alpha->priv;
-
-  if (priv->notify != NULL)
-    priv->notify (priv->user_data);
-  else if (priv->closure != NULL)
-    g_closure_unref (priv->closure);
-
-  priv->func = NULL;
-  priv->user_data = NULL;
-  priv->notify = NULL;
-
-  if (closure == NULL)
-    return;
-
-  /* need to take ownership of the closure before sinking it */
-  priv->closure = g_closure_ref (closure);
-  g_closure_sink (closure);
-
-  /* set the marshaller */
-  if (G_CLOSURE_NEEDS_MARSHAL (closure))
-    {
-      GClosureMarshal marshal = _clutter_marshal_DOUBLE__VOID;
-
-      g_closure_set_marshal (priv->closure, marshal);
-    }
-}
-
-/**
- * clutter_alpha_set_closure:
- * @alpha: A #ClutterAlpha
- * @closure: A #GClosure
- *
- * Sets the #GClosure used to compute the alpha value at each
- * frame of the #ClutterTimeline bound to @alpha.
- *
- * Since: 0.8
- *
- * Deprecated: 1.12: Use clutter_timeline_set_progress_func()
- */
-void
-clutter_alpha_set_closure (ClutterAlpha *alpha,
-                           GClosure     *closure)
-{
-  ClutterAlphaPrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_ALPHA (alpha));
-  g_return_if_fail (closure != NULL);
-
-  priv = alpha->priv;
-
-  clutter_alpha_set_closure_internal (alpha, closure);
-
-  priv->mode = CLUTTER_CUSTOM_MODE;
-  g_object_notify_by_pspec (G_OBJECT (alpha), obj_props[PROP_MODE]);
-}
-
-/**
- * clutter_alpha_set_func:
- * @alpha: A #ClutterAlpha
- * @func: A #ClutterAlphaFunc
- * @data: user data to be passed to the alpha function, or %NULL
- * @destroy: notify function used when disposing the alpha function
- *
- * Sets the #ClutterAlphaFunc function used to compute
- * the alpha value at each frame of the #ClutterTimeline
- * bound to @alpha.
- *
- * This function will not register @func as a global alpha function.
- *
- * Since: 0.2
- *
- * Deprecated: 1.12: Use clutter_timeline_set_progress_func()
- */
-void
-clutter_alpha_set_func (ClutterAlpha    *alpha,
-		        ClutterAlphaFunc func,
-                        gpointer         data,
-                        GDestroyNotify   destroy)
-{
-  ClutterAlphaPrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_ALPHA (alpha));
-  g_return_if_fail (func != NULL);
-
-  priv = alpha->priv;
-
-  if (priv->notify != NULL)
-    {
-      priv->notify (priv->user_data);
-    }
-  else if (priv->closure != NULL)
-    {
-      g_closure_unref (priv->closure);
-      priv->closure = NULL;
-    }
-
-  priv->func = func;
-  priv->user_data = data;
-  priv->notify = destroy;
-
-  priv->mode = CLUTTER_CUSTOM_MODE;
-
-  g_object_notify_by_pspec (G_OBJECT (alpha), obj_props[PROP_MODE]);
-}
-
-/**
- * clutter_alpha_set_timeline:
- * @alpha: A #ClutterAlpha
- * @timeline: A #ClutterTimeline
- *
- * Binds @alpha to @timeline.
- *
- * Since: 0.2
- *
- * Deprecated: 1.12: Use #ClutterTimeline directly
- */
-void
-clutter_alpha_set_timeline (ClutterAlpha    *alpha,
-                            ClutterTimeline *timeline)
-{
-  ClutterAlphaPrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_ALPHA (alpha));
-  g_return_if_fail (timeline == NULL || CLUTTER_IS_TIMELINE (timeline));
-  
-  priv = alpha->priv;
-
-  if (priv->timeline == timeline)
-    return;
-
-  if (priv->timeline)
-    {
-      g_signal_handlers_disconnect_by_func (priv->timeline,
-                                            timeline_new_frame_cb,
-                                            alpha);
-
-      g_object_unref (priv->timeline);
-      priv->timeline = NULL;
-    }
-
-  if (timeline)
-    {
-      priv->timeline = g_object_ref (timeline);
-
-      g_signal_connect (priv->timeline, "new-frame",
-                        G_CALLBACK (timeline_new_frame_cb),
-                        alpha);
-    }
-
-  g_object_notify_by_pspec (G_OBJECT (alpha), obj_props[PROP_TIMELINE]);
-}
-
-/**
- * clutter_alpha_get_timeline:
- * @alpha: A #ClutterAlpha
- *
- * Gets the #ClutterTimeline bound to @alpha.
- *
- * Return value: (transfer none): a #ClutterTimeline instance
- *
- * Since: 0.2
- *
- * Deprecated: 1.12: Use #ClutterTimeline directlry
- */
-ClutterTimeline *
-clutter_alpha_get_timeline (ClutterAlpha *alpha)
-{
-  g_return_val_if_fail (CLUTTER_IS_ALPHA (alpha), NULL);
-
-  return alpha->priv->timeline;
-}
-
-/**
- * clutter_alpha_new:
- * 
- * Creates a new #ClutterAlpha instance.  You must set a function
- * to compute the alpha value using clutter_alpha_set_func() and
- * bind a #ClutterTimeline object to the #ClutterAlpha instance
- * using clutter_alpha_set_timeline().
- *
- * Return value: the newly created empty #ClutterAlpha instance.
- *
- * Since: 0.2
- *
- * Deprecated: 1.12: Use #ClutterTimeline instead
- */
-ClutterAlpha *
-clutter_alpha_new (void)
-{
-  return g_object_new (CLUTTER_TYPE_ALPHA, NULL);
-}
-
-/**
- * clutter_alpha_new_full:
- * @timeline: #ClutterTimeline timeline
- * @mode: animation mode
- *
- * Creates a new #ClutterAlpha instance and sets the timeline
- * and animation mode.
- *
- * See also clutter_alpha_set_timeline() and clutter_alpha_set_mode().
- *
- * Return Value: the newly created #ClutterAlpha
- *
- * Since: 1.0
- *
- * Deprecated: 1.12: Use #ClutterTimeline instead
- */
-ClutterAlpha *
-clutter_alpha_new_full (ClutterTimeline *timeline,
-                        gulong           mode)
-{
-  g_return_val_if_fail (CLUTTER_IS_TIMELINE (timeline), NULL);
-  g_return_val_if_fail (mode != CLUTTER_ANIMATION_LAST, NULL);
-
-  return g_object_new (CLUTTER_TYPE_ALPHA,
-                       "timeline", timeline,
-                       "mode", mode,
-                       NULL);
-}
-
-/**
- * clutter_alpha_get_mode:
- * @alpha: a #ClutterAlpha
- *
- * Retrieves the #ClutterAnimationMode used by @alpha.
- *
- * Return value: the animation mode
- *
- * Since: 1.0
- *
- * Deprecated: 1.12: Use #ClutterTimeline instead
- */
-gulong
-clutter_alpha_get_mode (ClutterAlpha *alpha)
-{
-  g_return_val_if_fail (CLUTTER_IS_ALPHA (alpha), CLUTTER_CUSTOM_MODE);
-
-  return alpha->priv->mode;
-}
-
-typedef struct _AlphaData {
-  guint closure_set : 1;
-
-  ClutterAlphaFunc func;
-  gpointer data;
-
-  GClosure *closure;
-} AlphaData;
-
-static GPtrArray *clutter_alphas = NULL;
-
-static gdouble
-clutter_alpha_easing_func (ClutterAlpha *alpha,
-                           gpointer      data G_GNUC_UNUSED)
-{
-  ClutterAlphaPrivate *priv = alpha->priv;
-  ClutterTimeline *timeline = priv->timeline;
-  gdouble t, d;
-
-  if (G_UNLIKELY (priv->timeline == NULL))
-    return 0.0;
-
-  t = clutter_timeline_get_elapsed_time (timeline);
-  d = clutter_timeline_get_duration (timeline);
-
-  return clutter_easing_for_mode (priv->mode, t, d);
-}
-
-/**
- * clutter_alpha_set_mode:
- * @alpha: a #ClutterAlpha
- * @mode: a #ClutterAnimationMode
- *
- * Sets the progress function of @alpha using the symbolic value
- * of @mode, as taken by the #ClutterAnimationMode enumeration.
- *
- * Since: 1.0
- *
- * Deprecated: 1.12: Use #ClutterTimeline and
- *   clutter_timeline_set_progress_mode() instead
- */
-void
-clutter_alpha_set_mode (ClutterAlpha *alpha,
-                        gulong        mode)
-{
-  ClutterAlphaPrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_ALPHA (alpha));
-  g_return_if_fail (mode != CLUTTER_ANIMATION_LAST);
-
-  priv = alpha->priv;
-
-  if (mode == CLUTTER_CUSTOM_MODE)
-    {
-      priv->mode = mode;
-    }
-  else if (mode < CLUTTER_ANIMATION_LAST)
-    {
-      if (priv->mode == mode)
-        return;
-
-      /* sanity check to avoid getting an out of sync
-       * enum/function mapping
-       */
-      g_assert (clutter_get_easing_func_for_mode (mode) != NULL);
-
-      clutter_alpha_set_closure_internal (alpha, NULL);
-
-      priv->mode = mode;
-
-      CLUTTER_NOTE (ANIMATION, "New easing mode '%s'[%lu]\n",
-                    clutter_get_easing_name_for_mode (priv->mode),
-                    priv->mode);
-
-      priv->func = clutter_alpha_easing_func;
-      priv->user_data = NULL;
-      priv->notify = NULL;
-    }
-  else if (mode > CLUTTER_ANIMATION_LAST)
-    {
-      AlphaData *alpha_data = NULL;
-      gulong real_index = 0;
-
-      if (priv->mode == mode)
-        return;
-
-      if (G_UNLIKELY (clutter_alphas == NULL))
-        {
-          g_warning ("No alpha functions defined for ClutterAlpha to use. ");
-          return;
-        }
-
-      real_index = mode - CLUTTER_ANIMATION_LAST - 1;
-
-      alpha_data = g_ptr_array_index (clutter_alphas, real_index);
-      if (G_UNLIKELY (alpha_data == NULL))
-        {
-          g_warning ("No alpha function registered for mode %lu.",
-                     mode);
-          return;
-        }
-
-      if (alpha_data->closure_set)
-        clutter_alpha_set_closure (alpha, alpha_data->closure);
-      else
-        {
-          clutter_alpha_set_closure_internal (alpha, NULL);
-
-          priv->func = alpha_data->func;
-          priv->user_data = alpha_data->data;
-          priv->notify = NULL;
-        }
-
-      priv->mode = mode;
-    }
-  else
-    g_assert_not_reached ();
-
-  g_object_notify_by_pspec (G_OBJECT (alpha), obj_props[PROP_MODE]);
-}

clutter/clutter/deprecated/clutter-alpha.h

@@ -1,138 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *             Jorn Baayen  <jorn@openedhand.com>
- *             Emmanuele Bassi  <ebassi@openedhand.com>
- *             Tomas Frydrych <tf@openedhand.com>
- *
- * Copyright (C) 2006, 2007, 2008 OpenedHand
- * 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/>.
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_ALPHA_H__
-#define __CLUTTER_ALPHA_H__
-
-#include <clutter/clutter-timeline.h>
-#include <clutter/clutter-types.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_ALPHA              (clutter_alpha_get_type ())
-#define CLUTTER_ALPHA(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ALPHA, ClutterAlpha))
-#define CLUTTER_ALPHA_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_ALPHA, ClutterAlphaClass))
-#define CLUTTER_IS_ALPHA(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ALPHA))
-#define CLUTTER_IS_ALPHA_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_ALPHA))
-#define CLUTTER_ALPHA_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_ALPHA, ClutterAlphaClass))
-
-typedef struct _ClutterAlphaClass       ClutterAlphaClass;
-typedef struct _ClutterAlphaPrivate     ClutterAlphaPrivate;
-
-/**
- * ClutterAlphaFunc:
- * @alpha: a #ClutterAlpha
- * @user_data: user data passed to the function
- *
- * A function returning a value depending on the position of
- * the #ClutterTimeline bound to @alpha.
- *
- * Return value: a floating point value
- *
- * Since: 0.2
- *
- * Deprecated: 1.12: Use #ClutterTimelineProgressFunc instead.
- */
-typedef gdouble (*ClutterAlphaFunc) (ClutterAlpha *alpha,
-                                     gpointer      user_data); 
-
-/**
- * ClutterAlpha:
- *
- * #ClutterAlpha combines a #ClutterTimeline and a function.
- * The contents of the #ClutterAlpha structure are private and should
- * only be accessed using the provided API.
- *
- * Since: 0.2
- *
- * Deprecated: 1.12: Use #ClutterTimeline instead
- */
-struct _ClutterAlpha
-{
-  /*< private >*/
-  GInitiallyUnowned parent;
-
-  ClutterAlphaPrivate *priv;
-};
-
-/**
- * ClutterAlphaClass:
- *
- * Base class for #ClutterAlpha
- *
- * Since: 0.2
- *
- * Deprecated: 1.12: Use #ClutterTimeline instead
- */
-struct _ClutterAlphaClass
-{
-  /*< private >*/
-  GInitiallyUnownedClass parent_class;
-  
-  void (*_clutter_alpha_1) (void);
-  void (*_clutter_alpha_2) (void);
-  void (*_clutter_alpha_3) (void);
-  void (*_clutter_alpha_4) (void);
-  void (*_clutter_alpha_5) (void);
-}; 
-
-CLUTTER_DEPRECATED
-GType clutter_alpha_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED
-ClutterAlpha *   clutter_alpha_new              (void);
-CLUTTER_DEPRECATED
-ClutterAlpha *   clutter_alpha_new_full         (ClutterTimeline  *timeline,
-                                                 gulong            mode);
-CLUTTER_DEPRECATED
-gdouble          clutter_alpha_get_alpha        (ClutterAlpha     *alpha);
-CLUTTER_DEPRECATED
-void             clutter_alpha_set_func         (ClutterAlpha     *alpha,
-                                                 ClutterAlphaFunc  func,
-                                                 gpointer          data,
-                                                 GDestroyNotify    destroy);
-CLUTTER_DEPRECATED
-void             clutter_alpha_set_closure      (ClutterAlpha     *alpha,
-                                                 GClosure         *closure);
-CLUTTER_DEPRECATED
-void             clutter_alpha_set_timeline     (ClutterAlpha     *alpha,
-                                                 ClutterTimeline  *timeline);
-CLUTTER_DEPRECATED
-ClutterTimeline *clutter_alpha_get_timeline     (ClutterAlpha     *alpha);
-CLUTTER_DEPRECATED
-void             clutter_alpha_set_mode         (ClutterAlpha     *alpha,
-                                                 gulong            mode);
-CLUTTER_DEPRECATED
-gulong           clutter_alpha_get_mode         (ClutterAlpha     *alpha);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_ALPHA_H__ */

clutter/clutter/deprecated/clutter-animation.h

@@ -1,152 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Copyright (C) 2008  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>
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_ANIMATION_H__
-#define __CLUTTER_ANIMATION_H__
-
-#include <clutter/clutter-types.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_ANIMATION                  (clutter_animation_get_type ())
-#define CLUTTER_ANIMATION(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ANIMATION, ClutterAnimation))
-#define CLUTTER_IS_ANIMATION(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ANIMATION))
-#define CLUTTER_ANIMATION_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_ANIMATION, ClutterAnimationClass))
-#define CLUTTER_IS_ANIMATION_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_ANIMATION))
-#define CLUTTER_ANIMATION_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_ANIMATION, ClutterAnimationClass))
-
-typedef struct _ClutterAnimationPrivate         ClutterAnimationPrivate;
-typedef struct _ClutterAnimationClass           ClutterAnimationClass;
-
-/**
- * ClutterAnimation:
- *
- * The #ClutterAnimation structure contains only private data and should
- * be accessed using the provided functions.
- *
- * Since: 1.0
- *
- * Deprecated: 1.12: Use the implicit animation on #ClutterActor
- */
-struct _ClutterAnimation
-{
-  /*< private >*/
-  GObject parent_instance;
-
-  ClutterAnimationPrivate *priv;
-};
-
-/**
- * ClutterAnimationClass:
- * @started: class handler for the #ClutterAnimation::started signal
- * @completed: class handler for the #ClutterAnimation::completed signal
- *
- * The #ClutterAnimationClass structure contains only private data and
- * should be accessed using the provided functions.
- *
- * Since: 1.0
- *
- * Deprecated: 1.12: Use the implicit animation on #ClutterActor
- */
-struct _ClutterAnimationClass
-{
-  /*< private >*/
-  GObjectClass parent_class;
-
-  /*< public >*/
-  void (* started)   (ClutterAnimation *animation);
-  void (* completed) (ClutterAnimation *animation);
-
-  /*< private >*/
-  /* 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);
-  void (*_clutter_reserved7) (void);
-  void (*_clutter_reserved8) (void);
-};
-
-CLUTTER_DEPRECATED
-GType clutter_animation_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED_FOR(clutter_property_transition_new)
-ClutterAnimation *      clutter_animation_new                   (void);
-
-CLUTTER_DEPRECATED_FOR(clutter_transition_set_animatable)
-void                    clutter_animation_set_object            (ClutterAnimation     *animation,
-                                                                 GObject              *object);
-CLUTTER_DEPRECATED_FOR(clutter_timeline_set_progress_mode)
-void                    clutter_animation_set_mode              (ClutterAnimation     *animation,
-                                                                 gulong                mode);
-CLUTTER_DEPRECATED_FOR(clutter_timeline_get_progress_mode)
-gulong                  clutter_animation_get_mode              (ClutterAnimation     *animation);
-CLUTTER_DEPRECATED_FOR(clutter_timeline_set_duration)
-void                    clutter_animation_set_duration          (ClutterAnimation     *animation,
-                                                                 guint                 msecs);
-CLUTTER_DEPRECATED_FOR(clutter_timeline_get_duration)
-guint                   clutter_animation_get_duration          (ClutterAnimation     *animation);
-CLUTTER_DEPRECATED_FOR(clutter_timeline_set_repeat_count)
-void                    clutter_animation_set_loop              (ClutterAnimation     *animation,
-                                                                 gboolean              loop);
-CLUTTER_DEPRECATED_FOR(clutter_timeline_get_repeat_count)
-gboolean                clutter_animation_get_loop              (ClutterAnimation     *animation);
-CLUTTER_DEPRECATED
-void                    clutter_animation_set_timeline          (ClutterAnimation     *animation,
-                                                                 ClutterTimeline      *timeline);
-CLUTTER_DEPRECATED
-ClutterTimeline *       clutter_animation_get_timeline          (ClutterAnimation     *animation);
-CLUTTER_DEPRECATED
-gboolean                clutter_animation_has_property          (ClutterAnimation     *animation,
-                                                                 const gchar          *property_name);
-CLUTTER_DEPRECATED
-ClutterInterval     *   clutter_animation_get_interval          (ClutterAnimation     *animation,
-                                                                 const gchar          *property_name);
-
-/*
- * ClutterActor API
- */
-
-CLUTTER_DEPRECATED
-ClutterAnimation *      clutter_actor_animate                   (ClutterActor         *actor,
-                                                                 gulong                mode,
-                                                                 guint                 duration,
-                                                                 const gchar          *first_property_name,
-                                                                 ...) G_GNUC_NULL_TERMINATED;
-CLUTTER_DEPRECATED
-ClutterAnimation *      clutter_actor_animate_with_timeline     (ClutterActor         *actor,
-                                                                 gulong                mode,
-                                                                 ClutterTimeline      *timeline,
-                                                                 const gchar          *first_property_name,
-                                                                 ...) G_GNUC_NULL_TERMINATED;
-
-G_END_DECLS
-
-#endif /* __CLUTTER_ANIMATION_DEPRECATED_H__ */

clutter/clutter/deprecated/clutter-group.c

@@ -333,21 +333,20 @@ clutter_group_real_get_preferred_height (ClutterActor *actor,
 
 static void
 clutter_group_real_allocate (ClutterActor           *actor,
-                             const ClutterActorBox  *allocation,
-                             ClutterAllocationFlags  flags)
+                             const ClutterActorBox  *allocation)
 {
   ClutterGroupPrivate *priv = CLUTTER_GROUP (actor)->priv;
   ClutterActorClass *klass;
 
   klass = CLUTTER_ACTOR_CLASS (clutter_group_parent_class);
-  klass->allocate (actor, allocation, flags);
+  klass->allocate (actor, allocation);
 
   if (priv->children == NULL)
     return;
 
   clutter_layout_manager_allocate (priv->layout,
                                    CLUTTER_CONTAINER (actor),
-                                   allocation, flags);
+                                   allocation);
 }
 
 static void

clutter/clutter/deprecated/clutter-state.h

@@ -1,147 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Øyvind Kolås <pippin@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_STATE_H__
-#define __CLUTTER_STATE_H__
-
-#include <clutter/clutter-types.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_STATE_KEY          (clutter_state_key_get_type ())
-#define CLUTTER_TYPE_STATE              (clutter_state_get_type ())
-#define CLUTTER_STATE(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_STATE, ClutterState))
-#define CLUTTER_STATE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_STATE, ClutterStateClass))
-#define CLUTTER_IS_STATE(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_STATE))
-#define CLUTTER_IS_STATE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_STATE))
-#define CLUTTER_STATE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_STATE, ClutterStateClass))
-
-typedef struct _ClutterStatePrivate ClutterStatePrivate;
-typedef struct _ClutterStateClass   ClutterStateClass;
-
-/**
- * ClutterStateKey:
- *
- * #ClutterStateKey is an opaque structure whose
- * members cannot be accessed directly
- *
- * Since: 1.4
- */
-typedef struct _ClutterStateKey     ClutterStateKey;
-
-/**
- * ClutterState:
- *
- * The #ClutterState structure contains only
- * private data and should be accessed using the provided API
- *
- * Since: 1.4
- */
-struct _ClutterState
-{
-  /*< private >*/
-  GObject        parent;
-  ClutterStatePrivate *priv;
-};
-
-/**
- * ClutterStateClass:
- * @completed: class handler for the #ClutterState::completed signal
- *
- * The #ClutterStateClass structure contains
- * only private data
- *
- * Since: 1.4
- *
- * Deprecated: 1.12
- */
-struct _ClutterStateClass
-{
-  /*< private >*/
-  GObjectClass parent_class;
-
-  /*< public >*/
-  void (* completed) (ClutterState *state);
-
-  /*< private >*/
-  /* padding for future expansion */
-  gpointer _padding_dummy[8];
-};
-
-CLUTTER_DEPRECATED
-GType clutter_state_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED
-ClutterState    *clutter_state_new            (void);
-
-
-CLUTTER_DEPRECATED
-ClutterTimeline * clutter_state_set_state     (ClutterState    *state,
-                                               const gchar     *target_state_name);
-CLUTTER_DEPRECATED
-ClutterTimeline * clutter_state_warp_to_state (ClutterState    *state,
-                                               const gchar     *target_state_name);
-CLUTTER_DEPRECATED
-ClutterState *    clutter_state_set_key       (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name,
-                                               GObject         *object,
-                                               const gchar     *property_name,
-                                               guint            mode,
-                                               const GValue    *value,
-                                               gdouble          pre_delay,
-                                               gdouble          post_delay);
-CLUTTER_DEPRECATED
-void              clutter_state_set_duration  (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name,
-                                               guint            duration);
-CLUTTER_DEPRECATED
-guint             clutter_state_get_duration  (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name);
-CLUTTER_DEPRECATED
-void              clutter_state_set           (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name,
-                                               gpointer         first_object,
-                                               const gchar     *first_property_name,
-                                               gulong           first_mode,
-                                                ...) G_GNUC_NULL_TERMINATED;
-CLUTTER_DEPRECATED
-GList           * clutter_state_get_states    (ClutterState    *state);
-CLUTTER_DEPRECATED
-const gchar *     clutter_state_get_state     (ClutterState    *state);
-
-/*
- * ClutterStateKey
- */
-
-CLUTTER_DEPRECATED
-GType                 clutter_state_key_get_type              (void) G_GNUC_CONST;
-CLUTTER_DEPRECATED
-GType                 clutter_state_key_get_property_type     (const ClutterStateKey *key);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_STATE_H__ */

clutter/clutter/deprecated/clutter-timeline.h

@@ -26,16 +26,6 @@
 
 G_BEGIN_DECLS
 
-CLUTTER_DEPRECATED_FOR(clutter_timeline_new)
-ClutterTimeline *               clutter_timeline_clone                  (ClutterTimeline          *timeline);
-
-CLUTTER_DEPRECATED_FOR(clutter_timeline_set_repeat_count)
-void                            clutter_timeline_set_loop               (ClutterTimeline          *timeline,
-                                                                         gboolean                  loop);
-
-CLUTTER_DEPRECATED_FOR(clutter_timeline_get_repeat_count)
-gboolean                        clutter_timeline_get_loop               (ClutterTimeline          *timeline);
-
 G_END_DECLS
 
 #endif /* __CLUTTER_TIMELINE_PRIVATE_H__ */

clutter/clutter/meson.build

@@ -114,6 +114,7 @@ clutter_sources = [
   'clutter-constraint.c',
   'clutter-container.c',
   'clutter-content.c',
+  'clutter-damage-history.c',
   'clutter-deform-effect.c',
   'clutter-desaturate-effect.c',
   'clutter-effect.c',
@@ -185,6 +186,7 @@ clutter_private_headers = [
   'clutter-bezier.h',
   'clutter-constraint-private.h',
   'clutter-content-private.h',
+  'clutter-damage-history.h',
   'clutter-debug.h',
   'clutter-easing.h',
   'clutter-effect-private.h',
@@ -219,24 +221,18 @@ clutter_nonintrospected_sources = [
 
 clutter_deprecated_headers = [
   'deprecated/clutter-actor.h',
-  'deprecated/clutter-alpha.h',
-  'deprecated/clutter-animation.h',
   'deprecated/clutter-box.h',
   'deprecated/clutter-container.h',
   'deprecated/clutter-group.h',
   'deprecated/clutter-rectangle.h',
   'deprecated/clutter-stage.h',
-  'deprecated/clutter-state.h',
   'deprecated/clutter-timeline.h',
 ]
 
 clutter_deprecated_sources = [
-  'deprecated/clutter-alpha.c',
-  'deprecated/clutter-animation.c',
   'deprecated/clutter-box.c',
   'deprecated/clutter-group.c',
   'deprecated/clutter-rectangle.c',
-  'deprecated/clutter-state.c',
 ]
 
 clutter_backend_sources = []
@@ -337,35 +333,20 @@ clutter_build_config_h = configure_file(
 )
 clutter_built_private_headers += clutter_build_config_h
 
-clutter_config_defines = []
+cdata = configuration_data()
 if have_wayland
-  clutter_config_defines += [
-    '#define CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT 1',
-  ]
+  cdata.set10('CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT', true)
 endif
 if have_x11
-  clutter_config_defines += [
-    '#define CLUTTER_WINDOWING_X11 "x11"',
-    '#define CLUTTER_INPUT_X11 "x11"',
-    '#define CLUTTER_WINDOWING_GLX "glx"',
-  ]
+  cdata.set_quoted('CLUTTER_WINDOWING_X11', 'x11')
+  cdata.set_quoted('CLUTTER_INPUT_X11', 'x11')
+  cdata.set_quoted('CLUTTER_WINDOWING_GLX', 'glx')
 endif
 if have_native_backend
-  clutter_config_defines += [
-    '#define CLUTTER_WINDOWING_EGL "eglnative"',
-    '#define CLUTTER_INPUT_EVDEV "evdev"',
-  ]
+  cdata.set_quoted('CLUTTER_WINDOWING_EGL', 'eglnative')
+  cdata.set_quoted('CLUTTER_INPUT_EVDEV', 'evdev')
 endif
-clutter_config_defines += [
-  '#define CLUTTER_INPUT_NULL "null"',
-]
-clutter_config_defines_string = ''
-foreach clutter_config_define : clutter_config_defines
-  clutter_config_defines_string += clutter_config_define + '\n'
-endforeach
-
-cdata = configuration_data()
-cdata.set('CLUTTER_CONFIG_DEFINES', clutter_config_defines_string)
+cdata.set_quoted('CLUTTER_INPUT_NULL', 'null')
 
 clutter_config_h = configure_file(
   input: 'clutter-config.h.in',

cogl/cogl-pango/cogl-pango-fontmap.c

@@ -74,7 +74,7 @@ PangoFontMap *
 cogl_pango_font_map_new (void)
 {
   PangoFontMap *fm = pango_cairo_font_map_new ();
-  CoglPangoFontMapPriv *priv = g_new0 (CoglPangoFontMapPriv, 1);
+  g_autofree CoglPangoFontMapPriv *priv = g_new0 (CoglPangoFontMapPriv, 1);
 
   _COGL_GET_CONTEXT (context, NULL);
 
@@ -85,7 +85,7 @@ cogl_pango_font_map_new (void)
    * for now. */
   g_object_set_qdata_full (G_OBJECT (fm),
                            cogl_pango_font_map_get_priv_key (),
-                           priv,
+                           g_steal_pointer (&priv),
                            free_priv);
 
   return fm;

cogl/cogl/cogl-atlas-texture.c

@@ -48,7 +48,6 @@
 #include "cogl1-context.h"
 #include "cogl-sub-texture.h"
 #include "cogl-gtype-private.h"
-#include "driver/gl/cogl-pipeline-opengl-private.h"
 #include "driver/gl/cogl-texture-gl-private.h"
 
 #include <stdlib.h>

cogl/cogl/cogl-attribute.c

@@ -51,11 +51,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-/* This isn't defined in the GLES headers */
-#ifndef GL_UNSIGNED_INT
-#define GL_UNSIGNED_INT 0x1405
-#endif
-
 static void _cogl_attribute_free (CoglAttribute *attribute);
 
 COGL_OBJECT_DEFINE (Attribute, attribute);

cogl/cogl/cogl-blit.c

@@ -158,7 +158,7 @@ _cogl_blit_framebuffer_begin (CoglBlitData *data)
      supported. */
   if ((_cogl_texture_get_format (data->src_tex) & COGL_PREMULT_BIT) !=
       (_cogl_texture_get_format (data->dst_tex) & COGL_PREMULT_BIT) ||
-      !_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_BLIT_FRAMEBUFFER))
+      !cogl_has_feature (ctx, COGL_FEATURE_ID_BLIT_FRAMEBUFFER))
     return FALSE;
 
   dst_offscreen = _cogl_offscreen_new_with_texture_full

cogl/cogl/cogl-boxed-value.c

@@ -34,7 +34,6 @@
 
 #include "cogl-boxed-value.h"
 #include "cogl-context-private.h"
-#include "driver/gl/cogl-util-gl-private.h"
 
 gboolean
 _cogl_boxed_value_equal (const CoglBoxedValue *bva,
@@ -286,90 +285,5 @@ _cogl_boxed_value_set_uniform (CoglContext *ctx,
                                GLint location,
                                const CoglBoxedValue *value)
 {
-  switch (value->type)
-    {
-    case COGL_BOXED_NONE:
-      break;
-
-    case COGL_BOXED_INT:
-      {
-        const int *ptr;
-
-        if (value->count == 1)
-          ptr = value->v.int_value;
-        else
-          ptr = value->v.int_array;
-
-        switch (value->size)
-          {
-          case 1:
-            GE( ctx, glUniform1iv (location, value->count, ptr) );
-            break;
-          case 2:
-            GE( ctx, glUniform2iv (location, value->count, ptr) );
-            break;
-          case 3:
-            GE( ctx, glUniform3iv (location, value->count, ptr) );
-            break;
-          case 4:
-            GE( ctx, glUniform4iv (location, value->count, ptr) );
-            break;
-          }
-      }
-      break;
-
-    case COGL_BOXED_FLOAT:
-      {
-        const float *ptr;
-
-        if (value->count == 1)
-          ptr = value->v.float_value;
-        else
-          ptr = value->v.float_array;
-
-        switch (value->size)
-          {
-          case 1:
-            GE( ctx, glUniform1fv (location, value->count, ptr) );
-            break;
-          case 2:
-            GE( ctx, glUniform2fv (location, value->count, ptr) );
-            break;
-          case 3:
-            GE( ctx, glUniform3fv (location, value->count, ptr) );
-            break;
-          case 4:
-            GE( ctx, glUniform4fv (location, value->count, ptr) );
-            break;
-          }
-      }
-      break;
-
-    case COGL_BOXED_MATRIX:
-      {
-        const float *ptr;
-
-        if (value->count == 1)
-          ptr = value->v.matrix;
-        else
-          ptr = value->v.float_array;
-
-        switch (value->size)
-          {
-          case 2:
-            GE( ctx, glUniformMatrix2fv (location, value->count,
-                                         FALSE, ptr) );
-            break;
-          case 3:
-            GE( ctx, glUniformMatrix3fv (location, value->count,
-                                         FALSE, ptr) );
-            break;
-          case 4:
-            GE( ctx, glUniformMatrix4fv (location, value->count,
-                                         FALSE, ptr) );
-            break;
-          }
-      }
-      break;
-    }
+  ctx->driver_vtable->set_uniform (ctx, location, value);
 }

cogl/cogl/cogl-context-private.h

@@ -46,7 +46,6 @@
 #include "cogl-pipeline-cache.h"
 #include "cogl-texture-2d.h"
 #include "cogl-sampler-cache-private.h"
-#include "cogl-gpu-info-private.h"
 #include "cogl-gl-header.h"
 #include "cogl-framebuffer-private.h"
 #include "cogl-onscreen-private.h"
@@ -70,14 +69,12 @@ struct _CoglContext
 
   CoglDriver driver;
 
-  /* Information about the GPU and driver which we can use to
-     determine certain workarounds */
-  CoglGpuInfo gpu;
-
   /* vtables for the driver functions */
   const CoglDriverVtable *driver_vtable;
   const CoglTextureDriver *texture_driver;
 
+  void *driver_context;
+
   int glsl_major;
   int glsl_minor;
 
@@ -124,9 +121,6 @@ struct _CoglContext
 
   CoglMatrixEntry identity_entry;
 
-  GArray           *texture_units;
-  int               active_texture_unit;
-
   /* Only used for comparing other pipelines when reading pixels. */
   CoglPipeline     *opaque_color_pipeline;
 
@@ -315,18 +309,4 @@ void
 _cogl_context_set_current_modelview_entry (CoglContext *context,
                                            CoglMatrixEntry *entry);
 
-/*
- * _cogl_context_get_gl_extensions:
- * @context: A CoglContext
- *
- * Return value: a NULL-terminated array of strings representing the
- *   supported extensions by the current driver. This array is owned
- *   by the caller and should be freed with g_strfreev().
- */
-char **
-_cogl_context_get_gl_extensions (CoglContext *context);
-
-const char *
-_cogl_context_get_gl_version (CoglContext *context);
-
 #endif /* __COGL_CONTEXT_PRIVATE_H */

cogl/cogl/cogl-context.c

@@ -45,40 +45,12 @@
 #include "cogl-onscreen-private.h"
 #include "cogl-attribute-private.h"
 #include "cogl1-context.h"
-#include "cogl-gpu-info-private.h"
 #include "cogl-gtype-private.h"
 #include "winsys/cogl-winsys-private.h"
 
 #include <string.h>
 #include <stdlib.h>
 
-/* These aren't defined in the GLES headers */
-#ifndef GL_POINT_SPRITE
-#define GL_POINT_SPRITE 0x8861
-#endif
-
-#ifndef GL_NUM_EXTENSIONS
-#define GL_NUM_EXTENSIONS 0x821D
-#endif
-
-/* This is a relatively new extension */
-#ifndef GL_PURGED_CONTEXT_RESET_NV
-#define GL_PURGED_CONTEXT_RESET_NV 0x92BB
-#endif
-
-/* These aren't defined in the GLES2 headers */
-#ifndef GL_GUILTY_CONTEXT_RESET_ARB
-#define GL_GUILTY_CONTEXT_RESET_ARB 0x8253
-#endif
-
-#ifndef GL_INNOCENT_CONTEXT_RESET_ARB
-#define GL_INNOCENT_CONTEXT_RESET_ARB 0x8254
-#endif
-
-#ifndef GL_UNKNOWN_CONTEXT_RESET_ARB
-#define GL_UNKNOWN_CONTEXT_RESET_ARB 0x8255
-#endif
-
 static void _cogl_context_free (CoglContext *context);
 
 COGL_OBJECT_DEFINE (Context, context);
@@ -470,94 +442,6 @@ _cogl_context_set_current_modelview_entry (CoglContext *context,
   context->current_modelview_entry = entry;
 }
 
-char **
-_cogl_context_get_gl_extensions (CoglContext *context)
-{
-  const char *env_disabled_extensions;
-  char **ret;
-
-  /* In GL 3, querying GL_EXTENSIONS is deprecated so we have to build
-   * the array using glGetStringi instead */
-#ifdef HAVE_COGL_GL
-  if (context->driver == COGL_DRIVER_GL3)
-    {
-      int num_extensions, i;
-
-      context->glGetIntegerv (GL_NUM_EXTENSIONS, &num_extensions);
-
-      ret = g_malloc (sizeof (char *) * (num_extensions + 1));
-
-      for (i = 0; i < num_extensions; i++)
-        {
-          const char *ext =
-            (const char *) context->glGetStringi (GL_EXTENSIONS, i);
-          ret[i] = g_strdup (ext);
-        }
-
-      ret[num_extensions] = NULL;
-    }
-  else
-#endif
-    {
-      const char *all_extensions =
-        (const char *) context->glGetString (GL_EXTENSIONS);
-
-      ret = g_strsplit (all_extensions, " ", 0 /* max tokens */);
-    }
-
-  if ((env_disabled_extensions = g_getenv ("COGL_DISABLE_GL_EXTENSIONS")))
-    {
-      char **split_env_disabled_extensions;
-      char **src, **dst;
-
-      if (env_disabled_extensions)
-        split_env_disabled_extensions =
-          g_strsplit (env_disabled_extensions,
-                      ",",
-                      0 /* no max tokens */);
-      else
-        split_env_disabled_extensions = NULL;
-
-      for (dst = ret, src = ret;
-           *src;
-           src++)
-        {
-          char **d;
-
-          if (split_env_disabled_extensions)
-            for (d = split_env_disabled_extensions; *d; d++)
-              if (!strcmp (*src, *d))
-                goto disabled;
-
-          *(dst++) = *src;
-          continue;
-
-        disabled:
-          g_free (*src);
-          continue;
-        }
-
-      *dst = NULL;
-
-      if (split_env_disabled_extensions)
-        g_strfreev (split_env_disabled_extensions);
-    }
-
-  return ret;
-}
-
-const char *
-_cogl_context_get_gl_version (CoglContext *context)
-{
-  const char *version_override;
-
-  if ((version_override = g_getenv ("COGL_OVERRIDE_GL_VERSION")))
-    return version_override;
-  else
-    return (const char *) context->glGetString (GL_VERSION);
-
-}
-
 int64_t
 cogl_get_clock_time (CoglContext *context)
 {
@@ -572,24 +456,11 @@ cogl_get_clock_time (CoglContext *context)
 CoglGraphicsResetStatus
 cogl_get_graphics_reset_status (CoglContext *context)
 {
-  if (!context->glGetGraphicsResetStatus)
-    return COGL_GRAPHICS_RESET_STATUS_NO_ERROR;
-
-  switch (context->glGetGraphicsResetStatus ())
-    {
-    case GL_GUILTY_CONTEXT_RESET_ARB:
-      return COGL_GRAPHICS_RESET_STATUS_GUILTY_CONTEXT_RESET;
-
-    case GL_INNOCENT_CONTEXT_RESET_ARB:
-      return COGL_GRAPHICS_RESET_STATUS_INNOCENT_CONTEXT_RESET;
-
-    case GL_UNKNOWN_CONTEXT_RESET_ARB:
-      return COGL_GRAPHICS_RESET_STATUS_UNKNOWN_CONTEXT_RESET;
-
-    case GL_PURGED_CONTEXT_RESET_NV:
-      return COGL_GRAPHICS_RESET_STATUS_PURGED_CONTEXT_RESET;
-
-    default:
-      return COGL_GRAPHICS_RESET_STATUS_NO_ERROR;
-    }
+  return context->driver_vtable->get_graphics_reset_status (context);
+}
+
+gboolean
+cogl_context_is_hardware_accelerated (CoglContext *context)
+{
+  return context->driver_vtable->is_hardware_accelerated (context);
 }

cogl/cogl/cogl-context.h

@@ -193,6 +193,8 @@ cogl_is_context (void *object);
  *    expected to return age values other than 0.
  * @COGL_FEATURE_ID_PRESENTATION_TIME: Whether frame presentation
  *    time stamps will be recorded in #CoglFrameInfo objects.
+ * @COGL_FEATURE_ID_BLIT_FRAMEBUFFER: Whether blitting using
+ *    cogl_blit_framebuffer() is supported.
  *
  * All the capabilities that can vary between different GPUs supported
  * by Cogl. Applications that depend on any of these features should explicitly
@@ -211,6 +213,7 @@ typedef enum _CoglFeatureID
   COGL_FEATURE_ID_TEXTURE_RG,
   COGL_FEATURE_ID_BUFFER_AGE,
   COGL_FEATURE_ID_TEXTURE_EGL_IMAGE_EXTERNAL,
+  COGL_FEATURE_ID_BLIT_FRAMEBUFFER,
 
   /*< private >*/
   _COGL_N_FEATURE_IDS   /*< skip >*/
@@ -354,6 +357,16 @@ typedef enum _CoglGraphicsResetStatus
 COGL_EXPORT CoglGraphicsResetStatus
 cogl_get_graphics_reset_status (CoglContext *context);
 
+/**
+ * cogl_context_is_hardware_accelerated:
+ * @context: a #CoglContext pointer
+ *
+ * Returns: %TRUE if the @context is hardware accelerated, or %FALSE if
+ * not.
+ */
+COGL_EXPORT gboolean
+cogl_context_is_hardware_accelerated (CoglContext *context);
+
 G_END_DECLS
 
 #endif /* __COGL_CONTEXT_H__ */

cogl/cogl/cogl-dma-buf-handle.c

@@ -34,12 +34,22 @@
 #include "cogl-dma-buf-handle.h"
 #include "cogl-object.h"
 
+#include <errno.h>
+#include <gio/gio.h>
+#include <linux/dma-buf.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
 #include <unistd.h>
 
 struct _CoglDmaBufHandle
 {
   CoglFramebuffer *framebuffer;
   int dmabuf_fd;
+  int width;
+  int height;
+  int stride;
+  int offset;
+  int bpp;
   gpointer user_data;
   GDestroyNotify destroy_func;
 };
@@ -47,6 +57,11 @@ struct _CoglDmaBufHandle
 CoglDmaBufHandle *
 cogl_dma_buf_handle_new (CoglFramebuffer *framebuffer,
                          int              dmabuf_fd,
+                         int              width,
+                         int              height,
+                         int              stride,
+                         int              offset,
+                         int              bpp,
                          gpointer         user_data,
                          GDestroyNotify   destroy_func)
 {
@@ -61,6 +76,12 @@ cogl_dma_buf_handle_new (CoglFramebuffer *framebuffer,
   dmabuf_handle->user_data = user_data;
   dmabuf_handle->destroy_func = destroy_func;
 
+  dmabuf_handle->width = width;
+  dmabuf_handle->height = height;
+  dmabuf_handle->stride = stride;
+  dmabuf_handle->offset = offset;
+  dmabuf_handle->bpp = bpp;
+
   return dmabuf_handle;
 }
 
@@ -80,6 +101,93 @@ cogl_dma_buf_handle_free (CoglDmaBufHandle *dmabuf_handle)
   g_free (dmabuf_handle);
 }
 
+static gboolean
+sync_read (CoglDmaBufHandle  *dmabuf_handle,
+           uint64_t           start_or_end,
+           GError           **error)
+{
+  struct dma_buf_sync sync = { 0 };
+
+  sync.flags = start_or_end | DMA_BUF_SYNC_READ;
+
+  while (TRUE)
+    {
+      int ret;
+
+      ret = ioctl (dmabuf_handle->dmabuf_fd, DMA_BUF_IOCTL_SYNC, &sync);
+      if (ret == -1 && errno == EINTR)
+        {
+          continue;
+        }
+      else if (ret == -1)
+        {
+          g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
+                       "ioctl: %s", g_strerror (errno));
+          return FALSE;
+        }
+      else
+        {
+          break;
+        }
+    }
+
+  return TRUE;
+}
+
+gboolean
+cogl_dma_buf_handle_sync_read_start (CoglDmaBufHandle  *dmabuf_handle,
+                                     GError           **error)
+{
+  return sync_read (dmabuf_handle, DMA_BUF_SYNC_START, error);
+}
+
+gboolean
+cogl_dma_buf_handle_sync_read_end (CoglDmaBufHandle  *dmabuf_handle,
+                                   GError           **error)
+{
+  return sync_read (dmabuf_handle, DMA_BUF_SYNC_END, error);
+}
+
+gpointer
+cogl_dma_buf_handle_mmap (CoglDmaBufHandle  *dmabuf_handle,
+                          GError           **error)
+{
+  size_t size;
+  gpointer data;
+
+  size = dmabuf_handle->height * dmabuf_handle->stride;
+
+  data = mmap (NULL, size, PROT_READ, MAP_PRIVATE,
+               dmabuf_handle->dmabuf_fd,
+               dmabuf_handle->offset);
+  if (data == MAP_FAILED)
+    {
+      g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
+                   "mmap failed: %s", g_strerror (errno));
+      return NULL;
+    }
+
+  return data;
+}
+
+gboolean
+cogl_dma_buf_handle_munmap (CoglDmaBufHandle  *dmabuf_handle,
+                            gpointer           data,
+                            GError           **error)
+{
+  size_t size;
+
+  size = dmabuf_handle->height * dmabuf_handle->stride;
+  if (munmap (data, size) != 0)
+    {
+      g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
+                   "munmap failed: %s", g_strerror (errno));
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
 CoglFramebuffer *
 cogl_dma_buf_handle_get_framebuffer (CoglDmaBufHandle *dmabuf_handle)
 {
@@ -92,3 +200,32 @@ cogl_dma_buf_handle_get_fd (CoglDmaBufHandle *dmabuf_handle)
   return dmabuf_handle->dmabuf_fd;
 }
 
+int
+cogl_dma_buf_handle_get_width (CoglDmaBufHandle *dmabuf_handle)
+{
+  return dmabuf_handle->width;
+}
+
+int
+cogl_dma_buf_handle_get_height (CoglDmaBufHandle *dmabuf_handle)
+{
+  return dmabuf_handle->height;
+}
+
+int
+cogl_dma_buf_handle_get_stride (CoglDmaBufHandle *dmabuf_handle)
+{
+  return dmabuf_handle->stride;
+}
+
+int
+cogl_dma_buf_handle_get_offset (CoglDmaBufHandle *dmabuf_handle)
+{
+  return dmabuf_handle->offset;
+}
+
+int
+cogl_dma_buf_handle_get_bpp (CoglDmaBufHandle *dmabuf_handle)
+{
+  return dmabuf_handle->bpp;
+}

cogl/cogl/cogl-dma-buf-handle.h

@@ -46,7 +46,12 @@
 COGL_EXPORT CoglDmaBufHandle *
 cogl_dma_buf_handle_new (CoglFramebuffer *framebuffer,
                          int              dmabuf_fd,
-                         gpointer         data,
+                         int              width,
+                         int              height,
+                         int              stride,
+                         int              offset,
+                         int              bpp,
+                         gpointer         user_data,
                          GDestroyNotify   destroy_func);
 
 /**
@@ -58,6 +63,23 @@ cogl_dma_buf_handle_new (CoglFramebuffer *framebuffer,
 COGL_EXPORT void
 cogl_dma_buf_handle_free (CoglDmaBufHandle *dmabuf_handle);
 
+COGL_EXPORT gboolean
+cogl_dma_buf_handle_sync_read_start (CoglDmaBufHandle  *dmabuf_handle,
+                                     GError           **error);
+
+COGL_EXPORT gboolean
+cogl_dma_buf_handle_sync_read_end (CoglDmaBufHandle  *dmabuf_handle,
+                                   GError           **error);
+
+COGL_EXPORT gpointer
+cogl_dma_buf_handle_mmap (CoglDmaBufHandle  *dmabuf_handle,
+                          GError           **error);
+
+COGL_EXPORT gboolean
+cogl_dma_buf_handle_munmap (CoglDmaBufHandle  *dmabuf_handle,
+                            gpointer           data,
+                            GError           **error);
+
 /**
  * cogl_dma_buf_handle_get_framebuffer: (skip)
  *
@@ -79,5 +101,44 @@ cogl_dma_buf_handle_get_framebuffer (CoglDmaBufHandle *dmabuf_handle);
 COGL_EXPORT int
 cogl_dma_buf_handle_get_fd (CoglDmaBufHandle *dmabuf_handle);
 
+/**
+ * cogl_dmabuf_handle_get_width: (skip)
+ *
+ * Returns: the buffer width
+ */
+COGL_EXPORT int
+cogl_dma_buf_handle_get_width (CoglDmaBufHandle *dmabuf_handle);
+
+/**
+ * cogl_dmabuf_handle_get_height: (skip)
+ *
+ * Returns: the buffer height
+ */
+COGL_EXPORT int
+cogl_dma_buf_handle_get_height (CoglDmaBufHandle *dmabuf_handle);
+
+/**
+ * cogl_dmabuf_handle_get_stride: (skip)
+ *
+ * Returns: the buffer stride
+ */
+COGL_EXPORT int
+cogl_dma_buf_handle_get_stride (CoglDmaBufHandle *dmabuf_handle);
+
+/**
+ * cogl_dmabuf_handle_get_offset: (skip)
+ *
+ * Returns: the buffer offset
+ */
+COGL_EXPORT int
+cogl_dma_buf_handle_get_offset (CoglDmaBufHandle *dmabuf_handle);
+
+/**
+ * cogl_dmabuf_handle_get_bpp: (skip)
+ *
+ * Returns: the number of bytes per pixel
+ */
+COGL_EXPORT int
+cogl_dma_buf_handle_get_bpp (CoglDmaBufHandle *dmabuf_handle);
 
 #endif /* __COGL_DMA_BUF_HANDLE_H__ */

cogl/cogl/cogl-driver.h

@@ -35,6 +35,7 @@
 #include "cogl-offscreen.h"
 #include "cogl-framebuffer-private.h"
 #include "cogl-attribute-private.h"
+#include "cogl-sampler-cache-private.h"
 
 typedef struct _CoglDriverVtable CoglDriverVtable;
 
@@ -46,6 +47,12 @@ struct _CoglDriverVtable
   void
   (* context_deinit) (CoglContext *context);
 
+  gboolean
+  (* is_hardware_accelerated) (CoglContext *context);
+
+  CoglGraphicsResetStatus
+  (* get_graphics_reset_status) (CoglContext *context);
+
   /* TODO: factor this out since this is OpenGL specific and
    * so can be ignored by non-OpenGL drivers. */
   gboolean
@@ -262,6 +269,19 @@ struct _CoglDriverVtable
                        const void *data,
                        unsigned int size,
                        GError **error);
+
+  void
+  (*sampler_init) (CoglContext *context,
+                   CoglSamplerCacheEntry *entry);
+
+  void
+  (*sampler_free) (CoglContext *context,
+                   CoglSamplerCacheEntry *entry);
+
+  void
+  (* set_uniform) (CoglContext *ctx,
+                   GLint location,
+                   const CoglBoxedValue *value);
 };
 
 #define COGL_DRIVER_ERROR (_cogl_driver_error_quark ())

cogl/cogl/cogl-frame-info-private.h

@@ -43,8 +43,6 @@ struct _CoglFrameInfo
   float refresh_rate;
 
   int64_t global_frame_counter;
-
-  CoglOutput *output;
 };
 
 CoglFrameInfo *_cogl_frame_info_new (void);

cogl/cogl/cogl-frame-info.c

@@ -72,12 +72,6 @@ cogl_frame_info_get_refresh_rate (CoglFrameInfo *info)
   return info->refresh_rate;
 }
 
-CoglOutput *
-cogl_frame_info_get_output (CoglFrameInfo *info)
-{
-  return info->output;
-}
-
 int64_t
 cogl_frame_info_get_global_frame_counter (CoglFrameInfo *info)
 {

cogl/cogl/cogl-frame-info.h

@@ -126,20 +126,6 @@ int64_t cogl_frame_info_get_presentation_time (CoglFrameInfo *info);
 COGL_EXPORT
 float cogl_frame_info_get_refresh_rate (CoglFrameInfo *info);
 
-/**
- * cogl_frame_info_get_output:
- * @info: a #CoglFrameInfo object
- *
- * Gets the #CoglOutput that the swapped frame was presented to.
- *
- * Return value: (transfer none): The #CoglOutput that the frame was
- *        presented to, or %NULL if this could not be determined.
- * Since: 1.14
- * Stability: unstable
- */
-COGL_EXPORT CoglOutput *
-cogl_frame_info_get_output (CoglFrameInfo *info);
-
 /**
  * cogl_frame_info_get_global_frame_counter: (skip)
  */

cogl/cogl/cogl-framebuffer.c

@@ -1292,7 +1292,7 @@ cogl_blit_framebuffer (CoglFramebuffer *src,
   int src_x1, src_y1, src_x2, src_y2;
   int dst_x1, dst_y1, dst_x2, dst_y2;
 
-  if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_BLIT_FRAMEBUFFER))
+  if (!cogl_has_feature (ctx, COGL_FEATURE_ID_BLIT_FRAMEBUFFER))
     {
       g_set_error_literal (error, COGL_SYSTEM_ERROR,
                            COGL_SYSTEM_ERROR_UNSUPPORTED,

cogl/cogl/cogl-framebuffer.h

@@ -1509,7 +1509,7 @@ cogl_is_framebuffer (void *object);
  *
  * This blits a region of the color buffer of the source buffer
  * to the destination buffer. This function should only be
- * called if the COGL_PRIVATE_FEATURE_BLIT_FRAMEBUFFER feature is
+ * called if the COGL_FEATURE_ID_BLIT_FRAMEBUFFER feature is
  * advertised.
  *
  * The source and destination rectangles are defined in offscreen

cogl/cogl/cogl-glsl-shader-private.h

@@ -1,41 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2012 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#ifndef _COGL_GLSL_SHADER_PRIVATE_H_
-#define _COGL_GLSL_SHADER_PRIVATE_H_
-
-void
-_cogl_glsl_shader_set_source_with_boilerplate (CoglContext *ctx,
-                                               GLuint shader_gl_handle,
-                                               GLenum shader_gl_type,
-                                               CoglPipeline *pipeline,
-                                               GLsizei count_in,
-                                               const char **strings_in,
-                                               const GLint *lengths_in);
-
-#endif /* _COGL_GLSL_SHADER_PRIVATE_H_ */

cogl/cogl/cogl-glsl-shader.c

@@ -1,189 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2012 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- *
- *
- * Authors:
- *   Robert Bragg <robert@linux.intel.com>
- *   Neil Roberts <neil@linux.intel.com>
- */
-
-#include "cogl-config.h"
-
-#include "cogl-context-private.h"
-#include "cogl-glsl-shader-private.h"
-#include "cogl-glsl-shader-boilerplate.h"
-#include "driver/gl/cogl-util-gl-private.h"
-
-#include <string.h>
-
-#include <glib.h>
-
-static gboolean
-add_layer_vertex_boilerplate_cb (CoglPipelineLayer *layer,
-                                 void *user_data)
-{
-  GString *layer_declarations = user_data;
-  int unit_index = _cogl_pipeline_layer_get_unit_index (layer);
-  g_string_append_printf (layer_declarations,
-                          "attribute vec4 cogl_tex_coord%d_in;\n"
-                          "#define cogl_texture_matrix%i cogl_texture_matrix[%i]\n"
-                          "#define cogl_tex_coord%i_out _cogl_tex_coord[%i]\n",
-                          layer->index,
-                          layer->index,
-                          unit_index,
-                          layer->index,
-                          unit_index);
-  return TRUE;
-}
-
-static gboolean
-add_layer_fragment_boilerplate_cb (CoglPipelineLayer *layer,
-                                   void *user_data)
-{
-  GString *layer_declarations = user_data;
-  g_string_append_printf (layer_declarations,
-                          "#define cogl_tex_coord%i_in _cogl_tex_coord[%i]\n",
-                          layer->index,
-                          _cogl_pipeline_layer_get_unit_index (layer));
-  return TRUE;
-}
-
-void
-_cogl_glsl_shader_set_source_with_boilerplate (CoglContext *ctx,
-                                               GLuint shader_gl_handle,
-                                               GLenum shader_gl_type,
-                                               CoglPipeline *pipeline,
-                                               GLsizei count_in,
-                                               const char **strings_in,
-                                               const GLint *lengths_in)
-{
-  const char *vertex_boilerplate;
-  const char *fragment_boilerplate;
-
-  const char **strings = g_alloca (sizeof (char *) * (count_in + 4));
-  GLint *lengths = g_alloca (sizeof (GLint) * (count_in + 4));
-  char *version_string;
-  int count = 0;
-
-  int n_layers;
-
-  vertex_boilerplate = _COGL_VERTEX_SHADER_BOILERPLATE;
-  fragment_boilerplate = _COGL_FRAGMENT_SHADER_BOILERPLATE;
-
-  version_string = g_strdup_printf ("#version %i\n\n",
-                                    ctx->glsl_version_to_use);
-  strings[count] = version_string;
-  lengths[count++] = -1;
-
-  if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_EGL_IMAGE_EXTERNAL))
-    {
-      static const char image_external_extension[] =
-        "#extension GL_OES_EGL_image_external : require\n";
-      strings[count] = image_external_extension;
-      lengths[count++] = sizeof (image_external_extension) - 1;
-    }
-
-  if (shader_gl_type == GL_VERTEX_SHADER)
-    {
-      strings[count] = vertex_boilerplate;
-      lengths[count++] = strlen (vertex_boilerplate);
-    }
-  else if (shader_gl_type == GL_FRAGMENT_SHADER)
-    {
-      strings[count] = fragment_boilerplate;
-      lengths[count++] = strlen (fragment_boilerplate);
-    }
-
-  n_layers = cogl_pipeline_get_n_layers (pipeline);
-  if (n_layers)
-    {
-      GString *layer_declarations = ctx->codegen_boilerplate_buffer;
-      g_string_set_size (layer_declarations, 0);
-
-      g_string_append_printf (layer_declarations,
-                              "varying vec4 _cogl_tex_coord[%d];\n",
-                              n_layers);
-
-      if (shader_gl_type == GL_VERTEX_SHADER)
-        {
-          g_string_append_printf (layer_declarations,
-                                  "uniform mat4 cogl_texture_matrix[%d];\n",
-                                  n_layers);
-
-          _cogl_pipeline_foreach_layer_internal (pipeline,
-                                                 add_layer_vertex_boilerplate_cb,
-                                                 layer_declarations);
-        }
-      else if (shader_gl_type == GL_FRAGMENT_SHADER)
-        {
-          _cogl_pipeline_foreach_layer_internal (pipeline,
-                                                 add_layer_fragment_boilerplate_cb,
-                                                 layer_declarations);
-        }
-
-      strings[count] = layer_declarations->str;
-      lengths[count++] = -1; /* null terminated */
-    }
-
-  memcpy (strings + count, strings_in, sizeof (char *) * count_in);
-  if (lengths_in)
-    memcpy (lengths + count, lengths_in, sizeof (GLint) * count_in);
-  else
-    {
-      int i;
-
-      for (i = 0; i < count_in; i++)
-        lengths[count + i] = -1; /* null terminated */
-    }
-  count += count_in;
-
-  if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_SHOW_SOURCE)))
-    {
-      GString *buf = g_string_new (NULL);
-      int i;
-
-      g_string_append_printf (buf,
-                              "%s shader:\n",
-                              shader_gl_type == GL_VERTEX_SHADER ?
-                              "vertex" : "fragment");
-      for (i = 0; i < count; i++)
-        if (lengths[i] != -1)
-          g_string_append_len (buf, strings[i], lengths[i]);
-        else
-          g_string_append (buf, strings[i]);
-
-      g_message ("%s", buf->str);
-
-      g_string_free (buf, TRUE);
-    }
-
-  GE( ctx, glShaderSource (shader_gl_handle, count,
-                           (const char **) strings, lengths) );
-
-  g_free (version_string);
-}

cogl/cogl/cogl-gpu-info-private.h

@@ -1,112 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2012 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- *
- */
-
-#ifndef __COGL_GPU_INFO_PRIVATE_H
-#define __COGL_GPU_INFO_PRIVATE_H
-
-#include "cogl-context.h"
-
-typedef enum _CoglGpuInfoArchitectureFlag
-{
-  COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_IMMEDIATE_MODE,
-  COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_TILED,
-  COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_SOFTWARE,
-  COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_IMMEDIATE_MODE,
-  COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_DEFERRED,
-  COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_SOFTWARE
-} CoglGpuInfoArchitectureFlag;
-
-typedef enum _CoglGpuInfoArchitecture
-{
-  COGL_GPU_INFO_ARCHITECTURE_UNKNOWN,
-  COGL_GPU_INFO_ARCHITECTURE_SANDYBRIDGE,
-  COGL_GPU_INFO_ARCHITECTURE_SGX,
-  COGL_GPU_INFO_ARCHITECTURE_MALI,
-  COGL_GPU_INFO_ARCHITECTURE_LLVMPIPE,
-  COGL_GPU_INFO_ARCHITECTURE_SOFTPIPE,
-  COGL_GPU_INFO_ARCHITECTURE_SWRAST
-} CoglGpuInfoArchitecture;
-
-typedef enum
-{
-  COGL_GPU_INFO_VENDOR_UNKNOWN,
-  COGL_GPU_INFO_VENDOR_INTEL,
-  COGL_GPU_INFO_VENDOR_IMAGINATION_TECHNOLOGIES,
-  COGL_GPU_INFO_VENDOR_ARM,
-  COGL_GPU_INFO_VENDOR_QUALCOMM,
-  COGL_GPU_INFO_VENDOR_NVIDIA,
-  COGL_GPU_INFO_VENDOR_ATI,
-  COGL_GPU_INFO_VENDOR_MESA
-} CoglGpuInfoVendor;
-
-typedef enum
-{
-  COGL_GPU_INFO_DRIVER_PACKAGE_UNKNOWN,
-  COGL_GPU_INFO_DRIVER_PACKAGE_MESA
-} CoglGpuInfoDriverPackage;
-
-typedef enum
-{
-  COGL_GPU_INFO_DRIVER_STUB
-} CoglGpuInfoDriverBug;
-
-typedef struct _CoglGpuInfoVersion CoglGpuInfoVersion;
-
-typedef struct _CoglGpuInfo CoglGpuInfo;
-
-struct _CoglGpuInfo
-{
-  CoglGpuInfoVendor vendor;
-  const char *vendor_name;
-
-  CoglGpuInfoDriverPackage driver_package;
-  const char *driver_package_name;
-  int driver_package_version;
-
-  CoglGpuInfoArchitecture architecture;
-  const char *architecture_name;
-  CoglGpuInfoArchitectureFlag architecture_flags;
-
-  CoglGpuInfoDriverBug driver_bugs;
-};
-
-/*
- * _cogl_gpu_info_init:
- * @ctx: A #CoglContext
- * @gpu: A return location for the GPU information
- *
- * Determines information about the GPU and driver from the given
- * context.
- */
-void
-_cogl_gpu_info_init (CoglContext *ctx,
-                     CoglGpuInfo *gpu);
-
-#endif /* __COGL_GPU_INFO_PRIVATE_H */

cogl/cogl/cogl-gpu-info.c

@@ -1,572 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2012 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- *
- */
-
-#include "cogl-config.h"
-
-#include <string.h>
-#include <errno.h>
-
-#include <test-fixtures/test-unit.h>
-
-#include "cogl-gpu-info-private.h"
-#include "cogl-context-private.h"
-#include "cogl-version.h"
-
-typedef struct
-{
-  const char *renderer_string;
-  const char *version_string;
-  const char *vendor_string;
-} CoglGpuInfoStrings;
-
-typedef struct CoglGpuInfoArchitectureDescription
-{
-  CoglGpuInfoArchitecture architecture;
-  const char *name;
-  CoglGpuInfoArchitectureFlag flags;
-  gboolean (* check_function) (const CoglGpuInfoStrings *strings);
-
-} CoglGpuInfoArchitectureDescription;
-
-typedef struct
-{
-  CoglGpuInfoVendor vendor;
-  const char *name;
-  gboolean (* check_function) (const CoglGpuInfoStrings *strings);
-  const CoglGpuInfoArchitectureDescription *architectures;
-
-} CoglGpuInfoVendorDescription;
-
-typedef struct
-{
-  CoglGpuInfoDriverPackage driver_package;
-  const char *name;
-  gboolean (* check_function) (const CoglGpuInfoStrings *strings,
-                               int *version_out);
-} CoglGpuInfoDriverPackageDescription;
-
-static gboolean
-_cogl_gpu_info_parse_version_string (const char *version_string,
-                                     int n_components,
-                                     const char **tail,
-                                     int *version_ret)
-{
-  int version = 0;
-  uint64_t part;
-  int i;
-
-  for (i = 0; ; i++)
-    {
-      errno = 0;
-      part = g_ascii_strtoull (version_string,
-                               (char **) &version_string,
-                               10);
-
-      if (errno || part > COGL_VERSION_MAX_COMPONENT_VALUE)
-        return FALSE;
-
-      version |= part << ((2 - i) * COGL_VERSION_COMPONENT_BITS);
-
-      if (i + 1 >= n_components)
-        break;
-
-      if (*version_string != '.')
-        return FALSE;
-
-      version_string++;
-    }
-
-  if (version_ret)
-    *version_ret = version;
-  if (tail)
-    *tail = version_string;
-
-  return TRUE;
-}
-
-static gboolean
-match_phrase (const char *string, const char *phrase)
-{
-  const char *part = strstr (string, phrase);
-  int len;
-
-  if (part == NULL)
-    return FALSE;
-
-  /* The match must either be at the beginning of the string or
-     preceded by a space. */
-  if (part > string && part[-1] != ' ')
-    return FALSE;
-
-  /* Also match must either be at end of string or followed by a
-   * space. */
-  len = strlen (phrase);
-  if (part[len] != '\0' && part[len] != ' ')
-    return FALSE;
-
-  return TRUE;
-}
-
-static gboolean
-check_intel_vendor (const CoglGpuInfoStrings *strings)
-{
-  return match_phrase (strings->renderer_string, "Intel(R)");
-}
-
-static gboolean
-check_imagination_technologies_vendor (const CoglGpuInfoStrings *strings)
-{
-  if (strcmp (strings->vendor_string, "Imagination Technologies") != 0)
-    return FALSE;
-  return TRUE;
-}
-
-static gboolean
-check_arm_vendor (const CoglGpuInfoStrings *strings)
-{
-  if (strcmp (strings->vendor_string, "ARM") != 0)
-    return FALSE;
-  return TRUE;
-}
-
-static gboolean
-check_qualcomm_vendor (const CoglGpuInfoStrings *strings)
-{
-  if (strcmp (strings->vendor_string, "Qualcomm") != 0)
-    return FALSE;
-  return TRUE;
-}
-
-static gboolean
-check_nvidia_vendor (const CoglGpuInfoStrings *strings)
-{
-  if (strcmp (strings->vendor_string, "NVIDIA") != 0 &&
-      strcmp (strings->vendor_string, "NVIDIA Corporation") != 0)
-    return FALSE;
-
-  return TRUE;
-}
-
-static gboolean
-check_ati_vendor (const CoglGpuInfoStrings *strings)
-{
-  if (strcmp (strings->vendor_string, "ATI") != 0)
-    return FALSE;
-
-  return TRUE;
-}
-
-static gboolean
-check_mesa_vendor (const CoglGpuInfoStrings *strings)
-{
-  if (strcmp (strings->vendor_string, "Tungsten Graphics, Inc") == 0)
-    return TRUE;
-  else if (strcmp (strings->vendor_string, "VMware, Inc.") == 0)
-    return TRUE;
-  else if (strcmp (strings->vendor_string, "Mesa Project") == 0)
-    return TRUE;
-
-  return FALSE;
-}
-
-static gboolean
-check_true (const CoglGpuInfoStrings *strings)
-{
-  /* This is a last resort so it always matches */
-  return TRUE;
-}
-
-static gboolean
-check_sandybridge_architecture (const CoglGpuInfoStrings *strings)
-{
-  return match_phrase (strings->renderer_string, "Sandybridge");
-}
-
-static gboolean
-check_llvmpipe_architecture (const CoglGpuInfoStrings *strings)
-{
-  return match_phrase (strings->renderer_string, "llvmpipe");
-}
-
-static gboolean
-check_softpipe_architecture (const CoglGpuInfoStrings *strings)
-{
-  return match_phrase (strings->renderer_string, "softpipe");
-}
-
-static gboolean
-check_swrast_architecture (const CoglGpuInfoStrings *strings)
-{
-  return match_phrase (strings->renderer_string, "software rasterizer") ||
-    match_phrase (strings->renderer_string, "Software Rasterizer");
-}
-
-static gboolean
-check_sgx_architecture (const CoglGpuInfoStrings *strings)
-{
-  if (strncmp (strings->renderer_string, "PowerVR SGX", 12) != 0)
-    return FALSE;
-
-  return TRUE;
-}
-
-static gboolean
-check_mali_architecture (const CoglGpuInfoStrings *strings)
-{
-  if (strncmp (strings->renderer_string, "Mali-", 5) != 0)
-    return FALSE;
-
-  return TRUE;
-}
-
-static const CoglGpuInfoArchitectureDescription
-intel_architectures[] =
-  {
-    {
-      COGL_GPU_INFO_ARCHITECTURE_SANDYBRIDGE,
-      "Sandybridge",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_IMMEDIATE_MODE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_IMMEDIATE_MODE,
-      check_sandybridge_architecture
-    },
-    {
-      COGL_GPU_INFO_ARCHITECTURE_UNKNOWN,
-      "Unknown",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_IMMEDIATE_MODE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_IMMEDIATE_MODE,
-      check_true
-    }
-  };
-
-static const CoglGpuInfoArchitectureDescription
-powervr_architectures[] =
-  {
-    {
-      COGL_GPU_INFO_ARCHITECTURE_SGX,
-      "SGX",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_TILED |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_DEFERRED,
-      check_sgx_architecture
-    },
-    {
-      COGL_GPU_INFO_ARCHITECTURE_UNKNOWN,
-      "Unknown",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_TILED |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_TILED,
-      check_true
-    }
-  };
-
-static const CoglGpuInfoArchitectureDescription
-arm_architectures[] =
-  {
-    {
-      COGL_GPU_INFO_ARCHITECTURE_MALI,
-      "Mali",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_TILED |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_IMMEDIATE_MODE,
-      check_mali_architecture
-    },
-    {
-      COGL_GPU_INFO_ARCHITECTURE_UNKNOWN,
-      "Unknown",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_TILED |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_IMMEDIATE_MODE,
-      check_true
-    }
-  };
-
-static const CoglGpuInfoArchitectureDescription
-mesa_architectures[] =
-  {
-    {
-      COGL_GPU_INFO_ARCHITECTURE_LLVMPIPE,
-      "LLVM Pipe",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_IMMEDIATE_MODE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_SOFTWARE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_IMMEDIATE_MODE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_SOFTWARE,
-      check_llvmpipe_architecture
-    },
-    {
-      COGL_GPU_INFO_ARCHITECTURE_SOFTPIPE,
-      "Softpipe",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_IMMEDIATE_MODE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_SOFTWARE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_IMMEDIATE_MODE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_SOFTWARE,
-      check_softpipe_architecture
-    },
-    {
-      COGL_GPU_INFO_ARCHITECTURE_SWRAST,
-      "SWRast",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_IMMEDIATE_MODE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_SOFTWARE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_IMMEDIATE_MODE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_SOFTWARE,
-      check_swrast_architecture
-    },
-    {
-      COGL_GPU_INFO_ARCHITECTURE_UNKNOWN,
-      "Unknown",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_IMMEDIATE_MODE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_FRAGMENT_IMMEDIATE_MODE,
-      check_true
-    }
-  };
-
-static const CoglGpuInfoArchitectureDescription
-unknown_architectures[] =
-  {
-    {
-      COGL_GPU_INFO_ARCHITECTURE_UNKNOWN,
-      "Unknown",
-      COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_IMMEDIATE_MODE |
-        COGL_GPU_INFO_ARCHITECTURE_FLAG_VERTEX_IMMEDIATE_MODE,
-      check_true
-    }
-  };
-
-static const CoglGpuInfoVendorDescription
-_cogl_gpu_info_vendors[] =
-  {
-    {
-      COGL_GPU_INFO_VENDOR_INTEL,
-      "Intel",
-      check_intel_vendor,
-      intel_architectures
-    },
-    {
-      COGL_GPU_INFO_VENDOR_IMAGINATION_TECHNOLOGIES,
-      "Imagination Technologies",
-      check_imagination_technologies_vendor,
-      powervr_architectures
-    },
-    {
-      COGL_GPU_INFO_VENDOR_ARM,
-      "ARM",
-      check_arm_vendor,
-      arm_architectures
-    },
-    {
-      COGL_GPU_INFO_VENDOR_QUALCOMM,
-      "Qualcomm",
-      check_qualcomm_vendor,
-      unknown_architectures
-    },
-    {
-      COGL_GPU_INFO_VENDOR_NVIDIA,
-      "Nvidia",
-      check_nvidia_vendor,
-      unknown_architectures
-    },
-    {
-      COGL_GPU_INFO_VENDOR_ATI,
-      "ATI",
-      check_ati_vendor,
-      unknown_architectures
-    },
-    /* Must be last */
-    {
-      COGL_GPU_INFO_VENDOR_MESA,
-      "Mesa",
-      check_mesa_vendor,
-      mesa_architectures
-    },
-    {
-      COGL_GPU_INFO_VENDOR_UNKNOWN,
-      "Unknown",
-      check_true,
-      unknown_architectures
-    }
-  };
-
-static gboolean
-check_mesa_driver_package (const CoglGpuInfoStrings *strings,
-                           int *version_ret)
-{
-  uint64_t micro_part;
-  const char *v;
-
-  /* The version string should always begin a two-part GL version
-     number */
-  if (!_cogl_gpu_info_parse_version_string (strings->version_string,
-                                            2, /* n_components */
-                                            &v, /* tail */
-                                            NULL /* version_ret */))
-    return FALSE;
-
-  /* In mesa this will be followed optionally by "(Core Profile)" and
-   * then "Mesa" */
-  v = strstr (v, " Mesa ");
-  if (!v)
-    return FALSE;
-
-  v += 6;
-
-  /* Next there will be a version string that is at least two
-     components. On a git devel build the version will be something
-     like "-devel<git hash>" instead */
-  if (!_cogl_gpu_info_parse_version_string (v,
-                                            2, /* n_components */
-                                            &v, /* tail */
-                                            version_ret))
-    return FALSE;
-
-  /* If it is a development build then we'll just leave the micro
-     number as 0 */
-  if (g_str_has_prefix (v, "-devel"))
-    return TRUE;
-
-  /* Otherwise there should be a micro version number */
-  if (*v != '.')
-    return FALSE;
-
-  errno = 0;
-  micro_part = g_ascii_strtoull (v + 1, NULL /* endptr */, 10 /* base */);
-  if (errno || micro_part > COGL_VERSION_MAX_COMPONENT_VALUE)
-    return FALSE;
-
-  *version_ret = COGL_VERSION_ENCODE (COGL_VERSION_GET_MAJOR (*version_ret),
-                                      COGL_VERSION_GET_MINOR (*version_ret),
-                                      micro_part);
-
-  return TRUE;
-}
-
-UNIT_TEST (check_mesa_driver_package_parser,
-           0, /* no requirements */
-           0 /* no failure cases */)
-{
-  /* renderer_string, version_string, vendor_string;*/
-  const CoglGpuInfoStrings test_strings[2] = {
-    { NULL, "3.1 Mesa 9.2-devel15436ad", NULL },
-    { NULL, "3.1 (Core Profile) Mesa 9.2.0-devel (git-15436ad)", NULL }
-  };
-  int i;
-  int version;
-
-  for (i = 0; i < G_N_ELEMENTS (test_strings); i++)
-    {
-      g_assert (check_mesa_driver_package (&test_strings[i], &version));
-      g_assert_cmpint (version, ==, COGL_VERSION_ENCODE (9, 2, 0));
-    }
-}
-
-static gboolean
-check_unknown_driver_package (const CoglGpuInfoStrings *strings,
-                              int *version_out)
-{
-  *version_out = 0;
-
-  /* This is a last resort so it always matches */
-  return TRUE;
-}
-
-static const CoglGpuInfoDriverPackageDescription
-_cogl_gpu_info_driver_packages[] =
-  {
-    {
-      COGL_GPU_INFO_DRIVER_PACKAGE_MESA,
-      "Mesa",
-      check_mesa_driver_package
-    },
-    /* Must be last */
-    {
-      COGL_GPU_INFO_DRIVER_PACKAGE_UNKNOWN,
-      "Unknown",
-      check_unknown_driver_package
-    }
-  };
-
-void
-_cogl_gpu_info_init (CoglContext *ctx,
-                     CoglGpuInfo *gpu)
-{
-  CoglGpuInfoStrings strings;
-  int i;
-
-  strings.renderer_string = (const char *) ctx->glGetString (GL_RENDERER);
-  strings.version_string = _cogl_context_get_gl_version (ctx);
-  strings.vendor_string = (const char *) ctx->glGetString (GL_VENDOR);
-
-  /* Determine the driver package */
-  for (i = 0; ; i++)
-    {
-      const CoglGpuInfoDriverPackageDescription *description =
-        _cogl_gpu_info_driver_packages + i;
-
-      if (description->check_function (&strings, &gpu->driver_package_version))
-        {
-          gpu->driver_package = description->driver_package;
-          gpu->driver_package_name = description->name;
-          break;
-        }
-    }
-
-  /* Determine the GPU vendor */
-  for (i = 0; ; i++)
-    {
-      const CoglGpuInfoVendorDescription *description =
-        _cogl_gpu_info_vendors + i;
-
-      if (description->check_function (&strings))
-        {
-          int j;
-
-          gpu->vendor = description->vendor;
-          gpu->vendor_name = description->name;
-
-          for (j = 0; ; j++)
-            {
-              const CoglGpuInfoArchitectureDescription *architecture =
-                description->architectures + j;
-
-              if (architecture->check_function (&strings))
-                {
-                  gpu->architecture = architecture->architecture;
-                  gpu->architecture_name = architecture->name;
-                  gpu->architecture_flags = architecture->flags;
-                  goto probed;
-                }
-            }
-        }
-    }
-
-probed:
-
-  COGL_NOTE (WINSYS, "Driver package = %s, vendor = %s, architecture = %s\n",
-             gpu->driver_package_name,
-             gpu->vendor_name,
-             gpu->architecture_name);
-
-  /* Determine the driver bugs */
-  gpu->driver_bugs = 0;
-}

cogl/cogl/cogl-matrix-stack.c

@@ -41,7 +41,6 @@
 #include "cogl-matrix-private.h"
 #include "cogl-magazine-private.h"
 #include "cogl-gtype-private.h"
-#include "driver/gl/cogl-util-gl-private.h"
 
 static void _cogl_matrix_stack_free (CoglMatrixStack *stack);
 

cogl/cogl/cogl-onscreen.c

@@ -93,10 +93,12 @@ _cogl_onscreen_init_from_template (CoglOnscreen *onscreen,
 CoglOnscreen *
 _cogl_onscreen_new (void)
 {
-  CoglOnscreen *onscreen = g_new0 (CoglOnscreen, 1);
+  g_autofree CoglOnscreen *onscreen_ptr = g_new0 (CoglOnscreen, 1);
+  CoglOnscreen *onscreen;
 
   _COGL_GET_CONTEXT (ctx, NULL);
 
+  onscreen = g_steal_pointer (&onscreen_ptr);
   _cogl_framebuffer_init (COGL_FRAMEBUFFER (onscreen),
                           ctx,
                           COGL_FRAMEBUFFER_TYPE_ONSCREEN,
@@ -403,6 +405,27 @@ cogl_onscreen_get_buffer_age (CoglOnscreen *onscreen)
   return winsys->onscreen_get_buffer_age (onscreen);
 }
 
+void
+cogl_onscreen_direct_scanout (CoglOnscreen *onscreen,
+                              CoglScanout  *scanout)
+{
+  CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
+  const CoglWinsysVtable *winsys;
+  CoglFrameInfo *info;
+
+  g_return_if_fail (framebuffer->type == COGL_FRAMEBUFFER_TYPE_ONSCREEN);
+  g_return_if_fail (_cogl_winsys_has_feature (COGL_WINSYS_FEATURE_SYNC_AND_COMPLETE_EVENT));
+
+  info = _cogl_frame_info_new ();
+  info->frame_counter = onscreen->frame_counter;
+  g_queue_push_tail (&onscreen->pending_frame_infos, info);
+
+  winsys = _cogl_framebuffer_get_winsys (framebuffer);
+  winsys->onscreen_direct_scanout (onscreen, scanout);
+
+  onscreen->frame_counter++;
+}
+
 #ifdef COGL_HAS_X11_SUPPORT
 uint32_t
 cogl_x11_onscreen_get_window_xid (CoglOnscreen *onscreen)

cogl/cogl/cogl-onscreen.h

@@ -50,6 +50,8 @@ G_BEGIN_DECLS
 typedef struct _CoglOnscreen CoglOnscreen;
 #define COGL_ONSCREEN(X) ((CoglOnscreen *)(X))
 
+typedef struct _CoglScanout CoglScanout;
+
 /**
  * cogl_onscreen_get_gtype:
  *
@@ -284,6 +286,13 @@ cogl_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
                                         const int *rectangles,
                                         int n_rectangles);
 
+/**
+ * cogl_onscreen_direct_scanout: (skip)
+ */
+COGL_EXPORT void
+cogl_onscreen_direct_scanout (CoglOnscreen *onscreen,
+                              CoglScanout  *scanout);
+
 /**
  * cogl_onscreen_swap_region:
  * @onscreen: A #CoglOnscreen framebuffer

cogl/cogl/cogl-pipeline-cache.c

@@ -50,7 +50,7 @@ struct _CoglPipelineCache
 CoglPipelineCache *
 _cogl_pipeline_cache_new (void)
 {
-  CoglPipelineCache *cache = g_new (CoglPipelineCache, 1);
+  g_autofree CoglPipelineCache *cache = g_new (CoglPipelineCache, 1);
   unsigned long vertex_state;
   unsigned long layer_vertex_state;
   unsigned int fragment_state;
@@ -80,7 +80,7 @@ _cogl_pipeline_cache_new (void)
                                   layer_vertex_state | layer_fragment_state,
                                   "programs");
 
-  return cache;
+  return g_steal_pointer (&cache);
 }
 
 void

cogl/cogl/cogl-pipeline-layer-state.c

@@ -1361,6 +1361,17 @@ cogl_pipeline_set_layer_filters (CoglPipeline      *pipeline,
                                           sampler_state);
 }
 
+void
+cogl_pipeline_set_layer_max_mipmap_level (CoglPipeline *pipeline,
+                                          int           layer,
+                                          int           max_level)
+{
+  CoglTexture *texture = cogl_pipeline_get_layer_texture (pipeline, layer);
+
+  if (texture != NULL)
+    cogl_texture_set_max_level (texture, max_level);
+}
+
 const CoglSamplerCacheEntry *
 _cogl_pipeline_layer_get_sampler_state (CoglPipelineLayer *layer)
 {

cogl/cogl/cogl-pipeline-layer-state.h

@@ -568,6 +568,11 @@ cogl_pipeline_add_layer_snippet (CoglPipeline *pipeline,
                                  int layer,
                                  CoglSnippet *snippet);
 
+COGL_EXPORT void
+cogl_pipeline_set_layer_max_mipmap_level (CoglPipeline *pipeline,
+                                          int           layer,
+                                          int           max_level);
+
 G_END_DECLS
 
 #endif /* __COGL_PIPELINE_LAYER_STATE_H__ */