forked from AuroraMiddleware/gtk
e0fee22e78
2001-01-22 Havoc Pennington <hp@redhat.com>
* Makefile.am: Add built marshaller files to support
GdkPixbufLoader signals
* gdk-pixbuf-io.c (gdk_pixbuf_load_module): have
GDK_PIXBUF_MODULEDIR unconditionally replace the compiled-in
module location, rather than acting as a fallback, because we are
using GDK_PIXBUF_MODULEDIR to use gdk-pixbuf before installing it.
* gdk-pixbuf.h: include gdk-pixbuf-loader.h
* gdk-pixbuf-loader.h, gdk-pixbuf-loader.c: Move back over here
from gtk, and add error to close(), because stop_load may do
parsing of the image.
* pixops/have_mmx.S (_pixops_have_mmx): add newline at end of file
* io-*.c: make individual operations static, and add fill_vtable
functions which are exported. Fix the collection of type warnings
that surfaced, including a number of functions that didn't
properly take a GError and some that weren't
const-correct. Involved adding error handling for a few loaders.
* gdk-pixbuf-io.h: Add error reporting to stop_load function
* gdk-pixbuf-io.c (gdk_pixbuf_load_module): change to just look up
a function that fills in the GdkPixbufModule vtable, instead of
looking up all the image functions individually; this means we
can get type safety within modules for the loader functions.
Also it means you don't have to keep the statically compiled and
GModule versions in sync.
* test-gdk-pixbuf.c (main): remove gdk_pixbuf_init()
* make-inline-pixbuf.c (main): remove call to gdk_pixbuf_init()
* gdk-pixbuf.h: nuke gdk_pixbuf_init()
* gdk-pixbuf-animation.c (gdk_pixbuf_frame_get_type): g_type_init
() here
* gdk-pixbuf.c (gdk_pixbuf_get_type): g_type_init () here
* gdk-pixbuf-animation.c (gdk_pixbuf_animation_get_type):
g_type_init() here
2001-01-22 Havoc Pennington <hp@redhat.com>
* demos/testanimation.c: fix to reflect gdk-pixbuf changes
* demos/testpixbuf.c: fix to reflect gdk-pixbuf changes
* gtk/gdk-pixbuf-loader.c, gtk/gdk-pixbuf-loader.h:
Remove, move back to gdk-pixbuf
* gtk/gtktextiter.c, gtk/gtktextiter.h: add sentence equivalents
to all the word functions
* gtk/gtktextview.c (gtk_text_view_start_cursor_blink): return
before doing anything on NULL layout or if we don't have the focus
* gtk/testtext.c (fill_example_buffer): "justification"
* gtk/gtktexttag.h, gtk/gtktexttag.c: change the tag attribute
to be called "justification" not "justify"
* demos/gtk-demo/textview.c (create_tags): "justification"
* gtk/gtktextlayout.c (set_para_values): Handle char-wise wrapping
471 lines
13 KiB
C
471 lines
13 KiB
C
/* GdkPixbuf library - Simple animation support
|
||
*
|
||
* Copyright (C) 1999 The Free Software Foundation
|
||
*
|
||
* Authors: Jonathan Blandford <jrb@redhat.com>
|
||
* Havoc Pennington <hp@redhat.com>
|
||
*
|
||
* 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, write to the
|
||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||
* Boston, MA 02111-1307, USA.
|
||
*/
|
||
|
||
#include <config.h>
|
||
#include <errno.h>
|
||
#include "gdk-pixbuf-io.h"
|
||
#include "gdk-pixbuf-private.h"
|
||
|
||
static void gdk_pixbuf_animation_class_init (GdkPixbufAnimationClass *klass);
|
||
static void gdk_pixbuf_animation_finalize (GObject *object);
|
||
|
||
|
||
|
||
static gpointer parent_class;
|
||
|
||
GType
|
||
gdk_pixbuf_animation_get_type (void)
|
||
{
|
||
static GType object_type = 0;
|
||
|
||
if (!object_type) {
|
||
static const GTypeInfo object_info = {
|
||
sizeof (GdkPixbufAnimationClass),
|
||
(GBaseInitFunc) NULL,
|
||
(GBaseFinalizeFunc) NULL,
|
||
(GClassInitFunc) gdk_pixbuf_animation_class_init,
|
||
NULL, /* class_finalize */
|
||
NULL, /* class_data */
|
||
sizeof (GdkPixbufAnimation),
|
||
0, /* n_preallocs */
|
||
(GInstanceInitFunc) NULL,
|
||
};
|
||
|
||
g_type_init ();
|
||
|
||
object_type = g_type_register_static (G_TYPE_OBJECT,
|
||
"GdkPixbufAnimation",
|
||
&object_info, 0);
|
||
}
|
||
|
||
return object_type;
|
||
}
|
||
|
||
static void
|
||
gdk_pixbuf_animation_class_init (GdkPixbufAnimationClass *klass)
|
||
{
|
||
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
||
|
||
parent_class = g_type_class_peek_parent (klass);
|
||
|
||
object_class->finalize = gdk_pixbuf_animation_finalize;
|
||
}
|
||
|
||
static void
|
||
gdk_pixbuf_animation_finalize (GObject *object)
|
||
{
|
||
GdkPixbufAnimation *animation = GDK_PIXBUF_ANIMATION (object);
|
||
|
||
GList *l;
|
||
GdkPixbufFrame *frame;
|
||
|
||
for (l = animation->frames; l; l = l->next) {
|
||
frame = l->data;
|
||
gdk_pixbuf_unref (frame->pixbuf);
|
||
g_free (frame);
|
||
}
|
||
|
||
g_list_free (animation->frames);
|
||
|
||
G_OBJECT_CLASS (parent_class)->finalize (object);
|
||
}
|
||
|
||
|
||
|
||
/**
|
||
* gdk_pixbuf_animation_new_from_file:
|
||
* @filename: Name of file to load.
|
||
* @error: return location for error
|
||
*
|
||
* Creates a new animation by loading it from a file. The file format is
|
||
* detected automatically. If the file's format does not support multi-frame
|
||
* images, then an animation with a single frame will be created. Possible errors
|
||
* are in the #GDK_PIXBUF_ERROR and #G_FILE_ERROR domains.
|
||
*
|
||
* Return value: A newly created animation with a reference count of 1, or NULL
|
||
* if any of several error conditions ocurred: the file could not be opened,
|
||
* there was no loader for the file's format, there was not enough memory to
|
||
* allocate the image buffer, or the image file contained invalid data.
|
||
**/
|
||
GdkPixbufAnimation *
|
||
gdk_pixbuf_animation_new_from_file (const char *filename,
|
||
GError **error)
|
||
{
|
||
GdkPixbufAnimation *animation;
|
||
int size;
|
||
FILE *f;
|
||
guchar buffer [128];
|
||
GdkPixbufModule *image_module;
|
||
|
||
g_return_val_if_fail (filename != NULL, NULL);
|
||
|
||
f = fopen (filename, "rb");
|
||
if (!f) {
|
||
g_set_error (error,
|
||
G_FILE_ERROR,
|
||
g_file_error_from_errno (errno),
|
||
_("Failed to open file '%s': %s"),
|
||
filename, g_strerror (errno));
|
||
return NULL;
|
||
}
|
||
|
||
size = fread (&buffer, 1, sizeof (buffer), f);
|
||
|
||
if (size == 0) {
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
|
||
_("Image file '%s' contains no data"),
|
||
filename);
|
||
|
||
fclose (f);
|
||
return NULL;
|
||
}
|
||
|
||
image_module = gdk_pixbuf_get_module (buffer, size, filename, error);
|
||
if (!image_module) {
|
||
fclose (f);
|
||
return NULL;
|
||
}
|
||
|
||
if (image_module->module == NULL)
|
||
if (!gdk_pixbuf_load_module (image_module, error)) {
|
||
fclose (f);
|
||
return NULL;
|
||
}
|
||
|
||
if (image_module->load_animation == NULL) {
|
||
GdkPixbuf *pixbuf;
|
||
GdkPixbufFrame *frame;
|
||
|
||
/* Keep this logic in sync with gdk_pixbuf_new_from_file() */
|
||
|
||
if (image_module->load == NULL) {
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION,
|
||
_("Don't know how to load the animation in file '%s'"),
|
||
filename);
|
||
fclose (f);
|
||
return NULL;
|
||
}
|
||
|
||
fseek (f, 0, SEEK_SET);
|
||
pixbuf = (* image_module->load) (f, error);
|
||
fclose (f);
|
||
|
||
if (pixbuf == NULL && error != NULL && *error == NULL) {
|
||
/* I don't trust these crufty longjmp()'ing image libs
|
||
* to maintain proper error invariants, and I don't
|
||
* want user code to segfault as a result. We need to maintain
|
||
* the invariant that error gets set if NULL is returned.
|
||
*/
|
||
|
||
g_warning ("Bug! gdk-pixbuf loader '%s' didn't set an error on failure.",
|
||
image_module->module_name);
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_FAILED,
|
||
_("Failed to load image '%s': reason not known, probably a corrupt image file"),
|
||
filename);
|
||
}
|
||
|
||
if (pixbuf == NULL)
|
||
return NULL;
|
||
|
||
frame = g_new (GdkPixbufFrame, 1);
|
||
frame->pixbuf = pixbuf;
|
||
g_object_ref (G_OBJECT (frame->pixbuf));
|
||
frame->x_offset = 0;
|
||
frame->y_offset = 0;
|
||
frame->delay_time = -1;
|
||
frame->action = GDK_PIXBUF_FRAME_RETAIN;
|
||
|
||
animation = g_object_new (GDK_TYPE_PIXBUF_ANIMATION, NULL);
|
||
|
||
animation->n_frames = 1;
|
||
animation->frames = g_list_prepend (NULL, frame);
|
||
animation->width = gdk_pixbuf_get_width (pixbuf);
|
||
animation->height = gdk_pixbuf_get_height (pixbuf);
|
||
} else {
|
||
fseek (f, 0, SEEK_SET);
|
||
animation = (* image_module->load_animation) (f, error);
|
||
|
||
if (animation == NULL && error != NULL && *error == NULL) {
|
||
/* I don't trust these crufty longjmp()'ing
|
||
* image libs to maintain proper error
|
||
* invariants, and I don't want user code to
|
||
* segfault as a result. We need to maintain
|
||
* the invariant that error gets set if NULL
|
||
* is returned.
|
||
*/
|
||
|
||
g_warning ("Bug! gdk-pixbuf loader '%s' didn't set an error on failure.",
|
||
image_module->module_name);
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_FAILED,
|
||
_("Failed to load animation '%s': reason not known, probably a corrupt animation file"),
|
||
filename);
|
||
}
|
||
|
||
fclose (f);
|
||
}
|
||
|
||
return animation;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_animation_ref:
|
||
* @animation: An animation.
|
||
*
|
||
* Adds a reference to an animation. Deprecated; use
|
||
* g_object_ref(). The reference must be released afterwards using
|
||
* g_object_unref().
|
||
*
|
||
* Return value: The same as the @animation argument.
|
||
**/
|
||
GdkPixbufAnimation *
|
||
gdk_pixbuf_animation_ref (GdkPixbufAnimation *animation)
|
||
{
|
||
return (GdkPixbufAnimation*) g_object_ref (G_OBJECT (animation));
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_animation_unref:
|
||
* @animation: An animation.
|
||
*
|
||
* Removes a reference from an animation. Deprecated; use g_object_unref().
|
||
**/
|
||
void
|
||
gdk_pixbuf_animation_unref (GdkPixbufAnimation *animation)
|
||
{
|
||
g_object_unref (G_OBJECT (animation));
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_animation_get_width:
|
||
* @animation: An animation.
|
||
*
|
||
* Queries the width of the bounding box of a pixbuf animation.
|
||
*
|
||
* Return value: Width of the bounding box of the animation.
|
||
**/
|
||
int
|
||
gdk_pixbuf_animation_get_width (GdkPixbufAnimation *animation)
|
||
{
|
||
g_return_val_if_fail (animation != NULL, -1);
|
||
|
||
return animation->width;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_animation_get_height:
|
||
* @animation: An animation.
|
||
*
|
||
* Queries the height of the bounding box of a pixbuf animation.
|
||
*
|
||
* Return value: Height of the bounding box of the animation.
|
||
**/
|
||
int
|
||
gdk_pixbuf_animation_get_height (GdkPixbufAnimation *animation)
|
||
{
|
||
g_return_val_if_fail (animation != NULL, -1);
|
||
|
||
return animation->height;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_animation_get_num_frames:
|
||
* @animation: An animation.
|
||
*
|
||
* Queries the number of frames in a pixbuf animation.
|
||
*
|
||
* Return value: Number of frames in the animation.
|
||
**/
|
||
int
|
||
gdk_pixbuf_animation_get_num_frames (GdkPixbufAnimation *animation)
|
||
{
|
||
g_return_val_if_fail (animation != NULL, -1);
|
||
|
||
return animation->n_frames;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_animation_get_frames:
|
||
* @animation: An animation.
|
||
*
|
||
* Queries the list of frames of an animation.
|
||
*
|
||
* Return value: List of frames in the animation; this is a #GList of
|
||
* #GdkPixbufFrame structures.
|
||
**/
|
||
GList *
|
||
gdk_pixbuf_animation_get_frames (GdkPixbufAnimation *animation)
|
||
{
|
||
g_return_val_if_fail (animation != NULL, NULL);
|
||
|
||
return animation->frames;
|
||
}
|
||
|
||
|
||
|
||
/**
|
||
* gdk_pixbuf_frame_get_pixbuf:
|
||
* @frame: A pixbuf animation frame.
|
||
*
|
||
* Queries the pixbuf of an animation frame.
|
||
*
|
||
* Return value: A pixbuf.
|
||
**/
|
||
GdkPixbuf *
|
||
gdk_pixbuf_frame_get_pixbuf (GdkPixbufFrame *frame)
|
||
{
|
||
g_return_val_if_fail (frame != NULL, NULL);
|
||
|
||
return frame->pixbuf;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_frame_get_x_offset:
|
||
* @frame: A pixbuf animation frame.
|
||
*
|
||
* Queries the X offset of an animation frame.
|
||
*
|
||
* Return value: X offset from the top left corner of the animation.
|
||
**/
|
||
int
|
||
gdk_pixbuf_frame_get_x_offset (GdkPixbufFrame *frame)
|
||
{
|
||
g_return_val_if_fail (frame != NULL, -1);
|
||
|
||
return frame->x_offset;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_frame_get_y_offset:
|
||
* @frame: A pixbuf animation frame.
|
||
*
|
||
* Queries the Y offset of an animation frame.
|
||
*
|
||
* Return value: Y offset from the top left corner of the animation.
|
||
**/
|
||
int
|
||
gdk_pixbuf_frame_get_y_offset (GdkPixbufFrame *frame)
|
||
{
|
||
g_return_val_if_fail (frame != NULL, -1);
|
||
|
||
return frame->y_offset;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_frame_get_delay_time:
|
||
* @frame: A pixbuf animation frame.
|
||
*
|
||
* Queries the delay time in milliseconds of an animation frame.
|
||
*
|
||
* Return value: Delay time in milliseconds.
|
||
**/
|
||
int
|
||
gdk_pixbuf_frame_get_delay_time (GdkPixbufFrame *frame)
|
||
{
|
||
g_return_val_if_fail (frame != NULL, -1);
|
||
|
||
return frame->delay_time;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_frame_get_action:
|
||
* @frame: A pixbuf animation frame.
|
||
*
|
||
* Queries the overlay action of an animation frame.
|
||
*
|
||
* Return value: Overlay action for this frame.
|
||
**/
|
||
GdkPixbufFrameAction
|
||
gdk_pixbuf_frame_get_action (GdkPixbufFrame *frame)
|
||
{
|
||
g_return_val_if_fail (frame != NULL, GDK_PIXBUF_FRAME_RETAIN);
|
||
|
||
return frame->action;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_frame_copy:
|
||
* @src: a #GdkPixbufFrame to copy
|
||
*
|
||
* Copies a #GdkPixbufFrame. Free the result
|
||
* with gdk_pixbuf_frame_free().
|
||
*
|
||
* Return value: a new #GdkPixbufFrame
|
||
**/
|
||
GdkPixbufFrame*
|
||
gdk_pixbuf_frame_copy (GdkPixbufFrame *src)
|
||
{
|
||
GdkPixbufFrame *frame;
|
||
|
||
frame = g_new (GdkPixbufFrame, 1);
|
||
frame->pixbuf = src->pixbuf;
|
||
g_object_ref (G_OBJECT (frame->pixbuf));
|
||
frame->x_offset = src->x_offset;
|
||
frame->y_offset = src->y_offset;
|
||
frame->delay_time = src->delay_time;
|
||
frame->action = src->action;
|
||
|
||
return frame;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_frame_free:
|
||
* @frame: a #GdkPixbufFrame
|
||
*
|
||
* Frees a #GdkPixbufFrame. Don't do this with frames you got from
|
||
* #GdkPixbufAnimation, usually the animation owns those (it doesn't
|
||
* make a copy before returning the frame).
|
||
**/
|
||
void
|
||
gdk_pixbuf_frame_free (GdkPixbufFrame *frame)
|
||
{
|
||
g_return_if_fail (frame != NULL);
|
||
|
||
g_object_unref (G_OBJECT (frame->pixbuf));
|
||
g_free (frame);
|
||
}
|
||
|
||
GType
|
||
gdk_pixbuf_frame_get_type (void)
|
||
{
|
||
static GType our_type = 0;
|
||
|
||
if (our_type == 0)
|
||
{
|
||
g_type_init ();
|
||
|
||
our_type = g_boxed_type_register_static ("GdkPixbufFrame",
|
||
gdk_pixbuf_frame_copy,
|
||
gdk_pixbuf_frame_free);
|
||
}
|
||
|
||
return our_type;
|
||
}
|