Import Upstream version 43.0upstream/latest

1 files changed, 1668 insertions, 0 deletions

diff --git a/src/gui/gtd-widget.c b/src/gui/gtd-widget.c
new file mode 100644
index 0000000..e5bece4
--- /dev/null
+++ b/src/gui/gtd-widget.c
@@ -0,0 +1,1668 @@
+/* gtd-widget.c
+ *
+ * Copyright 2018-2020 Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include "gtd-animatable.h"
+#include "gtd-bin-layout.h"
+#include "gtd-debug.h"
+#include "gtd-animation-enums.h"
+#include "gtd-interval.h"
+#include "gtd-timeline.h"
+#include "gtd-property-transition.h"
+
+#include <graphene-gobject.h>
+#include <gobject/gvaluecollector.h>
+
+enum
+{
+  X,
+  Y,
+  Z,
+};
+
+typedef struct
+{
+  guint easing_duration;
+  guint easing_delay;
+  GtdEaseMode easing_mode;
+} AnimationState;
+
+typedef struct
+{
+  struct {
+    GHashTable *transitions;
+    GArray *states;
+    AnimationState *current_state;
+  } animation;
+
+  graphene_point3d_t  pivot_point;
+  gfloat              rotation[3];
+  gfloat              scale[3];
+  graphene_point3d_t  translation;
+
+  GskTransform       *cached_transform;
+} GtdWidgetPrivate;
+
+static void set_animatable_property (GtdWidget    *self,
+                                     guint         prop_id,
+                                     const GValue *value,
+                                     GParamSpec   *pspec);
+
+static void gtd_animatable_iface_init (GtdAnimatableInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GtdWidget, gtd_widget, GTK_TYPE_WIDGET,
+                         G_ADD_PRIVATE (GtdWidget)
+                         G_IMPLEMENT_INTERFACE (GTD_TYPE_ANIMATABLE, gtd_animatable_iface_init))
+
+enum
+{
+  PROP_0,
+  PROP_PIVOT_POINT,
+  PROP_ROTATION_X,
+  PROP_ROTATION_Y,
+  PROP_ROTATION_Z,
+  PROP_SCALE_X,
+  PROP_SCALE_Y,
+  PROP_SCALE_Z,
+  PROP_TRANSLATION_X,
+  PROP_TRANSLATION_Y,
+  PROP_TRANSLATION_Z,
+  N_PROPS
+};
+
+enum
+{
+  TRANSITION_STOPPED,
+  TRANSITIONS_COMPLETED,
+  NUM_SIGNALS
+};
+
+
+static guint signals[NUM_SIGNALS] = { 0, };
+
+static GParamSpec *properties [N_PROPS] = { NULL, };
+
+
+/*
+ * Auxiliary methods
+ */
+
+typedef struct
+{
+  GtdWidget *widget;
+  GtdTransition *transition;
+  gchar *name;
+  gulong completed_id;
+} TransitionClosure;
+
+static void
+transition_closure_free (gpointer data)
+{
+  if (G_LIKELY (data != NULL))
+    {
+      TransitionClosure *closure = data;
+      GtdTimeline *timeline;
+
+      timeline = GTD_TIMELINE (closure->transition);
+
+      /* we disconnect the signal handler before stopping the timeline,
+       * so that we don't end up inside on_transition_stopped() from
+       * a call to g_hash_table_remove().
+       */
+      g_clear_signal_handler (&closure->completed_id, closure->transition);
+
+      if (gtd_timeline_is_playing (timeline))
+        gtd_timeline_stop (timeline);
+
+      g_object_unref (closure->transition);
+
+      g_free (closure->name);
+
+      g_slice_free (TransitionClosure, closure);
+    }
+}
+
+static void
+on_transition_stopped_cb (GtdTransition     *transition,
+                          gboolean           is_finished,
+                          TransitionClosure *closure)
+{
+  GtdWidget *self = closure->widget;
+  GtdWidgetPrivate *priv = gtd_widget_get_instance_private (self);
+  GQuark t_quark;
+  gchar *t_name;
+
+  if (closure->name == NULL)
+    return;
+
+  /* we need copies because we emit the signal after the
+   * TransitionClosure data structure has been freed
+   */
+  t_quark = g_quark_from_string (closure->name);
+  t_name = g_strdup (closure->name);
+
+  if (gtd_transition_get_remove_on_complete (transition))
+    {
+      /* this is safe, because the timeline has now stopped,
+       * so we won't recurse; the reference on the Animatable
+       * will be dropped by the ::stopped signal closure in
+       * GtdTransition, which is RUN_LAST, and thus will
+       * be called after this handler
+       */
+      g_hash_table_remove (priv->animation.transitions, closure->name);
+    }
+
+  /* we emit the ::transition-stopped after removing the
+   * transition, so that we can chain up new transitions
+   * without interfering with the one that just finished
+   */
+  g_signal_emit (self, signals[TRANSITION_STOPPED], t_quark, t_name, is_finished);
+
+  g_free (t_name);
+
+  /* if it's the last transition then we clean up */
+  if (g_hash_table_size (priv->animation.transitions) == 0)
+    {
+      g_hash_table_unref (priv->animation.transitions);
+      priv->animation.transitions = NULL;
+
+      GTD_TRACE_MSG ("[animation] Transitions for '%p' completed", self);
+
+      g_signal_emit (self, signals[TRANSITIONS_COMPLETED], 0);
+    }
+}
+
+static void
+add_transition_to_widget (GtdWidget     *self,
+                          const gchar   *name,
+                          GtdTransition *transition)
+{
+  GtdWidgetPrivate *priv = gtd_widget_get_instance_private (self);
+  TransitionClosure *closure;
+  GtdTimeline *timeline;
+
+  GTD_ENTRY;
+
+  if (!priv->animation.transitions)
+    {
+      priv->animation.transitions = g_hash_table_new_full (g_str_hash,
+                                                           g_str_equal,
+                                                           NULL,
+                                                           transition_closure_free);
+    }
+
+  if (g_hash_table_lookup (priv->animation.transitions, name) != NULL)
+    {
+      g_warning ("A transition with name '%s' already exists for the widget '%p'",
+                 name,
+                 self);
+      GTD_RETURN ();
+    }
+
+  gtd_transition_set_animatable (transition, GTD_ANIMATABLE (self));
+
+  timeline = GTD_TIMELINE (transition);
+
+  closure = g_slice_new (TransitionClosure);
+  closure->widget = self;
+  closure->transition = g_object_ref (transition);
+  closure->name = g_strdup (name);
+  closure->completed_id = g_signal_connect (timeline,
+                                            "stopped",
+                                            G_CALLBACK (on_transition_stopped_cb),
+                                            closure);
+
+  GTD_TRACE_MSG ("[animation] Adding transition '%s' [%p] to widget %p",
+                closure->name,
+                closure->transition,
+                self);
+
+  g_hash_table_insert (priv->animation.transitions, closure->name, closure);
+  gtd_timeline_start (timeline);
+
+  GTD_EXIT;
+}
+
+static gboolean
+should_skip_implicit_transition (GtdWidget  *self,
+                                 GParamSpec *pspec)
+{
+  GtdWidgetPrivate *priv = gtd_widget_get_instance_private (self);
+
+  /* if the easing state has a non-zero duration we always want an
+   * implicit transition to occur
+   */
+  if (priv->animation.current_state->easing_duration == 0)
+    return TRUE;
+
+  /* if the widget is not mapped and is not part of a branch of the scene
+   * graph that is being cloned, then we always skip implicit transitions
+   * on the account of the fact that the widget is not going to be visible
+   * when those transitions happen
+   */
+  if (!gtk_widget_get_mapped (GTK_WIDGET (self)))
+    return TRUE;
+
+  return FALSE;
+}
+
+static GtdTransition*
+create_transition (GtdWidget  *self,
+                   GParamSpec *pspec,
+                   ...)
+{
+  GtdWidgetPrivate *priv = gtd_widget_get_instance_private (self);
+  g_autofree gchar *error = NULL;
+  g_auto (GValue) initial = G_VALUE_INIT;
+  g_auto (GValue) final = G_VALUE_INIT;
+  TransitionClosure *closure;
+  GtdTimeline *timeline;
+  GtdInterval *interval;
+  GtdTransition *res = NULL;
+  va_list var_args;
+  GType ptype;
+
+  g_assert (pspec != NULL);
+
+  if (!priv->animation.transitions)
+    {
+      priv->animation.transitions = g_hash_table_new_full (g_str_hash,
+                                                           g_str_equal,
+                                                           NULL,
+                                                           transition_closure_free);
+    }
+
+  va_start (var_args, pspec);
+
+  ptype = G_PARAM_SPEC_VALUE_TYPE (pspec);
+
+  G_VALUE_COLLECT_INIT (&initial, ptype, var_args, 0, &error);
+  if (error != NULL)
+    {
+      g_critical ("%s: %s", G_STRLOC, error);
+      goto out;
+    }
+
+  G_VALUE_COLLECT_INIT (&final, ptype, var_args, 0, &error);
+  if (error != NULL)
+    {
+      g_critical ("%s: %s", G_STRLOC, error);
+      goto out;
+    }
+
+  if (should_skip_implicit_transition (self, pspec))
+    {
+      GTD_TRACE_MSG ("[animation] Skipping implicit transition for '%p::%s'",
+                    self,
+                    pspec->name);
+
+      /* remove a transition, if one exists */
+      gtd_widget_remove_transition (self, pspec->name);
+
+      /* we don't go through the Animatable interface because we
+       * already know we got here through an animatable property.
+       */
+      set_animatable_property (self, pspec->param_id, &final, pspec);
+
+      goto out;
+    }
+
+  closure = g_hash_table_lookup (priv->animation.transitions, pspec->name);
+  if (closure == NULL)
+    {
+      res = gtd_property_transition_new (pspec->name);
+
+      gtd_transition_set_remove_on_complete (res, TRUE);
+
+      interval = gtd_interval_new_with_values (ptype, &initial, &final);
+      gtd_transition_set_interval (res, interval);
+
+      timeline = GTD_TIMELINE (res);
+      gtd_timeline_set_delay (timeline, priv->animation.current_state->easing_delay);
+      gtd_timeline_set_duration (timeline, priv->animation.current_state->easing_duration);
+      gtd_timeline_set_progress_mode (timeline, priv->animation.current_state->easing_mode);
+
+      /* this will start the transition as well */
+      add_transition_to_widget (self, pspec->name, res);
+
+      /* the widget now owns the transition */
+      g_object_unref (res);
+    }
+  else
+    {
+      GtdEaseMode cur_mode;
+      guint cur_duration;
+
+      GTD_TRACE_MSG ("[animation] Existing transition for %p:%s",
+                    self,
+                    pspec->name);
+
+      timeline = GTD_TIMELINE (closure->transition);
+
+      cur_duration = gtd_timeline_get_duration (timeline);
+      if (cur_duration != priv->animation.current_state->easing_duration)
+        gtd_timeline_set_duration (timeline, priv->animation.current_state->easing_duration);
+
+      cur_mode = gtd_timeline_get_progress_mode (timeline);
+      if (cur_mode != priv->animation.current_state->easing_mode)
+        gtd_timeline_set_progress_mode (timeline, priv->animation.current_state->easing_mode);
+
+      gtd_timeline_rewind (timeline);
+
+      interval = gtd_transition_get_interval (closure->transition);
+      gtd_interval_set_initial_value (interval, &initial);
+      gtd_interval_set_final_value (interval, &final);
+
+      res = closure->transition;
+    }
+
+out:
+  va_end (var_args);
+
+  return res;
+}
+
+static void
+invalidate_cached_transform (GtdWidget *self)
+{
+  GtdWidgetPrivate *priv = gtd_widget_get_instance_private (self);
+
+  g_clear_pointer (&priv->cached_transform, gsk_transform_unref);
+}
+
+static void
+calculate_transform (GtdWidget *self)
+{
+  GtdWidgetPrivate *priv = gtd_widget_get_instance_private (self);
+  graphene_point3d_t pivot;
+  GskTransform *transform;
+  gboolean pivot_is_zero;
+  gint height;
+  gint width;
+
+  transform = NULL;
+  width = gtk_widget_get_width (GTK_WIDGET (self));
+  height = gtk_widget_get_height (GTK_WIDGET (self));
+
+  /* Pivot point */
+  pivot_is_zero = graphene_point3d_equal (&priv->pivot_point, graphene_point3d_zero ());
+  pivot = GRAPHENE_POINT3D_INIT (width * priv->pivot_point.x,
+                                 height * priv->pivot_point.y,
+                                 priv->pivot_point.z);
+  if (!pivot_is_zero)
+    transform = gsk_transform_translate_3d (transform, &pivot);
+
+  /* Perspective */
+  transform = gsk_transform_perspective (transform, 2 * MAX (width, height));
+
+  /* Translation */
+  if (G_APPROX_VALUE (priv->translation.z, 0.f, FLT_EPSILON))
+    {
+      transform = gsk_transform_translate (transform,
+                                           &GRAPHENE_POINT_INIT (priv->translation.x,
+                                                                 priv->translation.y));
+    }
+  else
+    {
+      transform = gsk_transform_translate_3d (transform, &priv->translation);
+    }
+
+  /* Scale */
+  if (G_APPROX_VALUE (priv->scale[Z], 1.f, FLT_EPSILON))
+    transform = gsk_transform_scale (transform, priv->scale[X], priv->scale[Y]);
+  else
+    transform = gsk_transform_scale_3d (transform, priv->scale[X], priv->scale[Y], priv->scale[Z]);
+
+  /* Rotation */
+  transform = gsk_transform_rotate_3d (transform, priv->rotation[X], graphene_vec3_x_axis ());
+  transform = gsk_transform_rotate_3d (transform, priv->rotation[Y], graphene_vec3_y_axis ());
+  transform = gsk_transform_rotate_3d (transform, priv->rotation[Z], graphene_vec3_z_axis ());
+
+  /* Rollback pivot point */
+  if (!pivot_is_zero)
+    transform = gsk_transform_translate_3d (transform,
+                                            &GRAPHENE_POINT3D_INIT (-pivot.x,
+                                                                    -pivot.y,
+                                                                    -pivot.z));
+
+  priv->cached_transform = transform;
+}
+
+static void
+set_rotation_internal (GtdWidget *self,
+                       gfloat     rotation_x,
+                       gfloat     rotation_y,
+                       gfloat     rotation_z)
+{
+  GtdWidgetPrivate *priv;
+  gboolean changed[3];
+
+  GTD_ENTRY;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  changed[X] = !G_APPROX_VALUE (priv->rotation[X], rotation_x, FLT_EPSILON);
+  changed[Y] = !G_APPROX_VALUE (priv->rotation[Y], rotation_y, FLT_EPSILON);
+  changed[Z] = !G_APPROX_VALUE (priv->rotation[Z], rotation_z, FLT_EPSILON);
+
+  if (!changed[X] && !changed[Y] && !changed[Z])
+    GTD_RETURN ();
+
+  invalidate_cached_transform (self);
+
+  priv->rotation[X] = rotation_x;
+  priv->rotation[Y] = rotation_y;
+  priv->rotation[Z] = rotation_z;
+
+  if (changed[X])
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ROTATION_X]);
+
+  if (changed[Y])
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ROTATION_Y]);
+
+  if (changed[Z])
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ROTATION_Z]);
+
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  GTD_EXIT;
+}
+
+static void
+set_scale_internal (GtdWidget *self,
+                    gfloat     scale_x,
+                    gfloat     scale_y,
+                    gfloat     scale_z)
+{
+  GtdWidgetPrivate *priv;
+  gboolean changed[3];
+
+  GTD_ENTRY;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  changed[X] = !G_APPROX_VALUE (priv->scale[X], scale_x, FLT_EPSILON);
+  changed[Y] = !G_APPROX_VALUE (priv->scale[Y], scale_y, FLT_EPSILON);
+  changed[Z] = !G_APPROX_VALUE (priv->scale[Z], scale_z, FLT_EPSILON);
+
+  if (!changed[X] && !changed[Y] && !changed[Z])
+    GTD_RETURN ();
+
+  invalidate_cached_transform (self);
+
+  priv->scale[X] = scale_x;
+  priv->scale[Y] = scale_y;
+  priv->scale[Z] = scale_z;
+
+  if (changed[X])
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SCALE_X]);
+
+  if (changed[Y])
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SCALE_Y]);
+
+  if (changed[Z])
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SCALE_Z]);
+
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  GTD_EXIT;
+}
+
+static void
+set_translation_internal (GtdWidget *self,
+                          gfloat     translation_x,
+                          gfloat     translation_y,
+                          gfloat     translation_z)
+{
+  graphene_point3d_t old_translation, translation;
+  GtdWidgetPrivate *priv;
+
+  GTD_ENTRY;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+  translation = GRAPHENE_POINT3D_INIT (translation_x, translation_y, translation_z);
+
+  if (graphene_point3d_equal (&priv->translation, &translation))
+    GTD_RETURN ();
+
+  old_translation = priv->translation;
+
+  invalidate_cached_transform (self);
+  priv->translation = translation;
+
+  if (!G_APPROX_VALUE (old_translation.x, translation.x, FLT_EPSILON))
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TRANSLATION_X]);
+
+  if (!G_APPROX_VALUE (old_translation.y, translation.y, FLT_EPSILON))
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TRANSLATION_Y]);
+
+  if (!G_APPROX_VALUE (old_translation.y, translation.y, FLT_EPSILON))
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TRANSLATION_Z]);
+
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  GTD_EXIT;
+}
+
+static void
+set_animatable_property (GtdWidget    *self,
+                         guint         prop_id,
+                         const GValue *value,
+                         GParamSpec   *pspec)
+{
+  GtdWidgetPrivate *priv = gtd_widget_get_instance_private (self);
+  GObject *object = G_OBJECT (self);
+
+  g_object_freeze_notify (object);
+
+  switch (prop_id)
+    {
+    case PROP_ROTATION_X:
+      set_rotation_internal (self, g_value_get_float (value), priv->rotation[Y], priv->rotation[Z]);
+      break;
+
+    case PROP_ROTATION_Y:
+      set_rotation_internal (self, priv->rotation[X], g_value_get_float (value), priv->rotation[Z]);
+      break;
+
+    case PROP_ROTATION_Z:
+      set_rotation_internal (self, priv->rotation[X], priv->rotation[Y], g_value_get_float (value));
+      break;
+
+    case PROP_SCALE_X:
+      set_scale_internal (self, g_value_get_float (value), priv->scale[Y], priv->scale[Z]);
+      break;
+
+    case PROP_SCALE_Y:
+      set_scale_internal (self, priv->scale[X], g_value_get_float (value), priv->scale[Z]);
+      break;
+
+    case PROP_SCALE_Z:
+      set_scale_internal (self, priv->scale[X], priv->scale[Y], g_value_get_float (value));
+      break;
+
+    case PROP_TRANSLATION_X:
+      set_translation_internal (self, g_value_get_float (value), priv->translation.y, priv->translation.z);
+      break;
+
+    case PROP_TRANSLATION_Y:
+      set_translation_internal (self, priv->translation.x, g_value_get_float (value), priv->translation.z);
+      break;
+
+    case PROP_TRANSLATION_Z:
+      set_translation_internal (self, priv->translation.x, priv->translation.y, g_value_get_float (value));
+      break;
+
+    default:
+      g_object_set_property (object, pspec->name, value);
+      break;
+    }
+
+  g_object_thaw_notify (object);
+}
+
+/*
+ * GtdAnimatable interface
+ */
+
+static GParamSpec *
+gtd_widget_find_property (GtdAnimatable *animatable,
+                          const gchar   *property_name)
+{
+  return g_object_class_find_property (G_OBJECT_GET_CLASS (animatable), property_name);
+}
+
+static void
+gtd_widget_get_initial_state (GtdAnimatable *animatable,
+                              const gchar   *property_name,
+                              GValue        *initial)
+{
+  g_object_get_property (G_OBJECT (animatable), property_name, initial);
+}
+
+static void
+gtd_widget_set_final_state (GtdAnimatable *animatable,
+                            const gchar   *property_name,
+                            const GValue  *final)
+{
+  GObjectClass *obj_class = G_OBJECT_GET_CLASS (animatable);
+  GParamSpec *pspec;
+
+  pspec = g_object_class_find_property (obj_class, property_name);
+
+  if (pspec)
+    set_animatable_property (GTD_WIDGET (animatable), pspec->param_id, final, pspec);
+}
+
+static GtdWidget*
+gtd_widget_get_widget (GtdAnimatable *animatable)
+{
+  return GTD_WIDGET (animatable);
+}
+
+static void
+gtd_animatable_iface_init (GtdAnimatableInterface *iface)
+{
+  iface->find_property = gtd_widget_find_property;
+  iface->get_initial_state = gtd_widget_get_initial_state;
+  iface->set_final_state = gtd_widget_set_final_state;
+  iface->get_widget = gtd_widget_get_widget;
+}
+
+
+/*
+ * GObject overrides
+ */
+
+static void
+gtd_widget_dispose (GObject *object)
+{
+  GtdWidget *self = GTD_WIDGET (object);
+  GtkWidget *child = gtk_widget_get_first_child (GTK_WIDGET (object));
+
+  while (child)
+    {
+      GtkWidget *next = gtk_widget_get_next_sibling (child);
+
+      gtk_widget_unparent (child);
+      child = next;
+    }
+
+  invalidate_cached_transform (self);
+  gtd_widget_remove_all_transitions (self);
+
+  G_OBJECT_CLASS (gtd_widget_parent_class)->dispose (object);
+}
+
+static void
+gtd_widget_get_property (GObject    *object,
+                         guint       prop_id,
+                         GValue     *value,
+                         GParamSpec *pspec)
+{
+  GtdWidget *self = GTD_WIDGET (object);
+  GtdWidgetPrivate *priv = gtd_widget_get_instance_private (self);
+
+  switch (prop_id)
+    {
+    case PROP_PIVOT_POINT:
+      g_value_set_boxed (value, &priv->pivot_point);
+      break;
+
+    case PROP_ROTATION_X:
+      g_value_set_float (value, priv->rotation[X]);
+      break;
+
+    case PROP_ROTATION_Y:
+      g_value_set_float (value, priv->rotation[Y]);
+      break;
+
+    case PROP_ROTATION_Z:
+      g_value_set_float (value, priv->rotation[Z]);
+      break;
+
+    case PROP_SCALE_X:
+      g_value_set_float (value, priv->scale[X]);
+      break;
+
+    case PROP_SCALE_Y:
+      g_value_set_float (value, priv->scale[Y]);
+      break;
+
+    case PROP_SCALE_Z:
+      g_value_set_float (value, priv->scale[Z]);
+      break;
+
+    case PROP_TRANSLATION_X:
+      g_value_set_float (value, priv->translation.x);
+      break;
+
+    case PROP_TRANSLATION_Y:
+      g_value_set_float (value, priv->translation.y);
+      break;
+
+    case PROP_TRANSLATION_Z:
+      g_value_set_float (value, priv->translation.z);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtd_widget_set_property (GObject      *object,
+                         guint         prop_id,
+                         const GValue *value,
+                         GParamSpec   *pspec)
+{
+  GtdWidget *self = GTD_WIDGET (object);
+  GtdWidgetPrivate *priv = gtd_widget_get_instance_private (self);
+
+  switch (prop_id)
+    {
+    case PROP_PIVOT_POINT:
+      gtd_widget_set_pivot_point (self, g_value_get_boxed (value));
+      break;
+
+    case PROP_ROTATION_X:
+      gtd_widget_set_rotation (self, g_value_get_float (value), priv->rotation[Y], priv->rotation[Z]);
+      break;
+
+    case PROP_ROTATION_Y:
+      gtd_widget_set_rotation (self, priv->rotation[X], g_value_get_float (value), priv->rotation[Z]);
+      break;
+
+    case PROP_ROTATION_Z:
+      gtd_widget_set_rotation (self, priv->rotation[X], priv->rotation[Y], g_value_get_float (value));
+      break;
+
+    case PROP_SCALE_X:
+      gtd_widget_set_scale (self, g_value_get_float (value), priv->scale[Y], priv->scale[Z]);
+      break;
+
+    case PROP_SCALE_Y:
+      gtd_widget_set_scale (self, priv->scale[X], g_value_get_float (value), priv->scale[Z]);
+      break;
+
+    case PROP_SCALE_Z:
+      gtd_widget_set_scale (self, priv->scale[X], priv->scale[Y], g_value_get_float (value));
+      break;
+
+    case PROP_TRANSLATION_X:
+      gtd_widget_set_translation (self, g_value_get_float (value), priv->translation.y, priv->translation.z);
+      break;
+
+    case PROP_TRANSLATION_Y:
+      gtd_widget_set_translation (self, priv->translation.x, g_value_get_float (value), priv->translation.z);
+      break;
+
+    case PROP_TRANSLATION_Z:
+      gtd_widget_set_translation (self, priv->translation.x, priv->translation.y, g_value_get_float (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtd_widget_class_init (GtdWidgetClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->dispose = gtd_widget_dispose;
+  object_class->get_property = gtd_widget_get_property;
+  object_class->set_property = gtd_widget_set_property;
+
+  /**
+   * GtdWidget:
+   */
+  properties[PROP_PIVOT_POINT] = g_param_spec_boxed ("pivot-point",
+                                                     "Pivot point",
+                                                     "Pivot point",
+                                                     GRAPHENE_TYPE_POINT3D,
+                                                     G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdWidget:rotation-x
+   */
+  properties[PROP_ROTATION_X] = g_param_spec_float ("rotation-x",
+                                                    "Rotation in the X axis",
+                                                    "Rotation in the X axis",
+                                                    -G_MAXFLOAT,
+                                                    G_MAXFLOAT,
+                                                    0.f,
+                                                    G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdWidget:rotation-y
+   */
+  properties[PROP_ROTATION_Y] = g_param_spec_float ("rotation-y",
+                                                    "Rotation in the Y axis",
+                                                    "Rotation in the Y axis",
+                                                    -G_MAXFLOAT,
+                                                    G_MAXFLOAT,
+                                                    0.f,
+                                                    G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdWidget:rotation-z
+   */
+  properties[PROP_ROTATION_Z] = g_param_spec_float ("rotation-z",
+                                                    "Rotation in the Z axis",
+                                                    "Rotation in the Z axis",
+                                                    -G_MAXFLOAT,
+                                                    G_MAXFLOAT,
+                                                    0.f,
+                                                    G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdWidget:scale-x
+   */
+  properties[PROP_SCALE_X] = g_param_spec_float ("scale-x",
+                                                 "Scale in the X axis",
+                                                 "Scale in the X axis",
+                                                 -G_MAXFLOAT,
+                                                 G_MAXFLOAT,
+                                                 1.f,
+                                                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdWidget:scale-y
+   */
+  properties[PROP_SCALE_Y] = g_param_spec_float ("scale-y",
+                                                 "Scale in the Y axis",
+                                                 "Scale in the Y axis",
+                                                 -G_MAXFLOAT,
+                                                 G_MAXFLOAT,
+                                                 1.f,
+                                                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdWidget:scale-z
+   */
+  properties[PROP_SCALE_Z] = g_param_spec_float ("scale-z",
+                                                 "Scale in the Z axis",
+                                                 "Scale in the Z axis",
+                                                 -G_MAXFLOAT,
+                                                 G_MAXFLOAT,
+                                                 1.f,
+                                                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdWidget:translation-x
+   */
+  properties[PROP_TRANSLATION_X] = g_param_spec_float ("translation-x",
+                                                       "Translation in the X axis",
+                                                       "Translation in the X axis",
+                                                       -G_MAXFLOAT,
+                                                       G_MAXFLOAT,
+                                                       0.f,
+                                                       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdWidget:translation-y
+   */
+  properties[PROP_TRANSLATION_Y] = g_param_spec_float ("translation-y",
+                                                       "Translation in the Y axis",
+                                                       "Translation in the Y axis",
+                                                       -G_MAXFLOAT,
+                                                       G_MAXFLOAT,
+                                                       0.f,
+                                                       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdWidget:translation-z
+   */
+  properties[PROP_TRANSLATION_Z] = g_param_spec_float ("translation-z",
+                                                       "Translation in the Z axis",
+                                                       "Translation in the Z axis",
+                                                       -G_MAXFLOAT,
+                                                       G_MAXFLOAT,
+                                                       0.f,
+                                                       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class, N_PROPS, properties);
+
+  /**
+   * GtdWidget::transitions-completed:
+   * @actor: a #GtdWidget
+   *
+   * The ::transitions-completed signal is emitted once all transitions
+   * involving @actor are complete.
+   *
+   * Since: 1.10
+   */
+  signals[TRANSITIONS_COMPLETED] =
+    g_signal_new ("transitions-completed",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE,
+                  0);
+
+  /**
+   * GtdWidget::transition-stopped:
+   * @actor: a #GtdWidget
+   * @name: the name of the transition
+   * @is_finished: whether the transition was finished, or stopped
+   *
+   * The ::transition-stopped signal is emitted once a transition
+   * is stopped; a transition is stopped once it reached its total
+   * duration (including eventual repeats), it has been stopped
+   * using gtd_timeline_stop(), or it has been removed from the
+   * transitions applied on @actor, using gtd_actor_remove_transition().
+   *
+   * Since: 1.12
+   */
+  signals[TRANSITION_STOPPED] =
+    g_signal_new ("transition-stopped",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE |
+                  G_SIGNAL_NO_HOOKS | G_SIGNAL_DETAILED,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE,
+                  2,
+                  G_TYPE_STRING,
+                  G_TYPE_BOOLEAN);
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTD_TYPE_BIN_LAYOUT);
+}
+
+static void
+gtd_widget_init (GtdWidget *self)
+{
+  GtdWidgetPrivate *priv = gtd_widget_get_instance_private (self);
+
+  priv->scale[X] = 1.f;
+  priv->scale[Y] = 1.f;
+  priv->scale[Z] = 1.f;
+
+  priv->pivot_point = GRAPHENE_POINT3D_INIT (0.5, 0.5, 0.f);
+
+  gtd_widget_save_easing_state (self);
+  gtd_widget_set_easing_duration (self, 0);
+}
+
+GtkWidget*
+gtd_widget_new (void)
+{
+  return g_object_new (GTD_TYPE_WIDGET, NULL);
+}
+
+/**
+ */
+void
+gtd_widget_get_pivot_point (GtdWidget          *self,
+                            graphene_point3d_t *out_pivot_point)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+  g_return_if_fail (out_pivot_point != NULL);
+
+  priv = gtd_widget_get_instance_private (self);
+  *out_pivot_point = priv->pivot_point;
+}
+
+/**
+ */
+void
+gtd_widget_set_pivot_point (GtdWidget                *self,
+                            const graphene_point3d_t *pivot_point)
+{
+  GtdWidgetPrivate *priv;
+
+  GTD_ENTRY;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+  g_return_if_fail (pivot_point != NULL);
+  g_return_if_fail (pivot_point->x >= 0.f && pivot_point->x <= 1.0);
+  g_return_if_fail (pivot_point->y >= 0.f && pivot_point->y <= 1.0);
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (graphene_point3d_equal (&priv->pivot_point, pivot_point))
+    GTD_RETURN ();
+
+  invalidate_cached_transform (self);
+  priv->pivot_point = *pivot_point;
+
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  GTD_EXIT;
+}
+
+/**
+ */
+void
+gtd_widget_get_rotation (GtdWidget *self,
+                         gfloat    *rotation_x,
+                         gfloat    *rotation_y,
+                         gfloat    *rotation_z)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (rotation_x)
+    *rotation_x = priv->rotation[X];
+
+  if (rotation_y)
+    *rotation_y = priv->rotation[Y];
+
+  if (rotation_z)
+    *rotation_z = priv->rotation[Z];
+}
+
+/**
+ */
+void
+gtd_widget_set_rotation (GtdWidget *self,
+                         gfloat     rotation_x,
+                         gfloat     rotation_y,
+                         gfloat     rotation_z)
+{
+  GtdWidgetPrivate *priv;
+  gboolean changed[3];
+
+  GTD_ENTRY;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  changed[X] = !G_APPROX_VALUE (priv->rotation[X], rotation_x, FLT_EPSILON);
+  changed[Y] = !G_APPROX_VALUE (priv->rotation[Y], rotation_y, FLT_EPSILON);
+  changed[Z] = !G_APPROX_VALUE (priv->rotation[Z], rotation_z, FLT_EPSILON);
+
+  if (!changed[X] && !changed[Y] && !changed[Z])
+    GTD_RETURN ();
+
+  if (changed[X])
+    create_transition (self, properties[PROP_ROTATION_X], priv->rotation[X], rotation_x);
+
+  if (changed[Y])
+    create_transition (self, properties[PROP_ROTATION_Y], priv->rotation[Y], rotation_y);
+
+  if (changed[Z])
+    create_transition (self, properties[PROP_ROTATION_Z], priv->rotation[Z], rotation_z);
+
+  GTD_EXIT;
+}
+
+/**
+ */
+void
+gtd_widget_get_scale (GtdWidget *self,
+                      gfloat    *scale_x,
+                      gfloat    *scale_y,
+                      gfloat    *scale_z)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (scale_x)
+    *scale_x = priv->scale[0];
+
+  if (scale_y)
+    *scale_y = priv->scale[1];
+
+  if (scale_z)
+    *scale_z = priv->scale[2];
+}
+
+/**
+ */
+void
+gtd_widget_set_scale (GtdWidget *self,
+                      gfloat     scale_x,
+                      gfloat     scale_y,
+                      gfloat     scale_z)
+{
+  GtdWidgetPrivate *priv;
+  gboolean changed[3];
+
+  GTD_ENTRY;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  changed[X] = !G_APPROX_VALUE (priv->scale[X], scale_x, FLT_EPSILON);
+  changed[Y] = !G_APPROX_VALUE (priv->scale[Y], scale_y, FLT_EPSILON);
+  changed[Z] = !G_APPROX_VALUE (priv->scale[Z], scale_z, FLT_EPSILON);
+
+  if (!changed[X] && !changed[Y] && !changed[Z])
+    GTD_RETURN ();
+
+  if (changed[X])
+    create_transition (self, properties[PROP_SCALE_X], priv->scale[X], scale_x);
+
+  if (changed[Y])
+    create_transition (self, properties[PROP_SCALE_Y], priv->scale[Y], scale_y);
+
+  if (changed[Z])
+    create_transition (self, properties[PROP_SCALE_Z], priv->scale[Z], scale_z);
+
+  GTD_EXIT;
+}
+
+/**
+ */
+void
+gtd_widget_get_translation (GtdWidget *self,
+                            gfloat    *translation_x,
+                            gfloat    *translation_y,
+                            gfloat    *translation_z)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (translation_x)
+    *translation_x = priv->translation.x;
+
+  if (translation_y)
+    *translation_y = priv->translation.y;
+
+  if (translation_z)
+    *translation_z = priv->translation.z;
+}
+
+/**
+ */
+void
+gtd_widget_set_translation (GtdWidget *self,
+                            gfloat     translation_x,
+                            gfloat     translation_y,
+                            gfloat     translation_z)
+{
+  graphene_point3d_t translation;
+  GtdWidgetPrivate *priv;
+
+  GTD_ENTRY;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+  translation = GRAPHENE_POINT3D_INIT (translation_x, translation_y, translation_z);
+
+  if (graphene_point3d_equal (&priv->translation, &translation))
+    GTD_RETURN ();
+
+  if (!G_APPROX_VALUE (priv->translation.x, translation.x, FLT_EPSILON))
+    create_transition (self, properties[PROP_TRANSLATION_X], priv->translation.x, translation_x);
+
+  if (!G_APPROX_VALUE (priv->translation.y, translation.y, FLT_EPSILON))
+    create_transition (self, properties[PROP_TRANSLATION_Y], priv->translation.y, translation_y);
+
+  if (!G_APPROX_VALUE (priv->translation.y, translation.y, FLT_EPSILON))
+    create_transition (self, properties[PROP_TRANSLATION_Z], priv->translation.z, translation_z);
+
+  GTD_EXIT;
+}
+
+/**
+ */
+GskTransform*
+gtd_widget_apply_transform (GtdWidget    *self,
+                            GskTransform *transform)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_val_if_fail (GTD_IS_WIDGET (self), NULL);
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (!priv->cached_transform)
+    calculate_transform (self);
+
+  if (!transform)
+    return gsk_transform_ref (priv->cached_transform);
+
+  return gsk_transform_transform (transform, priv->cached_transform);
+}
+
+/**
+ * gtd_widget_add_transition:
+ * @self: a #GtdWidget
+ * @name: the name of the transition to add
+ * @transition: the #GtdTransition to add
+ *
+ * Adds a @transition to the #GtdWidget's list of animations.
+ *
+ * The @name string is a per-widget unique identifier of the @transition: only
+ * one #GtdTransition can be associated to the specified @name.
+ *
+ * The @transition will be started once added.
+ *
+ * This function will take a reference on the @transition.
+ *
+ * This function is usually called implicitly when modifying an animatable
+ * property.
+ *
+ * Since: 1.10
+ */
+void
+gtd_widget_add_transition (GtdWidget     *self,
+                           const gchar   *name,
+                           GtdTransition *transition)
+{
+  g_return_if_fail (GTD_IS_WIDGET (self));
+  g_return_if_fail (name != NULL);
+  g_return_if_fail (GTD_IS_TRANSITION (transition));
+
+  add_transition_to_widget (self, name, transition);
+}
+
+/**
+ * gtd_widget_remove_transition:
+ * @self: a #GtdWidget
+ * @name: the name of the transition to remove
+ *
+ * Removes the transition stored inside a #GtdWidget using @name
+ * identifier.
+ *
+ * If the transition is currently in progress, it will be stopped.
+ *
+ * This function releases the reference acquired when the transition
+ * was added to the #GtdWidget.
+ *
+ * Since: 1.10
+ */
+void
+gtd_widget_remove_transition (GtdWidget   *self,
+                              const gchar *name)
+{
+  GtdWidgetPrivate *priv;
+  TransitionClosure *closure;
+  gboolean was_playing;
+  GQuark t_quark;
+  gchar *t_name;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+  g_return_if_fail (name != NULL);
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (priv->animation.transitions == NULL)
+    return;
+
+  closure = g_hash_table_lookup (priv->animation.transitions, name);
+  if (closure == NULL)
+    return;
+
+  was_playing =
+    gtd_timeline_is_playing (GTD_TIMELINE (closure->transition));
+  t_quark = g_quark_from_string (closure->name);
+  t_name = g_strdup (closure->name);
+
+  g_hash_table_remove (priv->animation.transitions, name);
+
+  /* we want to maintain the invariant that ::transition-stopped is
+   * emitted after the transition has been removed, to allow replacing
+   * or chaining; removing the transition from the hash table will
+   * stop it, but transition_closure_free() will disconnect the signal
+   * handler we install in add_transition_internal(), to avoid loops
+   * or segfaults.
+   *
+   * since we know already that a transition will stop once it's removed
+   * from an widget, we can simply emit the ::transition-stopped here
+   * ourselves, if the timeline was playing (if it wasn't, then the
+   * signal was already emitted at least once).
+   */
+  if (was_playing)
+    g_signal_emit (self, signals[TRANSITION_STOPPED], t_quark, t_name, FALSE);
+
+  g_free (t_name);
+}
+
+/**
+ * gtd_widget_remove_all_transitions:
+ * @self: a #GtdWidget
+ *
+ * Removes all transitions associated to @self.
+ *
+ * Since: 1.10
+ */
+void
+gtd_widget_remove_all_transitions (GtdWidget *self)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+  if (priv->animation.transitions == NULL)
+    return;
+
+  g_hash_table_remove_all (priv->animation.transitions);
+}
+
+/**
+ * gtd_widget_set_easing_duration:
+ * @self: a #GtdWidget
+ * @msecs: the duration of the easing, or %NULL
+ *
+ * Sets the duration of the tweening for animatable properties
+ * of @self for the current easing state.
+ *
+ * Since: 1.10
+ */
+void
+gtd_widget_set_easing_duration (GtdWidget *self,
+                                guint      msecs)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (priv->animation.current_state == NULL)
+    {
+      g_warning ("You must call gtd_widget_save_easing_state() prior "
+                 "to calling gtd_widget_set_easing_duration().");
+      return;
+    }
+
+  if (priv->animation.current_state->easing_duration != msecs)
+    priv->animation.current_state->easing_duration = msecs;
+}
+
+/**
+ * gtd_widget_get_easing_duration:
+ * @self: a #GtdWidget
+ *
+ * Retrieves the duration of the tweening for animatable
+ * properties of @self for the current easing state.
+ *
+ * Return value: the duration of the tweening, in milliseconds
+ *
+ * Since: 1.10
+ */
+guint
+gtd_widget_get_easing_duration (GtdWidget *self)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_val_if_fail (GTD_IS_WIDGET (self), 0);
+
+  priv = gtd_widget_get_instance_private (self);
+  if (priv->animation.current_state != NULL)
+    return priv->animation.current_state->easing_duration;
+
+  return 0;
+}
+
+/**
+ * gtd_widget_set_easing_mode:
+ * @self: a #GtdWidget
+ * @mode: an easing mode, excluding %GTD_CUSTOM_MODE
+ *
+ * Sets the easing mode for the tweening of animatable properties
+ * of @self.
+ *
+ * Since: 1.10
+ */
+void
+gtd_widget_set_easing_mode (GtdWidget   *self,
+                            GtdEaseMode  mode)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+  g_return_if_fail (mode != GTD_CUSTOM_MODE);
+  g_return_if_fail (mode < GTD_EASE_LAST);
+
+  priv = gtd_widget_get_instance_private (self);
+  if (priv->animation.current_state == NULL)
+    {
+      g_warning ("You must call gtd_widget_save_easing_state() prior "
+                 "to calling gtd_widget_set_easing_mode().");
+      return;
+    }
+
+  if (priv->animation.current_state->easing_mode != mode)
+    priv->animation.current_state->easing_mode = mode;
+}
+
+/**
+ * gtd_widget_get_easing_mode:
+ * @self: a #GtdWidget
+ *
+ * Retrieves the easing mode for the tweening of animatable properties
+ * of @self for the current easing state.
+ *
+ * Return value: an easing mode
+ *
+ * Since: 1.10
+ */
+GtdEaseMode
+gtd_widget_get_easing_mode (GtdWidget *self)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_val_if_fail (GTD_IS_WIDGET (self), GTD_EASE_OUT_CUBIC);
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (priv->animation.current_state != NULL)
+    return priv->animation.current_state->easing_mode;
+
+  return GTD_EASE_OUT_CUBIC;
+}
+
+/**
+ * gtd_widget_set_easing_delay:
+ * @self: a #GtdWidget
+ * @msecs: the delay before the start of the tweening, in milliseconds
+ *
+ * Sets the delay that should be applied before tweening animatable
+ * properties.
+ *
+ * Since: 1.10
+ */
+void
+gtd_widget_set_easing_delay (GtdWidget *self,
+                             guint      msecs)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (priv->animation.current_state == NULL)
+    {
+      g_warning ("You must call gtd_widget_save_easing_state() prior "
+                 "to calling gtd_widget_set_easing_delay().");
+      return;
+    }
+
+  if (priv->animation.current_state->easing_delay != msecs)
+    priv->animation.current_state->easing_delay = msecs;
+}
+
+/**
+ * gtd_widget_get_easing_delay:
+ * @self: a #GtdWidget
+ *
+ * Retrieves the delay that should be applied when tweening animatable
+ * properties.
+ *
+ * Return value: a delay, in milliseconds
+ *
+ * Since: 1.10
+ */
+guint
+gtd_widget_get_easing_delay (GtdWidget *self)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_val_if_fail (GTD_IS_WIDGET (self), 0);
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (priv->animation.current_state != NULL)
+    return priv->animation.current_state->easing_delay;
+
+  return 0;
+}
+
+/**
+ * gtd_widget_get_transition:
+ * @self: a #GtdWidget
+ * @name: the name of the transition
+ *
+ * Retrieves the #GtdTransition of a #GtdWidget by using the
+ * transition @name.
+ *
+ * Transitions created for animatable properties use the name of the
+ * property itself, for instance the code below:
+ *
+ * |[<!-- language="C" -->
+ *   gtd_widget_set_easing_duration (widget, 1000);
+ *   gtd_widget_set_rotation_angle (widget, GTD_Y_AXIS, 360.0);
+ *
+ *   transition = gtd_widget_get_transition (widget, "rotation-angle-y");
+ *   g_signal_connect (transition, "stopped",
+ *                     G_CALLBACK (on_transition_stopped),
+ *                     widget);
+ * ]|
+ *
+ * will call the `on_transition_stopped` callback when the transition
+ * is finished.
+ *
+ * If you just want to get notifications of the completion of a transition,
+ * you should use the #GtdWidget::transition-stopped signal, using the
+ * transition name as the signal detail.
+ *
+ * Return value: (transfer none): a #GtdTransition, or %NULL is none
+ *   was found to match the passed name; the returned instance is owned
+ *   by Gtd and it should not be freed
+ */
+GtdTransition *
+gtd_widget_get_transition (GtdWidget   *self,
+                           const gchar *name)
+{
+  TransitionClosure *closure;
+  GtdWidgetPrivate *priv;
+
+  g_return_val_if_fail (GTD_IS_WIDGET (self), NULL);
+  g_return_val_if_fail (name != NULL, NULL);
+
+  priv = gtd_widget_get_instance_private (self);
+  if (priv->animation.transitions == NULL)
+    return NULL;
+
+  closure = g_hash_table_lookup (priv->animation.transitions, name);
+  if (closure == NULL)
+    return NULL;
+
+  return closure->transition;
+}
+
+/**
+ * gtd_widget_has_transitions: (skip)
+ */
+gboolean
+gtd_widget_has_transitions (GtdWidget *self)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_val_if_fail (GTD_IS_WIDGET (self), FALSE);
+
+  priv = gtd_widget_get_instance_private (self);
+  if (priv->animation.transitions == NULL)
+    return FALSE;
+
+  return g_hash_table_size (priv->animation.transitions) > 0;
+}
+
+/**
+ * gtd_widget_save_easing_state:
+ * @self: a #GtdWidget
+ *
+ * Saves the current easing state for animatable properties, and creates
+ * a new state with the default values for easing mode and duration.
+ *
+ * New transitions created after calling this function will inherit the
+ * duration, easing mode, and delay of the new easing state; this also
+ * applies to transitions modified in flight.
+ */
+void
+gtd_widget_save_easing_state (GtdWidget *self)
+{
+  GtdWidgetPrivate *priv;
+  AnimationState new_state;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (priv->animation.states == NULL)
+    priv->animation.states = g_array_new (FALSE, FALSE, sizeof (AnimationState));
+
+  new_state.easing_mode = GTD_EASE_OUT_CUBIC;
+  new_state.easing_duration = 250;
+  new_state.easing_delay = 0;
+
+  g_array_append_val (priv->animation.states, new_state);
+
+  priv->animation.current_state = &g_array_index (priv->animation.states,
+                                    AnimationState,
+                                    priv->animation.states->len - 1);
+}
+
+/**
+ * gtd_widget_restore_easing_state:
+ * @self: a #GtdWidget
+ *
+ * Restores the easing state as it was prior to a call to
+ * gtd_widget_save_easing_state().
+ *
+ * Since: 1.10
+ */
+void
+gtd_widget_restore_easing_state (GtdWidget *self)
+{
+  GtdWidgetPrivate *priv;
+
+  g_return_if_fail (GTD_IS_WIDGET (self));
+
+  priv = gtd_widget_get_instance_private (self);
+
+  if (priv->animation.states == NULL)
+    {
+      g_critical ("The function gtd_widget_restore_easing_state() has "
+                  "been called without a previous call to "
+                  "gtd_widget_save_easing_state().");
+      return;
+    }
+
+  g_array_remove_index (priv->animation.states, priv->animation.states->len - 1);
+
+  if (priv->animation.states->len > 0)
+    priv->animation.current_state = &g_array_index (priv->animation.states, AnimationState, priv->animation.states->len - 1);
+  else
+    {
+      g_array_unref (priv->animation.states);
+      priv->animation.states = NULL;
+      priv->animation.current_state = NULL;
+    }
+}