2006-05-29 04:59:36 -04:00
|
|
|
/*
|
|
|
|
|
* 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
|
2008-10-30 13:04:34 -04:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
2006-05-29 04:59:36 -04:00
|
|
|
*/
|
|
|
|
|
|
2008-10-30 13:04:34 -04:00
|
|
|
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
|
|
|
|
|
#error "Only <clutter/clutter.h> can be included directly."
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef __CLUTTER_TIMELINE_H__
|
|
|
|
|
#define __CLUTTER_TIMELINE_H__
|
2006-05-29 04:59:36 -04:00
|
|
|
|
2011-10-04 08:28:04 -04:00
|
|
|
#include <clutter/clutter-types.h>
|
2006-05-29 04:59:36 -04:00
|
|
|
|
|
|
|
|
G_BEGIN_DECLS
|
|
|
|
|
|
2009-03-09 13:05:13 -04:00
|
|
|
#define CLUTTER_TYPE_TIMELINE (clutter_timeline_get_type ())
|
|
|
|
|
#define CLUTTER_TIMELINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TIMELINE, ClutterTimeline))
|
|
|
|
|
#define CLUTTER_TIMELINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_TIMELINE, ClutterTimelineClass))
|
|
|
|
|
#define CLUTTER_IS_TIMELINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TIMELINE))
|
|
|
|
|
#define CLUTTER_IS_TIMELINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_TIMELINE))
|
|
|
|
|
#define CLUTTER_TIMELINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_TIMELINE, ClutterTimelineClass))
|
2006-05-29 04:59:36 -04:00
|
|
|
|
2006-11-15 18:37:53 -05:00
|
|
|
typedef struct _ClutterTimelineClass ClutterTimelineClass;
|
|
|
|
|
typedef struct _ClutterTimelinePrivate ClutterTimelinePrivate;
|
2006-08-13 19:55:52 -04:00
|
|
|
|
2012-02-17 11:06:28 -05:00
|
|
|
/**
|
|
|
|
|
* ClutterTimelineProgressFunc:
|
|
|
|
|
* @timeline: a #ClutterTimeline
|
|
|
|
|
* @elapsed: the elapsed time, in milliseconds
|
|
|
|
|
* @total: the total duration of the timeline, in milliseconds,
|
|
|
|
|
* @user_data: data passed to the function
|
|
|
|
|
*
|
|
|
|
|
* A function for defining a custom progress.
|
|
|
|
|
*
|
|
|
|
|
* Return value: the progress, as a floating point value between -1.0 and 2.0.
|
|
|
|
|
*
|
2012-08-27 04:48:36 -04:00
|
|
|
*
|
2012-02-17 11:06:28 -05:00
|
|
|
*/
|
|
|
|
|
typedef gdouble (* ClutterTimelineProgressFunc) (ClutterTimeline *timeline,
|
|
|
|
|
gdouble elapsed,
|
|
|
|
|
gdouble total,
|
|
|
|
|
gpointer user_data);
|
|
|
|
|
|
2009-03-16 11:00:55 -04:00
|
|
|
/**
|
|
|
|
|
* ClutterTimeline:
|
|
|
|
|
*
|
|
|
|
|
* The #ClutterTimeline structure contains only private data
|
|
|
|
|
* and should be accessed using the provided API
|
|
|
|
|
*
|
2012-08-27 04:48:36 -04:00
|
|
|
*
|
2009-03-16 11:00:55 -04:00
|
|
|
*/
|
2006-05-29 04:59:36 -04:00
|
|
|
struct _ClutterTimeline
|
|
|
|
|
{
|
2006-11-15 18:37:53 -05:00
|
|
|
/*< private >*/
|
2012-02-17 11:06:28 -05:00
|
|
|
GObject parent_instance;
|
|
|
|
|
|
2006-05-29 04:59:36 -04:00
|
|
|
ClutterTimelinePrivate *priv;
|
|
|
|
|
};
|
|
|
|
|
|
2009-03-16 11:00:55 -04:00
|
|
|
/**
|
|
|
|
|
* ClutterTimelineClass:
|
2012-06-05 14:27:28 -04:00
|
|
|
* @started: class handler for the #ClutterTimeline::started signal
|
|
|
|
|
* @completed: class handler for the #ClutterTimeline::completed signal
|
|
|
|
|
* @paused: class handler for the #ClutterTimeline::paused signal
|
|
|
|
|
* @new_frame: class handler for the #ClutterTimeline::new-frame signal
|
|
|
|
|
* @marker_reached: class handler for the #ClutterTimeline::marker-reached signal
|
|
|
|
|
* @stopped: class handler for the #ClutterTimeline::stopped signal
|
2009-03-16 11:00:55 -04:00
|
|
|
*
|
|
|
|
|
* The #ClutterTimelineClass structure contains only private data
|
|
|
|
|
*
|
2012-08-27 04:48:36 -04:00
|
|
|
*
|
2009-03-16 11:00:55 -04:00
|
|
|
*/
|
2006-05-29 04:59:36 -04:00
|
|
|
struct _ClutterTimelineClass
|
|
|
|
|
{
|
2007-08-20 05:17:23 -04:00
|
|
|
/*< private >*/
|
2006-05-29 04:59:36 -04:00
|
|
|
GObjectClass parent_class;
|
|
|
|
|
|
2007-08-20 05:17:23 -04:00
|
|
|
/*< public >*/
|
2008-03-18 13:50:45 -04:00
|
|
|
void (*started) (ClutterTimeline *timeline);
|
|
|
|
|
void (*completed) (ClutterTimeline *timeline);
|
|
|
|
|
void (*paused) (ClutterTimeline *timeline);
|
2006-06-22 08:05:51 -04:00
|
|
|
|
2008-03-18 13:50:45 -04:00
|
|
|
void (*new_frame) (ClutterTimeline *timeline,
|
2011-01-24 06:49:04 -05:00
|
|
|
gint msecs);
|
2008-03-18 13:50:45 -04:00
|
|
|
|
|
|
|
|
void (*marker_reached) (ClutterTimeline *timeline,
|
|
|
|
|
const gchar *marker_name,
|
2011-09-02 08:54:57 -04:00
|
|
|
gint msecs);
|
2012-05-25 19:41:14 -04:00
|
|
|
void (*stopped) (ClutterTimeline *timeline,
|
|
|
|
|
gboolean is_finished);
|
2006-06-22 08:05:51 -04:00
|
|
|
|
2007-08-20 05:17:23 -04:00
|
|
|
/*< private >*/
|
2006-06-22 08:05:51 -04:00
|
|
|
void (*_clutter_timeline_1) (void);
|
|
|
|
|
void (*_clutter_timeline_2) (void);
|
|
|
|
|
void (*_clutter_timeline_3) (void);
|
|
|
|
|
void (*_clutter_timeline_4) (void);
|
2008-03-18 13:50:45 -04:00
|
|
|
};
|
2006-05-29 04:59:36 -04:00
|
|
|
|
2006-11-15 18:37:53 -05:00
|
|
|
GType clutter_timeline_get_type (void) G_GNUC_CONST;
|
|
|
|
|
|
2012-07-19 21:55:35 -04:00
|
|
|
ClutterTimeline * clutter_timeline_new (guint msecs);
|
|
|
|
|
|
|
|
|
|
guint clutter_timeline_get_duration (ClutterTimeline *timeline);
|
|
|
|
|
void clutter_timeline_set_duration (ClutterTimeline *timeline,
|
|
|
|
|
guint msecs);
|
|
|
|
|
ClutterTimelineDirection clutter_timeline_get_direction (ClutterTimeline *timeline);
|
|
|
|
|
void clutter_timeline_set_direction (ClutterTimeline *timeline,
|
|
|
|
|
ClutterTimelineDirection direction);
|
|
|
|
|
void clutter_timeline_start (ClutterTimeline *timeline);
|
|
|
|
|
void clutter_timeline_pause (ClutterTimeline *timeline);
|
|
|
|
|
void clutter_timeline_stop (ClutterTimeline *timeline);
|
|
|
|
|
void clutter_timeline_set_auto_reverse (ClutterTimeline *timeline,
|
|
|
|
|
gboolean reverse);
|
|
|
|
|
gboolean clutter_timeline_get_auto_reverse (ClutterTimeline *timeline);
|
2012-02-27 11:31:53 -05:00
|
|
|
CLUTTER_AVAILABLE_IN_1_10
|
2012-07-19 21:55:35 -04:00
|
|
|
void clutter_timeline_set_repeat_count (ClutterTimeline *timeline,
|
|
|
|
|
gint count);
|
2012-02-27 11:31:53 -05:00
|
|
|
CLUTTER_AVAILABLE_IN_1_10
|
2012-07-19 21:55:35 -04:00
|
|
|
gint clutter_timeline_get_repeat_count (ClutterTimeline *timeline);
|
|
|
|
|
void clutter_timeline_rewind (ClutterTimeline *timeline);
|
|
|
|
|
void clutter_timeline_skip (ClutterTimeline *timeline,
|
|
|
|
|
guint msecs);
|
|
|
|
|
void clutter_timeline_advance (ClutterTimeline *timeline,
|
|
|
|
|
guint msecs);
|
|
|
|
|
guint clutter_timeline_get_elapsed_time (ClutterTimeline *timeline);
|
|
|
|
|
gdouble clutter_timeline_get_progress (ClutterTimeline *timeline);
|
|
|
|
|
gboolean clutter_timeline_is_playing (ClutterTimeline *timeline);
|
|
|
|
|
void clutter_timeline_set_delay (ClutterTimeline *timeline,
|
|
|
|
|
guint msecs);
|
|
|
|
|
guint clutter_timeline_get_delay (ClutterTimeline *timeline);
|
|
|
|
|
guint clutter_timeline_get_delta (ClutterTimeline *timeline);
|
2013-02-20 17:14:46 -05:00
|
|
|
CLUTTER_AVAILABLE_IN_1_14
|
|
|
|
|
void clutter_timeline_add_marker (ClutterTimeline *timeline,
|
|
|
|
|
const gchar *marker_name,
|
|
|
|
|
gdouble progress);
|
2012-07-19 21:55:35 -04:00
|
|
|
void clutter_timeline_add_marker_at_time (ClutterTimeline *timeline,
|
|
|
|
|
const gchar *marker_name,
|
|
|
|
|
guint msecs);
|
|
|
|
|
void clutter_timeline_remove_marker (ClutterTimeline *timeline,
|
|
|
|
|
const gchar *marker_name);
|
|
|
|
|
gchar ** clutter_timeline_list_markers (ClutterTimeline *timeline,
|
|
|
|
|
gint msecs,
|
|
|
|
|
gsize *n_markers) G_GNUC_MALLOC;
|
|
|
|
|
gboolean clutter_timeline_has_marker (ClutterTimeline *timeline,
|
|
|
|
|
const gchar *marker_name);
|
|
|
|
|
void clutter_timeline_advance_to_marker (ClutterTimeline *timeline,
|
|
|
|
|
const gchar *marker_name);
|
2012-02-27 11:31:53 -05:00
|
|
|
CLUTTER_AVAILABLE_IN_1_10
|
2012-07-19 21:55:35 -04:00
|
|
|
void clutter_timeline_set_progress_func (ClutterTimeline *timeline,
|
|
|
|
|
ClutterTimelineProgressFunc func,
|
|
|
|
|
gpointer data,
|
|
|
|
|
GDestroyNotify notify);
|
2012-02-27 11:31:53 -05:00
|
|
|
CLUTTER_AVAILABLE_IN_1_10
|
2012-07-19 21:55:35 -04:00
|
|
|
void clutter_timeline_set_progress_mode (ClutterTimeline *timeline,
|
|
|
|
|
ClutterAnimationMode mode);
|
2012-02-27 11:31:53 -05:00
|
|
|
CLUTTER_AVAILABLE_IN_1_10
|
2012-07-19 21:55:35 -04:00
|
|
|
ClutterAnimationMode clutter_timeline_get_progress_mode (ClutterTimeline *timeline);
|
timeline: Add support for step() progress
The CSS3 Transitions specification from the W3C defines the possibility
of using a parametrized step() timing function, with the following
prototype:
steps(n_steps, [ start | end ])
where @n_steps represents the number of steps used to divide an interval
between 0 and 1; the 'start' and 'end' tokens describe whether the value
change should happen at the start of the transition, or at the end.
For instance, the "steps(3, start)" timing function has the following
profile:
1 | x
| |
| x---|
| ' |
| x---' |
| ' |
0 |---' |
Whereas the "steps(3, end)" timing function has the following profile:
1 | x---|
| ' |
| x---' |
| ' |
x---' |
| |
0 | |
Since ClutterTimeline uses an enumeration for controlling the progress
mode, we need additional API to define the parameters of the steps()
progress; for this reason, we need a CLUTTER_STEPS enumeration value,
and a method for setting the number of steps and the value transition
policy.
The CSS3 Transitions spec helpfully also defines a step-start and a
step-end shorthands, which expand to step(1, start) and step(1, end)
respectively; we can provide a CLUTTER_STEP_START and CLUTTER_STEP_END
enumeration values for those.
2012-07-19 19:47:48 -04:00
|
|
|
CLUTTER_AVAILABLE_IN_1_12
|
2012-07-19 21:55:35 -04:00
|
|
|
void clutter_timeline_set_step_progress (ClutterTimeline *timeline,
|
|
|
|
|
gint n_steps,
|
|
|
|
|
ClutterStepMode step_mode);
|
timeline: Add support for step() progress
The CSS3 Transitions specification from the W3C defines the possibility
of using a parametrized step() timing function, with the following
prototype:
steps(n_steps, [ start | end ])
where @n_steps represents the number of steps used to divide an interval
between 0 and 1; the 'start' and 'end' tokens describe whether the value
change should happen at the start of the transition, or at the end.
For instance, the "steps(3, start)" timing function has the following
profile:
1 | x
| |
| x---|
| ' |
| x---' |
| ' |
0 |---' |
Whereas the "steps(3, end)" timing function has the following profile:
1 | x---|
| ' |
| x---' |
| ' |
x---' |
| |
0 | |
Since ClutterTimeline uses an enumeration for controlling the progress
mode, we need additional API to define the parameters of the steps()
progress; for this reason, we need a CLUTTER_STEPS enumeration value,
and a method for setting the number of steps and the value transition
policy.
The CSS3 Transitions spec helpfully also defines a step-start and a
step-end shorthands, which expand to step(1, start) and step(1, end)
respectively; we can provide a CLUTTER_STEP_START and CLUTTER_STEP_END
enumeration values for those.
2012-07-19 19:47:48 -04:00
|
|
|
CLUTTER_AVAILABLE_IN_1_12
|
2012-07-19 21:55:35 -04:00
|
|
|
gboolean clutter_timeline_get_step_progress (ClutterTimeline *timeline,
|
|
|
|
|
gint *n_steps,
|
|
|
|
|
ClutterStepMode *step_mode);
|
|
|
|
|
CLUTTER_AVAILABLE_IN_1_12
|
|
|
|
|
void clutter_timeline_set_cubic_bezier_progress (ClutterTimeline *timeline,
|
|
|
|
|
const ClutterPoint *c_1,
|
|
|
|
|
const ClutterPoint *c_2);
|
|
|
|
|
CLUTTER_AVAILABLE_IN_1_12
|
|
|
|
|
gboolean clutter_timeline_get_cubic_bezier_progress (ClutterTimeline *timeline,
|
|
|
|
|
ClutterPoint *c_1,
|
|
|
|
|
ClutterPoint *c_2);
|
2012-02-17 11:06:28 -05:00
|
|
|
|
2012-03-15 09:50:28 -04:00
|
|
|
CLUTTER_AVAILABLE_IN_1_10
|
2012-07-19 21:55:35 -04:00
|
|
|
gint64 clutter_timeline_get_duration_hint (ClutterTimeline *timeline);
|
2012-03-15 09:50:28 -04:00
|
|
|
CLUTTER_AVAILABLE_IN_1_10
|
2012-07-19 21:55:35 -04:00
|
|
|
gint clutter_timeline_get_current_repeat (ClutterTimeline *timeline);
|
2012-03-15 09:50:28 -04:00
|
|
|
|
2006-05-29 04:59:36 -04:00
|
|
|
G_END_DECLS
|
|
|
|
|
|
2008-10-30 13:04:34 -04:00
|
|
|
#endif /* _CLUTTER_TIMELINE_H__ */
|