1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
2 /* GdkPixbuf library - Simple animation support
4 * Copyright (C) 1999 The Free Software Foundation
6 * Authors: Jonathan Blandford <jrb@redhat.com>
7 * Havoc Pennington <hp@redhat.com>
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the
21 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 * Boston, MA 02111-1307, USA.
27 #include "gdk-pixbuf-private.h"
28 #include "gdk-pixbuf-io.h"
29 #include "gdk-pixbuf-i18n.h"
30 #include "gdk-pixbuf-animation.h"
31 #include "gdk-pixbuf-alias.h"
33 #include <glib/gstdio.h>
35 typedef struct _GdkPixbufNonAnim GdkPixbufNonAnim;
36 typedef struct _GdkPixbufNonAnimClass GdkPixbufNonAnimClass;
38 #define GDK_TYPE_PIXBUF_NON_ANIM (gdk_pixbuf_non_anim_get_type ())
39 #define GDK_PIXBUF_NON_ANIM(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_NON_ANIM, GdkPixbufNonAnim))
40 #define GDK_IS_PIXBUF_NON_ANIM(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_NON_ANIM))
42 #define GDK_PIXBUF_NON_ANIM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_NON_ANIM, GdkPixbufNonAnimClass))
43 #define GDK_IS_PIXBUF_NON_ANIM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_NON_ANIM))
44 #define GDK_PIXBUF_NON_ANIM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_NON_ANIM, GdkPixbufNonAnimClass))
46 /* Private part of the GdkPixbufNonAnim structure */
47 struct _GdkPixbufNonAnim {
48 GdkPixbufAnimation parent_instance;
53 struct _GdkPixbufNonAnimClass {
54 GdkPixbufAnimationClass parent_class;
59 typedef struct _GdkPixbufNonAnimIter GdkPixbufNonAnimIter;
60 typedef struct _GdkPixbufNonAnimIterClass GdkPixbufNonAnimIterClass;
63 #define GDK_TYPE_PIXBUF_NON_ANIM_ITER (gdk_pixbuf_non_anim_iter_get_type ())
64 #define GDK_PIXBUF_NON_ANIM_ITER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_NON_ANIM_ITER, GdkPixbufNonAnimIter))
65 #define GDK_IS_PIXBUF_NON_ANIM_ITER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_NON_ANIM_ITER))
67 #define GDK_PIXBUF_NON_ANIM_ITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_NON_ANIM_ITER, GdkPixbufNonAnimIterClass))
68 #define GDK_IS_PIXBUF_NON_ANIM_ITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_NON_ANIM_ITER))
69 #define GDK_PIXBUF_NON_ANIM_ITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_NON_ANIM_ITER, GdkPixbufNonAnimIterClass))
71 struct _GdkPixbufNonAnimIter {
72 GdkPixbufAnimationIter parent_instance;
74 GdkPixbufNonAnim *non_anim;
77 struct _GdkPixbufNonAnimIterClass {
78 GdkPixbufAnimationIterClass parent_class;
82 static GType gdk_pixbuf_non_anim_iter_get_type (void) G_GNUC_CONST;
84 G_DEFINE_TYPE (GdkPixbufAnimation, gdk_pixbuf_animation, G_TYPE_OBJECT);
87 gdk_pixbuf_animation_class_init (GdkPixbufAnimationClass *klass)
92 gdk_pixbuf_animation_init (GdkPixbufAnimation *animation)
97 * gdk_pixbuf_animation_new_from_file:
98 * @filename: Name of file to load, in the GLib file name encoding
99 * @error: return location for error
101 * Creates a new animation by loading it from a file. The file format is
102 * detected automatically. If the file's format does not support multi-frame
103 * images, then an animation with a single frame will be created. Possible errors
104 * are in the #GDK_PIXBUF_ERROR and #G_FILE_ERROR domains.
106 * Return value: A newly-created animation with a reference count of 1, or %NULL
107 * if any of several error conditions ocurred: the file could not be opened,
108 * there was no loader for the file's format, there was not enough memory to
109 * allocate the image buffer, or the image file contained invalid data.
112 gdk_pixbuf_animation_new_from_file (const char *filename,
115 GdkPixbufAnimation *animation;
118 guchar buffer [1024];
119 GdkPixbufModule *image_module;
121 gboolean locked = FALSE;
123 g_return_val_if_fail (filename != NULL, NULL);
124 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
126 display_name = g_filename_display_name (filename);
127 f = g_fopen (filename, "rb");
129 gint save_errno = errno;
132 g_file_error_from_errno (save_errno),
133 _("Failed to open file '%s': %s"),
135 g_strerror (save_errno));
136 g_free (display_name);
140 size = fread (&buffer, 1, sizeof (buffer), f);
145 GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
146 _("Image file '%s' contains no data"),
148 g_free (display_name);
153 image_module = _gdk_pixbuf_get_module (buffer, size, filename, error);
155 g_free (display_name);
160 if (image_module->module == NULL)
161 if (!_gdk_pixbuf_load_module (image_module, error)) {
162 g_free (display_name);
167 if (image_module->load_animation == NULL) {
170 /* Keep this logic in sync with gdk_pixbuf_new_from_file() */
172 fseek (f, 0, SEEK_SET);
173 pixbuf = _gdk_pixbuf_generic_image_load (image_module, f, error);
176 if (pixbuf == NULL && error != NULL && *error == NULL) {
177 /* I don't trust these crufty longjmp()'ing image libs
178 * to maintain proper error invariants, and I don't
179 * want user code to segfault as a result. We need to maintain
180 * the invariant that error gets set if NULL is returned.
183 g_warning ("Bug! gdk-pixbuf loader '%s' didn't set an error on failure.",
184 image_module->module_name);
187 GDK_PIXBUF_ERROR_FAILED,
188 _("Failed to load image '%s': reason not known, probably a corrupt image file"),
192 if (pixbuf == NULL) {
193 g_free (display_name);
198 animation = gdk_pixbuf_non_anim_new (pixbuf);
200 g_object_unref (pixbuf);
202 locked = _gdk_pixbuf_lock (image_module);
204 fseek (f, 0, SEEK_SET);
205 animation = (* image_module->load_animation) (f, error);
207 if (animation == NULL && error != NULL && *error == NULL) {
208 /* I don't trust these crufty longjmp()'ing
209 * image libs to maintain proper error
210 * invariants, and I don't want user code to
211 * segfault as a result. We need to maintain
212 * the invariant that error gets set if NULL
216 g_warning ("Bug! gdk-pixbuf loader '%s' didn't set an error on failure.",
217 image_module->module_name);
220 GDK_PIXBUF_ERROR_FAILED,
221 _("Failed to load animation '%s': reason not known, probably a corrupt animation file"),
228 g_free (display_name);
232 _gdk_pixbuf_unlock (image_module);
238 #undef gdk_pixbuf_animation_new_from_file
241 gdk_pixbuf_animation_new_from_file (const char *filename,
244 gchar *utf8_filename =
245 g_locale_to_utf8 (filename, -1, NULL, NULL, error);
246 GdkPixbufAnimation *retval;
248 if (utf8_filename == NULL)
251 retval = gdk_pixbuf_animation_new_from_file_utf8 (utf8_filename, error);
253 g_free (utf8_filename);
261 * gdk_pixbuf_animation_ref:
262 * @animation: An animation.
264 * Adds a reference to an animation.
266 * Return value: The same as the @animation argument.
268 * Deprecated: Use g_object_ref().
271 gdk_pixbuf_animation_ref (GdkPixbufAnimation *animation)
273 return (GdkPixbufAnimation*) g_object_ref (animation);
277 * gdk_pixbuf_animation_unref:
278 * @animation: An animation.
280 * Removes a reference from an animation.
282 * Deprecated: Use g_object_unref().
285 gdk_pixbuf_animation_unref (GdkPixbufAnimation *animation)
287 g_object_unref (animation);
291 * gdk_pixbuf_animation_is_static_image:
292 * @animation: a #GdkPixbufAnimation
294 * If you load a file with gdk_pixbuf_animation_new_from_file() and it turns
295 * out to be a plain, unanimated image, then this function will return
296 * %TRUE. Use gdk_pixbuf_animation_get_static_image() to retrieve
299 * Return value: %TRUE if the "animation" was really just an image
302 gdk_pixbuf_animation_is_static_image (GdkPixbufAnimation *animation)
304 g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), FALSE);
306 return GDK_PIXBUF_ANIMATION_GET_CLASS (animation)->is_static_image (animation);
310 * gdk_pixbuf_animation_get_static_image:
311 * @animation: a #GdkPixbufAnimation
313 * If an animation is really just a plain image (has only one frame),
314 * this function returns that image. If the animation is an animation,
315 * this function returns a reasonable thing to display as a static
316 * unanimated image, which might be the first frame, or something more
317 * sophisticated. If an animation hasn't loaded any frames yet, this
318 * function will return %NULL.
320 * Return value: unanimated image representing the animation
323 gdk_pixbuf_animation_get_static_image (GdkPixbufAnimation *animation)
325 g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), NULL);
327 return GDK_PIXBUF_ANIMATION_GET_CLASS (animation)->get_static_image (animation);
331 * gdk_pixbuf_animation_get_width:
332 * @animation: An animation.
334 * Queries the width of the bounding box of a pixbuf animation.
336 * Return value: Width of the bounding box of the animation.
339 gdk_pixbuf_animation_get_width (GdkPixbufAnimation *animation)
343 g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), 0);
346 GDK_PIXBUF_ANIMATION_GET_CLASS (animation)->get_size (animation,
354 * gdk_pixbuf_animation_get_height:
355 * @animation: An animation.
357 * Queries the height of the bounding box of a pixbuf animation.
359 * Return value: Height of the bounding box of the animation.
362 gdk_pixbuf_animation_get_height (GdkPixbufAnimation *animation)
366 g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), 0);
369 GDK_PIXBUF_ANIMATION_GET_CLASS (animation)->get_size (animation,
378 * gdk_pixbuf_animation_get_iter:
379 * @animation: a #GdkPixbufAnimation
380 * @start_time: time when the animation starts playing
382 * Get an iterator for displaying an animation. The iterator provides
383 * the frames that should be displayed at a given time.
384 * It should be freed after use with g_object_unref().
386 * @start_time would normally come from g_get_current_time(), and
387 * marks the beginning of animation playback. After creating an
388 * iterator, you should immediately display the pixbuf returned by
389 * gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install a
390 * timeout (with g_timeout_add()) or by some other mechanism ensure
391 * that you'll update the image after
392 * gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time
393 * the image is updated, you should reinstall the timeout with the new,
394 * possibly-changed delay time.
396 * As a shortcut, if @start_time is %NULL, the result of
397 * g_get_current_time() will be used automatically.
399 * To update the image (i.e. possibly change the result of
400 * gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation),
401 * call gdk_pixbuf_animation_iter_advance().
403 * If you're using #GdkPixbufLoader, in addition to updating the image
404 * after the delay time, you should also update it whenever you
405 * receive the area_updated signal and
406 * gdk_pixbuf_animation_iter_on_currently_loading_frame() returns
407 * %TRUE. In this case, the frame currently being fed into the loader
408 * has received new data, so needs to be refreshed. The delay time for
409 * a frame may also be modified after an area_updated signal, for
410 * example if the delay time for a frame is encoded in the data after
411 * the frame itself. So your timeout should be reinstalled after any
412 * area_updated signal.
414 * A delay time of -1 is possible, indicating "infinite."
416 * Return value: an iterator to move over the animation
418 GdkPixbufAnimationIter*
419 gdk_pixbuf_animation_get_iter (GdkPixbufAnimation *animation,
420 const GTimeVal *start_time)
424 g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), NULL);
430 g_get_current_time (&val);
432 return GDK_PIXBUF_ANIMATION_GET_CLASS (animation)->get_iter (animation, &val);
435 G_DEFINE_TYPE (GdkPixbufAnimationIter, gdk_pixbuf_animation_iter, G_TYPE_OBJECT);
438 gdk_pixbuf_animation_iter_class_init (GdkPixbufAnimationIterClass *klass)
443 gdk_pixbuf_animation_iter_init (GdkPixbufAnimationIter *iter)
448 * gdk_pixbuf_animation_iter_get_delay_time:
449 * @iter: an animation iterator
451 * Gets the number of milliseconds the current pixbuf should be displayed,
452 * or -1 if the current pixbuf should be displayed forever. g_timeout_add()
453 * conveniently takes a timeout in milliseconds, so you can use a timeout
454 * to schedule the next update.
456 * Return value: delay time in milliseconds (thousandths of a second)
459 gdk_pixbuf_animation_iter_get_delay_time (GdkPixbufAnimationIter *iter)
461 g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION_ITER (iter), -1);
463 return GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->get_delay_time (iter);
467 * gdk_pixbuf_animation_iter_get_pixbuf:
468 * @iter: an animation iterator
470 * Gets the current pixbuf which should be displayed; the pixbuf will
471 * be the same size as the animation itself
472 * (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()).
473 * This pixbuf should be displayed for
474 * gdk_pixbuf_animation_iter_get_delay_time() milliseconds. The caller
475 * of this function does not own a reference to the returned pixbuf;
476 * the returned pixbuf will become invalid when the iterator advances
477 * to the next frame, which may happen anytime you call
478 * gdk_pixbuf_animation_iter_advance(). Copy the pixbuf to keep it
479 * (don't just add a reference), as it may get recycled as you advance
482 * Return value: the pixbuf to be displayed
485 gdk_pixbuf_animation_iter_get_pixbuf (GdkPixbufAnimationIter *iter)
487 g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION_ITER (iter), NULL);
489 return GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->get_pixbuf (iter);
493 * gdk_pixbuf_animation_iter_on_currently_loading_frame:
494 * @iter: a #GdkPixbufAnimationIter
496 * Used to determine how to respond to the area_updated signal on
497 * #GdkPixbufLoader when loading an animation. area_updated is emitted
498 * for an area of the frame currently streaming in to the loader. So if
499 * you're on the currently loading frame, you need to redraw the screen for
502 * Return value: %TRUE if the frame we're on is partially loaded, or the last frame
505 gdk_pixbuf_animation_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter)
507 g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION_ITER (iter), FALSE);
509 return GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->on_currently_loading_frame (iter);
513 * gdk_pixbuf_animation_iter_advance:
514 * @iter: a #GdkPixbufAnimationIter
515 * @current_time: current time
517 * Possibly advances an animation to a new frame. Chooses the frame based
518 * on the start time passed to gdk_pixbuf_animation_get_iter().
520 * @current_time would normally come from g_get_current_time(), and
521 * must be greater than or equal to the time passed to
522 * gdk_pixbuf_animation_get_iter(), and must increase or remain
523 * unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is
524 * called. That is, you can't go backward in time; animations only
527 * As a shortcut, pass %NULL for the current time and g_get_current_time()
528 * will be invoked on your behalf. So you only need to explicitly pass
529 * @current_time if you're doing something odd like playing the animation
532 * If this function returns %FALSE, there's no need to update the animation
533 * display, assuming the display had been rendered prior to advancing;
534 * if %TRUE, you need to call gdk_animation_iter_get_pixbuf() and update the
535 * display with the new pixbuf.
537 * Returns: %TRUE if the image may need updating
541 gdk_pixbuf_animation_iter_advance (GdkPixbufAnimationIter *iter,
542 const GTimeVal *current_time)
546 g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION_ITER (iter), FALSE);
551 g_get_current_time (&val);
553 return GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->advance (iter, &val);
556 static void gdk_pixbuf_non_anim_finalize (GObject *object);
557 static gboolean gdk_pixbuf_non_anim_is_static_image (GdkPixbufAnimation *animation);
558 static GdkPixbuf* gdk_pixbuf_non_anim_get_static_image (GdkPixbufAnimation *animation);
559 static void gdk_pixbuf_non_anim_get_size (GdkPixbufAnimation *anim,
562 static GdkPixbufAnimationIter* gdk_pixbuf_non_anim_get_iter (GdkPixbufAnimation *anim,
563 const GTimeVal *start_time);
565 G_DEFINE_TYPE (GdkPixbufNonAnim, gdk_pixbuf_non_anim, GDK_TYPE_PIXBUF_ANIMATION);
568 gdk_pixbuf_non_anim_class_init (GdkPixbufNonAnimClass *klass)
570 GObjectClass *object_class = G_OBJECT_CLASS (klass);
571 GdkPixbufAnimationClass *anim_class = GDK_PIXBUF_ANIMATION_CLASS (klass);
573 object_class->finalize = gdk_pixbuf_non_anim_finalize;
575 anim_class->is_static_image = gdk_pixbuf_non_anim_is_static_image;
576 anim_class->get_static_image = gdk_pixbuf_non_anim_get_static_image;
577 anim_class->get_size = gdk_pixbuf_non_anim_get_size;
578 anim_class->get_iter = gdk_pixbuf_non_anim_get_iter;
582 gdk_pixbuf_non_anim_init (GdkPixbufNonAnim *non_anim)
587 gdk_pixbuf_non_anim_finalize (GObject *object)
589 GdkPixbufNonAnim *non_anim = GDK_PIXBUF_NON_ANIM (object);
591 if (non_anim->pixbuf)
592 g_object_unref (non_anim->pixbuf);
594 G_OBJECT_CLASS (gdk_pixbuf_non_anim_parent_class)->finalize (object);
598 gdk_pixbuf_non_anim_new (GdkPixbuf *pixbuf)
600 GdkPixbufNonAnim *non_anim;
602 non_anim = g_object_new (GDK_TYPE_PIXBUF_NON_ANIM, NULL);
604 non_anim->pixbuf = pixbuf;
607 g_object_ref (pixbuf);
609 return GDK_PIXBUF_ANIMATION (non_anim);
613 gdk_pixbuf_non_anim_is_static_image (GdkPixbufAnimation *animation)
620 gdk_pixbuf_non_anim_get_static_image (GdkPixbufAnimation *animation)
622 GdkPixbufNonAnim *non_anim;
624 non_anim = GDK_PIXBUF_NON_ANIM (animation);
626 return non_anim->pixbuf;
630 gdk_pixbuf_non_anim_get_size (GdkPixbufAnimation *anim,
634 GdkPixbufNonAnim *non_anim;
636 non_anim = GDK_PIXBUF_NON_ANIM (anim);
639 *width = gdk_pixbuf_get_width (non_anim->pixbuf);
642 *height = gdk_pixbuf_get_height (non_anim->pixbuf);
645 static GdkPixbufAnimationIter*
646 gdk_pixbuf_non_anim_get_iter (GdkPixbufAnimation *anim,
647 const GTimeVal *start_time)
649 GdkPixbufNonAnimIter *iter;
651 iter = g_object_new (GDK_TYPE_PIXBUF_NON_ANIM_ITER, NULL);
653 iter->non_anim = GDK_PIXBUF_NON_ANIM (anim);
655 g_object_ref (iter->non_anim);
657 return GDK_PIXBUF_ANIMATION_ITER (iter);
660 static void gdk_pixbuf_non_anim_iter_finalize (GObject *object);
661 static int gdk_pixbuf_non_anim_iter_get_delay_time (GdkPixbufAnimationIter *iter);
662 static GdkPixbuf* gdk_pixbuf_non_anim_iter_get_pixbuf (GdkPixbufAnimationIter *iter);
663 static gboolean gdk_pixbuf_non_anim_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter);
664 static gboolean gdk_pixbuf_non_anim_iter_advance (GdkPixbufAnimationIter *iter,
665 const GTimeVal *current_time);
667 G_DEFINE_TYPE (GdkPixbufNonAnimIter,
668 gdk_pixbuf_non_anim_iter,
669 GDK_TYPE_PIXBUF_ANIMATION_ITER);
672 gdk_pixbuf_non_anim_iter_class_init (GdkPixbufNonAnimIterClass *klass)
674 GObjectClass *object_class = G_OBJECT_CLASS (klass);
675 GdkPixbufAnimationIterClass *anim_iter_class =
676 GDK_PIXBUF_ANIMATION_ITER_CLASS (klass);
678 object_class->finalize = gdk_pixbuf_non_anim_iter_finalize;
680 anim_iter_class->get_delay_time = gdk_pixbuf_non_anim_iter_get_delay_time;
681 anim_iter_class->get_pixbuf = gdk_pixbuf_non_anim_iter_get_pixbuf;
682 anim_iter_class->on_currently_loading_frame = gdk_pixbuf_non_anim_iter_on_currently_loading_frame;
683 anim_iter_class->advance = gdk_pixbuf_non_anim_iter_advance;
687 gdk_pixbuf_non_anim_iter_init (GdkPixbufNonAnimIter *non_iter)
692 gdk_pixbuf_non_anim_iter_finalize (GObject *object)
694 GdkPixbufNonAnimIter *iter = GDK_PIXBUF_NON_ANIM_ITER (object);
696 g_object_unref (iter->non_anim);
698 G_OBJECT_CLASS (gdk_pixbuf_non_anim_iter_parent_class)->finalize (object);
702 gdk_pixbuf_non_anim_iter_get_delay_time (GdkPixbufAnimationIter *iter)
704 return -1; /* show only frame forever */
708 gdk_pixbuf_non_anim_iter_get_pixbuf (GdkPixbufAnimationIter *iter)
710 return GDK_PIXBUF_NON_ANIM_ITER (iter)->non_anim->pixbuf;
715 gdk_pixbuf_non_anim_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter)
721 gdk_pixbuf_non_anim_iter_advance (GdkPixbufAnimationIter *iter,
722 const GTimeVal *current_time)
725 /* Advancing never requires a refresh */
729 #define __GDK_PIXBUF_ANIMATION_C__
730 #include "gdk-pixbuf-aliasdef.c"