/*

 * Clutter.

 *

 * An OpenGL based 'interactive canvas' library.

 *

 * Authored By Matthew Allum  <mallum@openedhand.com>

 *

 * Copyright (C) 2006 OpenedHand

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library. If not, see <http://www.gnu.org/licenses/>.

 */

/**

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

 *

 * Each #ClutterTimeline instance has a duration: once a timeline has been

 * started, using clutter_timeline_start(), it will emit a signal that can

 * be used to update the state of the actors.

 *

 * It is important to note that #ClutterTimeline is not a generic API for

 * calling closures after an interval; each Timeline is tied into the master

 * clock used to drive the frame cycle. If you need to schedule a closure

 * after an interval, see clutter_threads_add_timeout() instead.

 *

 * Users of #ClutterTimeline should connect to the #ClutterTimeline::new-frame

 * signal, which is emitted each time a timeline is advanced during the maste

 * clock iteration. The #ClutterTimeline::new-frame signal provides the time

 * elapsed since the beginning of the timeline, in milliseconds. A normalized

 * progress value can be obtained by calling clutter_timeline_get_progress().

 * By using clutter_timeline_get_delta() it is possible to obtain the wallclock

 * time elapsed since the last emission of the #ClutterTimeline::new-frame

 * signal.

 *

 * Initial state can be set up by using the #ClutterTimeline::started signal,

 * while final state can be set up by using the #ClutterTimeline::stopped

 * signal. The #ClutterTimeline guarantees the emission of at least a single

 * #ClutterTimeline::new-frame signal, as well as the emission of the

 * #ClutterTimeline::completed signal every time the #ClutterTimeline reaches

 * its #ClutterTimeline:duration.

 *

 * It is possible to connect to specific points in the timeline progress by

 * adding markers using clutter_timeline_add_marker_at_time() and connecting

 * to the #ClutterTimeline::marker-reached signal.

 *

 * Timelines can be made to loop once they reach the end of their duration, by

 * using clutter_timeline_set_repeat_count(); a looping timeline will still

 * emit the #ClutterTimeline::completed signal once it reaches the end of its

 * duration at each repeat. If you want to be notified of the end of the last

 * repeat, use the #ClutterTimeline::stopped signal.

 *

 * Timelines have a #ClutterTimeline:direction: the default direction is

 * %CLUTTER_TIMELINE_FORWARD, and goes from 0 to the duration; it is possible

 * to change the direction to %CLUTTER_TIMELINE_BACKWARD, and have the timeline

 * go from the duration to 0. The direction can be automatically reversed

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

 *

 * ## Defining Timelines in ClutterScript

 *

 * A #ClutterTimeline can be described in #ClutterScript like any

 * other object. Additionally, it is possible to define markers directly

 * inside the JSON definition by using the `markers` JSON object member,

 * such as:

 *

 * |[

{

  "type" : "ClutterTimeline",

  "duration" : 1000,

  "markers" : [

    { "name" : "quarter", "time" : 250 },

    { "name" : "half-time", "time" : 500 },

    { "name" : "three-quarters", "time" : 750 }

  ]

}

 * ]|

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "clutter-timeline.h"

#include "clutter-debug.h"

#include "clutter-easing.h"

#include "clutter-enum-types.h"

#include "clutter-main.h"

#include "clutter-marshal.h"

#include "clutter-master-clock.h"

#include "clutter-private.h"

#include "clutter-scriptable.h"

#include "deprecated/clutter-timeline.h"

struct _ClutterTimelinePrivate

{

  ClutterTimelineDirection direction;

  guint delay_id;

  /* The total length in milliseconds of this timeline */

  guint duration;

  guint delay;

  /* The current amount of elapsed time */

  gint64 elapsed_time;

  /* The elapsed time since the last frame was fired */

  gint64 msecs_delta;

  GHashTable *markers_by_name;

  /* Time we last advanced the elapsed time and showed a frame */

  gint64 last_frame_time;

  /* How many times the timeline should repeat */

  gint repeat_count;

  /* The number of times the timeline has repeated */

  gint current_repeat;

  ClutterTimelineProgressFunc progress_func;

  gpointer progress_data;

  GDestroyNotify progress_notify;

  ClutterAnimationMode progress_mode;

  /* step() parameters */

  gint n_steps;

  ClutterStepMode step_mode;

  /* cubic-bezier() parameters */

  ClutterPoint cb_1;

  ClutterPoint cb_2;

  guint is_playing         : 1;

  /* If we've just started playing and haven't yet gotten

   * a tick from the master clock

   */

  guint waiting_first_tick : 1;

  guint auto_reverse       : 1;

};

typedef struct {

  gchar *name;

  GQuark quark;

  union {

    guint msecs;

    gdouble progress;

  } data;

  guint is_relative : 1;

} TimelineMarker;

enum

{

  PROP_0,

  PROP_LOOP,

  PROP_DELAY,

  PROP_DURATION,

  PROP_DIRECTION,

  PROP_AUTO_REVERSE,

  PROP_REPEAT_COUNT,

  PROP_PROGRESS_MODE,

  PROP_LAST

};

static GParamSpec *obj_props[PROP_LAST] = { NULL, };

enum

{

  NEW_FRAME,

  STARTED,

  PAUSED,

  COMPLETED,

  MARKER_REACHED,

  STOPPED,

  LAST_SIGNAL

};

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

static void clutter_scriptable_iface_init (ClutterScriptableIface *iface);

G_DEFINE_TYPE_WITH_CODE (ClutterTimeline, clutter_timeline, G_TYPE_OBJECT,

                         G_ADD_PRIVATE (ClutterTimeline)

                         G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_SCRIPTABLE,

                                                clutter_scriptable_iface_init))

static TimelineMarker *

timeline_marker_new_time (const gchar *name,

                          guint        msecs)

{

  TimelineMarker *marker = g_slice_new (TimelineMarker);

  marker->name = g_strdup (name);

  marker->quark = g_quark_from_string (marker->name);

  marker->is_relative = FALSE;

  marker->data.msecs = msecs;

  return marker;

}

static TimelineMarker *

timeline_marker_new_progress (const gchar *name,

                              gdouble      progress)

{

  TimelineMarker *marker = g_slice_new (TimelineMarker);

  marker->name = g_strdup (name);

  marker->quark = g_quark_from_string (marker->name);

  marker->is_relative = TRUE;

  marker->data.progress = CLAMP (progress, 0.0, 1.0);

  return marker;

}

static void

timeline_marker_free (gpointer data)

{

  if (G_LIKELY (data))

    {

      TimelineMarker *marker = data;

      g_free (marker->name);

      g_slice_free (TimelineMarker, marker);

    }

}

/*< private >

 * clutter_timeline_add_marker_internal:

 * @timeline: a #ClutterTimeline

 * @marker: a TimelineMarker

 *

 * Adds @marker into the hash table of markers for @timeline.

 *

 * The TimelineMarker will either be added or, in case of collisions

 * with another existing marker, freed. In any case, this function

 * assumes the ownership of the passed @marker.

 */

static inline void

clutter_timeline_add_marker_internal (ClutterTimeline *timeline,

                                      TimelineMarker  *marker)

{

  ClutterTimelinePrivate *priv = timeline->priv;

  TimelineMarker *old_marker;

  /* create the hash table that will hold the markers */

  if (G_UNLIKELY (priv->markers_by_name == NULL))

    priv->markers_by_name = g_hash_table_new_full (g_str_hash, g_str_equal,

                                                   NULL,

                                                   timeline_marker_free);

  old_marker = g_hash_table_lookup (priv->markers_by_name, marker->name);

  if (old_marker != NULL)

    {

      guint msecs;

      if (old_marker->is_relative)

        msecs = old_marker->data.progress * priv->duration;

      else

        msecs = old_marker->data.msecs;

      g_warning ("A marker named '%s' already exists at time %d",

                 old_marker->name,

                 msecs);

      timeline_marker_free (marker);

      return;

    }

  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;

  ClutterScript *script;

  GValue *value;

  gboolean result;

} ParseClosure;

static void

parse_timeline_markers (JsonArray *array,

                        guint      index_,

                        JsonNode  *element,

                        gpointer   data)

{

  ParseClosure *clos = data;

  JsonObject *object;

  TimelineMarker *marker;

  GList *markers;

  if (JSON_NODE_TYPE (element) != JSON_NODE_OBJECT)

    {

      g_warning ("The 'markers' member of a ClutterTimeline description "

                 "should be an array of objects, but the element %d of the "

                 "array is of type '%s'. The element will be ignored.",

                 index_,

                 json_node_type_name (element));

      return;

    }

  object = json_node_get_object (element);

  if (!(json_object_has_member (object, "name") &&

        (json_object_has_member (object, "time") ||

         json_object_has_member (object, "progress"))))

    {

      g_warning ("The marker definition in a ClutterTimeline description "

                 "must be an object with the 'name' and either the 'time' "

                 "or the 'progress' members, but the element %d of the "

                 "'markers' array does not have any of them.",

                 index_);

      return;

    }

  if (G_IS_VALUE (clos->value))

    markers = g_value_get_pointer (clos->value);

  else

    {

      g_value_init (clos->value, G_TYPE_POINTER);

      markers = NULL;

    }

  if (json_object_has_member (object, "time"))

    marker = timeline_marker_new_time (json_object_get_string_member (object, "name"),

                                       json_object_get_int_member (object, "time"));

  else

    marker = timeline_marker_new_progress (json_object_get_string_member (object, "name"),

                                           json_object_get_double_member (object, "progress"));

  markers = g_list_prepend (markers, marker);

  g_value_set_pointer (clos->value, markers);

  clos->result = TRUE;

}

static gboolean

clutter_timeline_parse_custom_node (ClutterScriptable *scriptable,

                                    ClutterScript     *script,

                                    GValue            *value,

                                    const gchar       *name,

                                    JsonNode          *node)

{

  ParseClosure clos;

  if (strcmp (name, "markers") != 0)

    return FALSE;

  if (JSON_NODE_TYPE (node) != JSON_NODE_ARRAY)

    return FALSE;

  clos.timeline = CLUTTER_TIMELINE (scriptable);

  clos.script = script;

  clos.value = value;

  clos.result = FALSE;

  json_array_foreach_element (json_node_get_array (node),

                              parse_timeline_markers,

                              &clos);

  return clos.result;

}

static void

clutter_timeline_set_custom_property (ClutterScriptable *scriptable,

                                      ClutterScript     *script,

                                      const gchar       *name,

                                      const GValue      *value)

{

  if (strcmp (name, "markers") == 0)

    {

      ClutterTimeline *timeline = CLUTTER_TIMELINE (scriptable);

      GList *markers = g_value_get_pointer (value);

      GList *m;

      /* the list was created through prepend() */

      markers = g_list_reverse (markers);

      for (m = markers; m != NULL; m = m->next)

        clutter_timeline_add_marker_internal (timeline, m->data);

      g_list_free (markers);

    }

  else

    g_object_set_property (G_OBJECT (scriptable), name, value);

}

static void

clutter_scriptable_iface_init (ClutterScriptableIface *iface)

{

  iface->parse_custom_node = clutter_timeline_parse_custom_node;

  iface->set_custom_property = clutter_timeline_set_custom_property;

}

/* Object */

static void

clutter_timeline_set_property (GObject      *object,

			       guint         prop_id,

			       const GValue *value,

			       GParamSpec   *pspec)

{

  ClutterTimeline *timeline = CLUTTER_TIMELINE (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;

    case PROP_DURATION:

      clutter_timeline_set_duration (timeline, g_value_get_uint (value));

      break;

    case PROP_DIRECTION:

      clutter_timeline_set_direction (timeline, g_value_get_enum (value));

      break;

    case PROP_AUTO_REVERSE:

      clutter_timeline_set_auto_reverse (timeline, g_value_get_boolean (value));

      break;

    case PROP_REPEAT_COUNT:

      clutter_timeline_set_repeat_count (timeline, g_value_get_int (value));

      break;

    case PROP_PROGRESS_MODE:

      clutter_timeline_set_progress_mode (timeline, g_value_get_enum (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

clutter_timeline_get_property (GObject    *object,

			       guint       prop_id,

			       GValue     *value,

			       GParamSpec *pspec)

{

  ClutterTimeline *timeline = CLUTTER_TIMELINE (object);

  ClutterTimelinePrivate *priv = timeline->priv;

  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;

    case PROP_DURATION:

      g_value_set_uint (value, clutter_timeline_get_duration (timeline));

      break;

    case PROP_DIRECTION:

      g_value_set_enum (value, priv->direction);

      break;

    case PROP_AUTO_REVERSE:

      g_value_set_boolean (value, priv->auto_reverse);

      break;

    case PROP_REPEAT_COUNT:

      g_value_set_int (value, priv->repeat_count);

      break;

    case PROP_PROGRESS_MODE:

      g_value_set_enum (value, priv->progress_mode);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

clutter_timeline_finalize (GObject *object)

{

  ClutterTimeline *self = CLUTTER_TIMELINE (object);

  ClutterTimelinePrivate *priv = self->priv;

  ClutterMasterClock *master_clock;

  if (priv->markers_by_name)

    g_hash_table_destroy (priv->markers_by_name);

  if (priv->is_playing)

    {

      master_clock = _clutter_master_clock_get_default ();

      _clutter_master_clock_remove_timeline (master_clock, self);

    }

  G_OBJECT_CLASS (clutter_timeline_parent_class)->finalize (object);

}

static void

clutter_timeline_dispose (GObject *object)

{

  ClutterTimeline *self = CLUTTER_TIMELINE(object);

  ClutterTimelinePrivate *priv;

  priv = self->priv;

  if (priv->delay_id)

    {

      g_source_remove (priv->delay_id);

      priv->delay_id = 0;

    }

  if (priv->progress_notify != NULL)

    {

      priv->progress_notify (priv->progress_data);

      priv->progress_func = NULL;

      priv->progress_data = NULL;

      priv->progress_notify = NULL;

    }

  G_OBJECT_CLASS (clutter_timeline_parent_class)->dispose (object);

}

static void

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:

   *

   * A delay, in milliseconds, that should be observed by the

   * timeline before actually starting.

   *

   * Since: 0.4

   */

  obj_props[PROP_DELAY] =

    g_param_spec_uint ("delay",

                       P_("Delay"),

                       P_("Delay before start"),

                       0, G_MAXUINT,

                       0,

                       CLUTTER_PARAM_READWRITE);

  /**

   * ClutterTimeline:duration:

   *

   * Duration of the timeline in milliseconds, depending on the

   * ClutterTimeline:fps value.

   *

   * Since: 0.6

   */

  obj_props[PROP_DURATION] =

    g_param_spec_uint ("duration",

                       P_("Duration"),

                       P_("Duration of the timeline in milliseconds"),

                       0, G_MAXUINT,

                       1000,

                       CLUTTER_PARAM_READWRITE);

  /**

   * ClutterTimeline:direction:

   *

   * The direction of the timeline, either %CLUTTER_TIMELINE_FORWARD or

   * %CLUTTER_TIMELINE_BACKWARD.

   *

   * Since: 0.6

   */

  obj_props[PROP_DIRECTION] =

    g_param_spec_enum ("direction",

                       P_("Direction"),

                       P_("Direction of the timeline"),

                       CLUTTER_TYPE_TIMELINE_DIRECTION,

                       CLUTTER_TIMELINE_FORWARD,

                       CLUTTER_PARAM_READWRITE);

  /**

   * ClutterTimeline:auto-reverse:

   *

   * If the direction of the timeline should be automatically reversed

   * when reaching the end.

   *

   * Since: 1.6

   */

  obj_props[PROP_AUTO_REVERSE] =

    g_param_spec_boolean ("auto-reverse",

                          P_("Auto Reverse"),

                          P_("Whether the direction should be reversed when reaching the end"),

                          FALSE,

                          CLUTTER_PARAM_READWRITE);

  /**

   * ClutterTimeline:repeat-count:

   *

   * Defines how many times the timeline should repeat.

   *

   * If the repeat count is 0, the timeline does not repeat.

   *

   * If the repeat count is set to -1, the timeline will repeat until it is

   * stopped.

   *

   * Since: 1.10

   */

  obj_props[PROP_REPEAT_COUNT] =

    g_param_spec_int ("repeat-count",

                      P_("Repeat Count"),

                      P_("How many times the timeline should repeat"),

                      -1, G_MAXINT,

                      0,

                      CLUTTER_PARAM_READWRITE);

  /**

   * ClutterTimeline:progress-mode:

   *

   * Controls the way a #ClutterTimeline computes the normalized progress.

   *

   * Since: 1.10

   */

  obj_props[PROP_PROGRESS_MODE] =

    g_param_spec_enum ("progress-mode",

                       P_("Progress Mode"),

                       P_("How the timeline should compute the progress"),

                       CLUTTER_TYPE_ANIMATION_MODE,

                       CLUTTER_LINEAR,

                       CLUTTER_PARAM_READWRITE);

  object_class->dispose = clutter_timeline_dispose;

  object_class->finalize = clutter_timeline_finalize;

  object_class->set_property = clutter_timeline_set_property;

  object_class->get_property = clutter_timeline_get_property;

  g_object_class_install_properties (object_class, PROP_LAST, obj_props);

  /**

   * ClutterTimeline::new-frame:

   * @timeline: the timeline which received the signal

   * @msecs: the elapsed time between 0 and duration

   *

   * The ::new-frame signal is emitted for each timeline running

   * timeline before a new frame is drawn to give animations a chance

   * to update the scene.

   */

  timeline_signals[NEW_FRAME] =

    g_signal_new (I_("new-frame"),

		  G_TYPE_FROM_CLASS (object_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (ClutterTimelineClass, new_frame),

		  NULL, NULL,

		  _clutter_marshal_VOID__INT,

		  G_TYPE_NONE,

		  1, G_TYPE_INT);

  /**

   * ClutterTimeline::completed:

   * @timeline: the #ClutterTimeline which received the signal

   *

   * The #ClutterTimeline::completed signal is emitted when the timeline's

   * elapsed time reaches the value of the #ClutterTimeline:duration

   * property.

   *

   * This signal will be emitted even if the #ClutterTimeline is set to be

   * repeating.

   *

   * If you want to get notification on whether the #ClutterTimeline has

   * been stopped or has finished its run, including its eventual repeats,

   * you should use the #ClutterTimeline::stopped signal instead.

   */

  timeline_signals[COMPLETED] =

    g_signal_new (I_("completed"),

		  G_TYPE_FROM_CLASS (object_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (ClutterTimelineClass, completed),

		  NULL, NULL,

		  _clutter_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /**

   * ClutterTimeline::started:

   * @timeline: the #ClutterTimeline which received the signal

   *

   * The ::started signal is emitted when the timeline starts its run.

   * This might be as soon as clutter_timeline_start() is invoked or

   * after the delay set in the ClutterTimeline:delay property has

   * expired.

   */

  timeline_signals[STARTED] =

    g_signal_new (I_("started"),

		  G_TYPE_FROM_CLASS (object_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (ClutterTimelineClass, started),

		  NULL, NULL,

		  _clutter_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /**

   * ClutterTimeline::paused:

   * @timeline: the #ClutterTimeline which received the signal

   *

   * The ::paused signal is emitted when clutter_timeline_pause() is invoked.

   */

  timeline_signals[PAUSED] =

    g_signal_new (I_("paused"),

		  G_TYPE_FROM_CLASS (object_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (ClutterTimelineClass, paused),

		  NULL, NULL,

		  _clutter_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /**

   * ClutterTimeline::marker-reached:

   * @timeline: the #ClutterTimeline which received the signal

   * @marker_name: the name of the marker reached

   * @msecs: the elapsed time

   *

   * The ::marker-reached signal is emitted each time a timeline

   * reaches a marker set with

   * clutter_timeline_add_marker_at_time(). This signal is detailed

   * with the name of the marker as well, so it is possible to connect

   * a callback to the ::marker-reached signal for a specific marker

   * with:

   *

   * <informalexample><programlisting>

   *   clutter_timeline_add_marker_at_time (timeline, "foo", 500);

   *   clutter_timeline_add_marker_at_time (timeline, "bar", 750);

   *

   *   g_signal_connect (timeline, "marker-reached",

   *                     G_CALLBACK (each_marker_reached), NULL);

   *   g_signal_connect (timeline, "marker-reached::foo",

   *                     G_CALLBACK (foo_marker_reached), NULL);

   *   g_signal_connect (timeline, "marker-reached::bar",

   *                     G_CALLBACK (bar_marker_reached), NULL);

   * </programlisting></informalexample>

   *

   * In the example, the first callback will be invoked for both

   * the "foo" and "bar" marker, while the second and third callbacks

   * will be invoked for the "foo" or "bar" markers, respectively.

   *

   * Since: 0.8

   */

  timeline_signals[MARKER_REACHED] =

    g_signal_new (I_("marker-reached"),

                  G_TYPE_FROM_CLASS (object_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE |

                  G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS,

                  G_STRUCT_OFFSET (ClutterTimelineClass, marker_reached),

                  NULL, NULL,

                  _clutter_marshal_VOID__STRING_INT,

                  G_TYPE_NONE, 2,

                  G_TYPE_STRING,

                  G_TYPE_INT);

  /**

   * ClutterTimeline::stopped:

   * @timeline: the #ClutterTimeline that emitted the signal

   * @is_finished: %TRUE if the signal was emitted at the end of the

   *   timeline.

   *

   * The #ClutterTimeline::stopped signal is emitted when the timeline

   * has been stopped, either because clutter_timeline_stop() has been

   * called, or because it has been exhausted.

   *

   * This is different from the #ClutterTimeline::completed signal,

   * which gets emitted after every repeat finishes.

   *

   * If the #ClutterTimeline has is marked as infinitely repeating,

   * this signal will never be emitted.

   *

   * Since: 1.12

   */

  timeline_signals[STOPPED] =

    g_signal_new (I_("stopped"),

		  G_TYPE_FROM_CLASS (object_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (ClutterTimelineClass, stopped),

		  NULL, NULL,

		  _clutter_marshal_VOID__BOOLEAN,

		  G_TYPE_NONE, 1,

                  G_TYPE_BOOLEAN);

}

static void

clutter_timeline_init (ClutterTimeline *self)

{

  self->priv = clutter_timeline_get_instance_private (self);

  self->priv->progress_mode = CLUTTER_LINEAR;

  /* default steps() parameters are 1, end */

  self->priv->n_steps = 1;

  self->priv->step_mode = CLUTTER_STEP_MODE_END;

  /* default cubic-bezier() paramereters are (0, 0, 1, 1) */

  clutter_point_init (&self->priv->cb_1, 0, 0);

  clutter_point_init (&self->priv->cb_2, 1, 1);

}

struct CheckIfMarkerHitClosure

{

  ClutterTimeline *timeline;

  ClutterTimelineDirection direction;

  gint new_time;

  gint duration;

  gint delta;

};

static gboolean

have_passed_time (const struct CheckIfMarkerHitClosure *data,

                  gint msecs)

{

  /* Ignore markers that are outside the duration of the timeline */

  if (msecs < 0 || msecs > data->duration)

    return FALSE;

  if (data->direction == CLUTTER_TIMELINE_FORWARD)

    {

      /* We need to special case when a marker is added at the

         beginning of the timeline */

      if (msecs == 0 &&