[gtk+/wip/frame-synchronization: 824/857] Add back GtkTimeline
- From: Owen Taylor <otaylor src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk+/wip/frame-synchronization: 824/857] Add back GtkTimeline
- Date: Wed, 13 Feb 2013 06:12:48 +0000 (UTC)
commit 4dfe25aa3586a073950e44fa05e536f39f21a3c7
Author: Owen W. Taylor <otaylor fishsoup net>
Date: Fri Jul 27 04:56:51 2012 -0400
Add back GtkTimeline
Add back the GtkTimeline code that previously made private and
then removed. It will be hooked up to GdkFrameClock. This commit
purely adds the old code back.
https://bugzilla.gnome.org/show_bug.cgi?id=685460
gtk/Makefile.am | 2 +
gtk/gtktimeline.c | 760 +++++++++++++++++++++++++++++++++++++++++++++++++++++
gtk/gtktimeline.h | 116 ++++++++
3 files changed, 878 insertions(+), 0 deletions(-)
---
diff --git a/gtk/Makefile.am b/gtk/Makefile.am
index 973f3c8..70ef204 100644
--- a/gtk/Makefile.am
+++ b/gtk/Makefile.am
@@ -544,6 +544,7 @@ gtk_private_h_sources = \
gtktextutil.h \
gtkthemingbackgroundprivate.h \
gtkthemingengineprivate.h \
+ gtktimeline.h \
gtktoolpaletteprivate.h \
gtktreedatalist.h \
gtktreeprivate.h \
@@ -850,6 +851,7 @@ gtk_base_c_sources = \
gtktextview.c \
gtkthemingbackground.c \
gtkthemingengine.c \
+ gtktimeline.c \
gtktoggleaction.c \
gtktogglebutton.c \
gtktoggletoolbutton.c \
diff --git a/gtk/gtktimeline.c b/gtk/gtktimeline.c
new file mode 100644
index 0000000..2202e79
--- /dev/null
+++ b/gtk/gtktimeline.c
@@ -0,0 +1,760 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2007 Carlos Garnacho <carlos imendio com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtk/gtktimeline.h>
+#include <gtk/gtktypebuiltins.h>
+#include <gtk/gtksettings.h>
+#include <math.h>
+
+#define MSECS_PER_SEC 1000
+#define FRAME_INTERVAL(nframes) (MSECS_PER_SEC / nframes)
+#define DEFAULT_FPS 30
+
+typedef struct GtkTimelinePriv GtkTimelinePriv;
+
+struct GtkTimelinePriv
+{
+ guint duration;
+ guint fps;
+ guint source_id;
+
+ GTimer *timer;
+ gdouble elapsed_time;
+
+ gdouble progress;
+ gdouble last_progress;
+
+ GdkScreen *screen;
+
+ GtkTimelineProgressType progress_type;
+
+ guint animations_enabled : 1;
+ guint loop : 1;
+ guint direction : 1;
+};
+
+enum {
+ PROP_0,
+ PROP_FPS,
+ PROP_DURATION,
+ PROP_LOOP,
+ PROP_DIRECTION,
+ PROP_SCREEN
+};
+
+enum {
+ STARTED,
+ PAUSED,
+ FINISHED,
+ FRAME,
+ LAST_SIGNAL
+};
+
+static guint signals [LAST_SIGNAL] = { 0, };
+
+
+static void gtk_timeline_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gtk_timeline_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void gtk_timeline_finalize (GObject *object);
+
+
+G_DEFINE_TYPE (GtkTimeline, gtk_timeline, G_TYPE_OBJECT)
+
+
+static void
+gtk_timeline_class_init (GtkTimelineClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->set_property = gtk_timeline_set_property;
+ object_class->get_property = gtk_timeline_get_property;
+ object_class->finalize = gtk_timeline_finalize;
+
+ g_object_class_install_property (object_class,
+ PROP_FPS,
+ g_param_spec_uint ("fps",
+ "FPS",
+ "Frames per second for the timeline",
+ 1, G_MAXUINT,
+ DEFAULT_FPS,
+ G_PARAM_READWRITE));
+ g_object_class_install_property (object_class,
+ PROP_DURATION,
+ g_param_spec_uint ("duration",
+ "Animation Duration",
+ "Animation Duration",
+ 0, G_MAXUINT,
+ 0,
+ G_PARAM_READWRITE));
+ g_object_class_install_property (object_class,
+ PROP_LOOP,
+ g_param_spec_boolean ("loop",
+ "Loop",
+ "Whether the timeline loops or not",
+ FALSE,
+ G_PARAM_READWRITE));
+ g_object_class_install_property (object_class,
+ PROP_SCREEN,
+ g_param_spec_object ("screen",
+ "Screen",
+ "Screen to get the settings from",
+ GDK_TYPE_SCREEN,
+ G_PARAM_READWRITE));
+
+ signals[STARTED] =
+ g_signal_new ("started",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTimelineClass, started),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ signals[PAUSED] =
+ g_signal_new ("paused",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTimelineClass, paused),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ signals[FINISHED] =
+ g_signal_new ("finished",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTimelineClass, finished),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ signals[FRAME] =
+ g_signal_new ("frame",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTimelineClass, frame),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__DOUBLE,
+ G_TYPE_NONE, 1,
+ G_TYPE_DOUBLE);
+
+ g_type_class_add_private (klass, sizeof (GtkTimelinePriv));
+}
+
+static void
+gtk_timeline_init (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ priv = timeline->priv = G_TYPE_INSTANCE_GET_PRIVATE (timeline,
+ GTK_TYPE_TIMELINE,
+ GtkTimelinePriv);
+
+ priv->fps = DEFAULT_FPS;
+ priv->duration = 0.0;
+ priv->direction = GTK_TIMELINE_DIRECTION_FORWARD;
+ priv->screen = gdk_screen_get_default ();
+
+ priv->last_progress = 0;
+}
+
+static void
+gtk_timeline_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkTimeline *timeline;
+
+ timeline = GTK_TIMELINE (object);
+
+ switch (prop_id)
+ {
+ case PROP_FPS:
+ _gtk_timeline_set_fps (timeline, g_value_get_uint (value));
+ break;
+ case PROP_DURATION:
+ gtk_timeline_set_duration (timeline, g_value_get_uint (value));
+ break;
+ case PROP_LOOP:
+ gtk_timeline_set_loop (timeline, g_value_get_boolean (value));
+ break;
+ case PROP_DIRECTION:
+ gtk_timeline_set_direction (timeline, g_value_get_enum (value));
+ break;
+ case PROP_SCREEN:
+ gtk_timeline_set_screen (timeline,
+ GDK_SCREEN (g_value_get_object (value)));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gtk_timeline_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkTimeline *timeline;
+ GtkTimelinePriv *priv;
+
+ timeline = GTK_TIMELINE (object);
+ priv = timeline->priv;
+
+ switch (prop_id)
+ {
+ case PROP_FPS:
+ g_value_set_uint (value, priv->fps);
+ break;
+ case PROP_DURATION:
+ g_value_set_uint (value, priv->duration);
+ break;
+ case PROP_LOOP:
+ g_value_set_boolean (value, priv->loop);
+ break;
+ case PROP_DIRECTION:
+ g_value_set_enum (value, priv->direction);
+ break;
+ case PROP_SCREEN:
+ g_value_set_object (value, priv->screen);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gtk_timeline_finalize (GObject *object)
+{
+ GtkTimelinePriv *priv;
+ GtkTimeline *timeline;
+
+ timeline = (GtkTimeline *) object;
+ priv = timeline->priv;
+
+ if (priv->source_id)
+ {
+ g_source_remove (priv->source_id);
+ priv->source_id = 0;
+ }
+
+ if (priv->timer)
+ g_timer_destroy (priv->timer);
+
+ G_OBJECT_CLASS (gtk_timeline_parent_class)->finalize (object);
+}
+
+static gdouble
+calculate_progress (gdouble linear_progress,
+ GtkTimelineProgressType progress_type)
+{
+ gdouble progress;
+
+ progress = linear_progress;
+
+ switch (progress_type)
+ {
+ case GTK_TIMELINE_PROGRESS_LINEAR:
+ break;
+ case GTK_TIMELINE_PROGRESS_EASE_IN_OUT:
+ progress *= 2;
+
+ if (progress < 1)
+ progress = pow (progress, 3) / 2;
+ else
+ progress = (pow (progress - 2, 3) + 2) / 2;
+
+ break;
+ case GTK_TIMELINE_PROGRESS_EASE:
+ progress = (sin ((progress - 0.5) * G_PI) + 1) / 2;
+ break;
+ case GTK_TIMELINE_PROGRESS_EASE_IN:
+ progress = pow (progress, 3);
+ break;
+ case GTK_TIMELINE_PROGRESS_EASE_OUT:
+ progress = pow (progress - 1, 3) + 1;
+ break;
+ default:
+ g_warning ("Timeline progress type not implemented");
+ }
+
+ return progress;
+}
+
+static gboolean
+gtk_timeline_run_frame (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+ gdouble delta_progress, progress;
+
+ /* the user may unref us during the signals, so save ourselves */
+ g_object_ref (timeline);
+
+ priv = timeline->priv;
+
+ priv->elapsed_time = (guint) (g_timer_elapsed (priv->timer, NULL) * 1000);
+ g_timer_start (priv->timer);
+
+ if (priv->animations_enabled)
+ {
+ delta_progress = (gdouble) priv->elapsed_time / priv->duration;
+ progress = priv->last_progress;
+
+ if (priv->direction == GTK_TIMELINE_DIRECTION_BACKWARD)
+ progress -= delta_progress;
+ else
+ progress += delta_progress;
+
+ priv->last_progress = progress;
+
+ progress = CLAMP (progress, 0., 1.);
+ }
+ else
+ progress = (priv->direction == GTK_TIMELINE_DIRECTION_FORWARD) ? 1.0 : 0.0;
+
+ priv->progress = progress;
+ g_signal_emit (timeline, signals [FRAME], 0,
+ calculate_progress (progress, priv->progress_type));
+
+ if ((priv->direction == GTK_TIMELINE_DIRECTION_FORWARD && progress == 1.0) ||
+ (priv->direction == GTK_TIMELINE_DIRECTION_BACKWARD && progress == 0.0))
+ {
+ gboolean loop;
+
+ loop = priv->loop && priv->animations_enabled;
+
+ if (loop)
+ gtk_timeline_rewind (timeline);
+ else
+ {
+ if (priv->source_id)
+ {
+ g_source_remove (priv->source_id);
+ priv->source_id = 0;
+ }
+ g_timer_stop (priv->timer);
+ g_signal_emit (timeline, signals [FINISHED], 0);
+ g_object_unref (timeline);
+ return FALSE;
+ }
+ }
+
+ g_object_unref (timeline);
+
+ return TRUE;
+}
+
+/*
+ * gtk_timeline_new:
+ * @duration: duration in milliseconds for the timeline
+ *
+ * Creates a new #GtkTimeline with the specified number of frames.
+ *
+ * Return Value: the newly created #GtkTimeline
+ */
+GtkTimeline *
+gtk_timeline_new (guint duration)
+{
+ return g_object_new (GTK_TYPE_TIMELINE,
+ "duration", duration,
+ NULL);
+}
+
+GtkTimeline *
+gtk_timeline_new_for_screen (guint duration,
+ GdkScreen *screen)
+{
+ return g_object_new (GTK_TYPE_TIMELINE,
+ "duration", duration,
+ "screen", screen,
+ NULL);
+}
+
+/*
+ * gtk_timeline_start:
+ * @timeline: A #GtkTimeline
+ *
+ * Runs the timeline from the current frame.
+ */
+void
+gtk_timeline_start (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+ GtkSettings *settings;
+ gboolean enable_animations = FALSE;
+
+ g_return_if_fail (GTK_IS_TIMELINE (timeline));
+
+ priv = timeline->priv;
+
+ if (!priv->source_id)
+ {
+ if (priv->timer)
+ g_timer_continue (priv->timer);
+ else
+ priv->timer = g_timer_new ();
+
+ /* sanity check */
+ g_assert (priv->fps > 0);
+
+ if (priv->screen)
+ {
+ settings = gtk_settings_get_for_screen (priv->screen);
+ g_object_get (settings, "gtk-enable-animations", &enable_animations, NULL);
+ }
+
+ priv->animations_enabled = enable_animations;
+
+ g_signal_emit (timeline, signals [STARTED], 0);
+
+ if (enable_animations)
+ priv->source_id = gdk_threads_add_timeout (FRAME_INTERVAL (priv->fps),
+ (GSourceFunc) gtk_timeline_run_frame,
+ timeline);
+ else
+ priv->source_id = gdk_threads_add_idle ((GSourceFunc) gtk_timeline_run_frame,
+ timeline);
+ }
+}
+
+/*
+ * gtk_timeline_pause:
+ * @timeline: A #GtkTimeline
+ *
+ * Pauses the timeline.
+ */
+void
+gtk_timeline_pause (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_if_fail (GTK_IS_TIMELINE (timeline));
+
+ priv = timeline->priv;
+
+ if (priv->source_id)
+ {
+ g_timer_stop (priv->timer);
+ g_source_remove (priv->source_id);
+ priv->source_id = 0;
+ g_signal_emit (timeline, signals [PAUSED], 0);
+ }
+}
+
+/*
+ * gtk_timeline_rewind:
+ * @timeline: A #GtkTimeline
+ *
+ * Rewinds the timeline.
+ */
+void
+gtk_timeline_rewind (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_if_fail (GTK_IS_TIMELINE (timeline));
+
+ priv = timeline->priv;
+
+ if (gtk_timeline_get_direction (timeline) != GTK_TIMELINE_DIRECTION_FORWARD)
+ priv->progress = priv->last_progress = 1.;
+ else
+ priv->progress = priv->last_progress = 0.;
+
+ /* reset timer */
+ if (priv->timer)
+ {
+ g_timer_start (priv->timer);
+
+ if (!priv->source_id)
+ g_timer_stop (priv->timer);
+ }
+}
+
+/*
+ * gtk_timeline_is_running:
+ * @timeline: A #GtkTimeline
+ *
+ * Returns whether the timeline is running or not.
+ *
+ * Return Value: %TRUE if the timeline is running
+ */
+gboolean
+gtk_timeline_is_running (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_val_if_fail (GTK_IS_TIMELINE (timeline), FALSE);
+
+ priv = timeline->priv;
+
+ return (priv->source_id != 0);
+}
+
+/*
+ * gtk_timeline_get_elapsed_time:
+ * @timeline: A #GtkTimeline
+ *
+ * Returns the elapsed time since the last GtkTimeline::frame signal
+ *
+ * Return Value: elapsed time in milliseconds since the last frame
+ */
+guint
+gtk_timeline_get_elapsed_time (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_val_if_fail (GTK_IS_TIMELINE (timeline), 0);
+
+ priv = timeline->priv;
+ return priv->elapsed_time;
+}
+
+/*
+ * gtk_timeline_get_fps:
+ * @timeline: A #GtkTimeline
+ *
+ * Returns the number of frames per second.
+ *
+ * Return Value: frames per second
+ */
+guint
+gtk_timeline_get_fps (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_val_if_fail (GTK_IS_TIMELINE (timeline), 1);
+
+ priv = timeline->priv;
+ return priv->fps;
+}
+
+/*
+ * gtk_timeline_set_fps:
+ * @timeline: A #GtkTimeline
+ * @fps: frames per second
+ *
+ * Sets the number of frames per second that
+ * the timeline will play.
+ */
+void
+gtk_timeline_set_fps (GtkTimeline *timeline,
+ guint fps)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_if_fail (GTK_IS_TIMELINE (timeline));
+ g_return_if_fail (fps > 0);
+
+ priv = timeline->priv;
+
+ priv->fps = fps;
+
+ if (gtk_timeline_is_running (timeline))
+ {
+ g_source_remove (priv->source_id);
+ priv->source_id = gdk_threads_add_timeout (FRAME_INTERVAL (priv->fps),
+ (GSourceFunc) gtk_timeline_run_frame,
+ timeline);
+ }
+
+ g_object_notify (G_OBJECT (timeline), "fps");
+}
+
+/**
+ * gtk_timeline_get_loop:
+ * @timeline: A #GtkTimeline
+ *
+ * Returns whether the timeline loops to the
+ * beginning when it has reached the end.
+ *
+ * Return Value: %TRUE if the timeline loops
+ */
+gboolean
+gtk_timeline_get_loop (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_val_if_fail (GTK_IS_TIMELINE (timeline), FALSE);
+
+ priv = timeline->priv;
+ return priv->loop;
+}
+
+/*
+ * gtk_timeline_set_loop:
+ * @timeline: A #GtkTimeline
+ * @loop: %TRUE to make the timeline loop
+ *
+ * Sets whether the timeline loops to the beginning
+ * when it has reached the end.
+ */
+void
+gtk_timeline_set_loop (GtkTimeline *timeline,
+ gboolean loop)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_if_fail (GTK_IS_TIMELINE (timeline));
+
+ priv = timeline->priv;
+
+ if (loop != priv->loop)
+ {
+ priv->loop = loop;
+ g_object_notify (G_OBJECT (timeline), "loop");
+ }
+}
+
+void
+gtk_timeline_set_duration (GtkTimeline *timeline,
+ guint duration)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_if_fail (GTK_IS_TIMELINE (timeline));
+
+ priv = timeline->priv;
+
+ if (duration != priv->duration)
+ {
+ priv->duration = duration;
+ g_object_notify (G_OBJECT (timeline), "duration");
+ }
+}
+
+guint
+gtk_timeline_get_duration (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_val_if_fail (GTK_IS_TIMELINE (timeline), 0);
+
+ priv = timeline->priv;
+
+ return priv->duration;
+}
+
+/*
+ * gtk_timeline_set_direction:
+ * @timeline: A #GtkTimeline
+ * @direction: direction
+ *
+ * Sets the direction of the timeline.
+ */
+void
+gtk_timeline_set_direction (GtkTimeline *timeline,
+ GtkTimelineDirection direction)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_if_fail (GTK_IS_TIMELINE (timeline));
+
+ priv = timeline->priv;
+ priv->direction = direction;
+}
+
+/*
+ * gtk_timeline_get_direction:
+ * @timeline: A #GtkTimeline
+ *
+ * Returns the direction of the timeline.
+ *
+ * Return Value: direction
+ */
+GtkTimelineDirection
+gtk_timeline_get_direction (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_val_if_fail (GTK_IS_TIMELINE (timeline), GTK_TIMELINE_DIRECTION_FORWARD);
+
+ priv = timeline->priv;
+ return priv->direction;
+}
+
+void
+gtk_timeline_set_screen (GtkTimeline *timeline,
+ GdkScreen *screen)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_if_fail (GTK_IS_TIMELINE (timeline));
+ g_return_if_fail (GDK_IS_SCREEN (screen));
+
+ priv = timeline->priv;
+
+ if (priv->screen)
+ g_object_unref (priv->screen);
+
+ priv->screen = g_object_ref (screen);
+
+ g_object_notify (G_OBJECT (timeline), "screen");
+}
+
+GdkScreen *
+gtk_timeline_get_screen (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_val_if_fail (GTK_IS_TIMELINE (timeline), NULL);
+
+ priv = timeline->priv;
+ return priv->screen;
+}
+
+gdouble
+gtk_timeline_get_progress (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_val_if_fail (GTK_IS_TIMELINE (timeline), 0.);
+
+ priv = timeline->priv;
+ return calculate_progress (priv->progress, priv->progress_type);
+}
+
+GtkTimelineProgressType
+gtk_timeline_get_progress_type (GtkTimeline *timeline)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_val_if_fail (GTK_IS_TIMELINE (timeline), GTK_TIMELINE_PROGRESS_LINEAR);
+
+ priv = timeline->priv;
+ return priv->progress_type;
+}
+
+void
+gtk_timeline_set_progress_type (GtkTimeline *timeline,
+ GtkTimelineProgressType progress_type)
+{
+ GtkTimelinePriv *priv;
+
+ g_return_if_fail (GTK_IS_TIMELINE (timeline));
+
+ priv = timeline->priv;
+ priv->progress_type = progress_type;
+}
diff --git a/gtk/gtktimeline.h b/gtk/gtktimeline.h
new file mode 100644
index 0000000..3960cb7
--- /dev/null
+++ b/gtk/gtktimeline.h
@@ -0,0 +1,116 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2007 Carlos Garnacho <carlos imendio com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_TIMELINE_H__
+#define __GTK_TIMELINE_H__
+
+#include <glib-object.h>
+#include <gtk/gtkenums.h>
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_TIMELINE (gtk_timeline_get_type ())
+#define GTK_TIMELINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TIMELINE, GtkTimeline))
+#define GTK_TIMELINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TIMELINE, GtkTimelineClass))
+#define GTK_IS_TIMELINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TIMELINE))
+#define GTK_IS_TIMELINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TIMELINE))
+#define GTK_TIMELINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TIMELINE, GtkTimelineClass))
+
+typedef struct GtkTimeline GtkTimeline;
+typedef struct GtkTimelineClass GtkTimelineClass;
+
+typedef enum {
+ GTK_TIMELINE_DIRECTION_FORWARD,
+ GTK_TIMELINE_DIRECTION_BACKWARD
+} GtkTimelineDirection;
+
+typedef enum {
+ GTK_TIMELINE_PROGRESS_LINEAR,
+ GTK_TIMELINE_PROGRESS_EASE,
+ GTK_TIMELINE_PROGRESS_EASE_IN,
+ GTK_TIMELINE_PROGRESS_EASE_OUT,
+ GTK_TIMELINE_PROGRESS_EASE_IN_OUT
+} GtkTimelineProgressType;
+
+struct GtkTimeline
+{
+ GObject parent_instance;
+ gpointer priv;
+};
+
+struct GtkTimelineClass
+{
+ GObjectClass parent_class;
+
+ void (* started) (GtkTimeline *timeline);
+ void (* finished) (GtkTimeline *timeline);
+ void (* paused) (GtkTimeline *timeline);
+
+ void (* frame) (GtkTimeline *timeline,
+ gdouble progress);
+
+ void (* __gtk_reserved1) (void);
+ void (* __gtk_reserved2) (void);
+ void (* __gtk_reserved3) (void);
+ void (* __gtk_reserved4) (void);
+};
+
+
+GType gtk_timeline_get_type (void) G_GNUC_CONST;
+
+GtkTimeline * gtk_timeline_new (guint duration);
+GtkTimeline * gtk_timeline_new_for_screen (guint duration,
+ GdkScreen *screen);
+
+void gtk_timeline_start (GtkTimeline *timeline);
+void gtk_timeline_pause (GtkTimeline *timeline);
+void gtk_timeline_rewind (GtkTimeline *timeline);
+
+gboolean gtk_timeline_is_running (GtkTimeline *timeline);
+guint gtk_timeline_get_elapsed_time (GtkTimeline *timeline);
+
+guint gtk_timeline_get_fps (GtkTimeline *timeline);
+void gtk_timeline_set_fps (GtkTimeline *timeline,
+ guint fps);
+
+gboolean gtk_timeline_get_loop (GtkTimeline *timeline);
+void gtk_timeline_set_loop (GtkTimeline *timeline,
+ gboolean loop);
+
+guint gtk_timeline_get_duration (GtkTimeline *timeline);
+void gtk_timeline_set_duration (GtkTimeline *timeline,
+ guint duration);
+
+GdkScreen * gtk_timeline_get_screen (GtkTimeline *timeline);
+void gtk_timeline_set_screen (GtkTimeline *timeline,
+ GdkScreen *screen);
+
+GtkTimelineDirection gtk_timeline_get_direction (GtkTimeline *timeline);
+void gtk_timeline_set_direction (GtkTimeline *timeline,
+ GtkTimelineDirection direction);
+
+gdouble gtk_timeline_get_progress (GtkTimeline *timeline);
+
+GtkTimelineProgressType gtk_timeline_get_progress_type (GtkTimeline *timeline);
+void gtk_timeline_set_progress_type (GtkTimeline *timeline,
+ GtkTimelineProgressType progress_type);
+
+
+G_END_DECLS
+
+#endif /* _GTK_TIMELINE_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
