Initial stab at getting the focus code to work.
Fri Jun 1 18:54:47 2001 Jonathan Blandford <jrb@redhat.com> * gtk/gtktreeview.c: (gtk_tree_view_focus): Initial stab at getting the focus code to work. (gtk_tree_view_class_init): Add a bunch of keybindings. * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_set_cell_data_func): s/GtkCellDataFunc/GtkTreeCellDataFunc. (_gtk_tree_view_column_set_tree_view): Use "notify::model" instead of "properties_changed" to help justify the death of the latter signal. (-: * tests/testtreefocus.c (main): Let some columns be focussable to test focus better.
This commit is contained in:
Jonathan Blandford
committed by
Havoc Pennington
Havoc Pennington
parent
11043de66f
commit
741c71eb93
@ -1,3 +1,4 @@
|
||||
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
|
||||
/* GdkPixbuf library - TIFF image loader
|
||||
*
|
||||
* Copyright (C) 1999 Mark Crichton
|
||||
@ -6,6 +7,7 @@
|
||||
* Authors: Mark Crichton <crichton@gimp.org>
|
||||
* Federico Mena-Quintero <federico@gimp.org>
|
||||
* Jonathan Blandford <jrb@redhat.com>
|
||||
* S<>ren Sandmann <sandmann@daimi.au.dk>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
@ -42,103 +44,197 @@
|
||||
#endif
|
||||
|
||||
|
||||
typedef struct _TiffData TiffData;
|
||||
struct _TiffData
|
||||
typedef struct _TiffContext TiffContext;
|
||||
struct _TiffContext
|
||||
{
|
||||
ModulePreparedNotifyFunc prepare_func;
|
||||
ModuleUpdatedNotifyFunc update_func;
|
||||
gpointer user_data;
|
||||
|
||||
gchar *tempname;
|
||||
FILE *file;
|
||||
gboolean all_okay;
|
||||
|
||||
guchar *buffer;
|
||||
guint allocated;
|
||||
guint used;
|
||||
guint pos;
|
||||
};
|
||||
|
||||
|
||||
|
||||
static GdkPixbuf *
|
||||
gdk_pixbuf__tiff_image_load_real (FILE *f, TiffData *context, GError **error)
|
||||
/* There's no user data for the error handlers, so we just have to
|
||||
* put a big-ass lock on the whole TIFF loader
|
||||
*/
|
||||
G_LOCK_DEFINE_STATIC (tiff_loader);
|
||||
static char *global_error = NULL;
|
||||
static TIFFErrorHandler orig_error_handler = NULL;
|
||||
static TIFFErrorHandler orig_warning_handler = NULL;
|
||||
|
||||
static void
|
||||
tiff_warning_handler (const char *mod, const char *fmt, va_list ap)
|
||||
{
|
||||
/* Don't print anything; we should not be dumping junk to
|
||||
* stderr, since that may be bad for some apps.
|
||||
*/
|
||||
|
||||
/* libTIFF seems to occasionally warn about things that
|
||||
* are really errors, so maybe we should just call tiff_error_handler
|
||||
* here.
|
||||
*/
|
||||
}
|
||||
|
||||
static void
|
||||
tiff_error_handler (const char *mod, const char *fmt, va_list ap)
|
||||
{
|
||||
if (global_error) {
|
||||
/* Blah, loader called us twice */
|
||||
return;
|
||||
}
|
||||
|
||||
global_error = g_strdup_vprintf (fmt, ap);
|
||||
}
|
||||
|
||||
static void
|
||||
tiff_push_handlers (void)
|
||||
{
|
||||
if (global_error)
|
||||
g_warning ("TIFF loader left crufty global_error around, FIXME");
|
||||
|
||||
orig_error_handler = TIFFSetErrorHandler (tiff_error_handler);
|
||||
orig_warning_handler = TIFFSetWarningHandler (tiff_warning_handler);
|
||||
}
|
||||
|
||||
static void
|
||||
tiff_pop_handlers (void)
|
||||
{
|
||||
if (global_error)
|
||||
g_warning ("TIFF loader left crufty global_error around, FIXME");
|
||||
|
||||
TIFFSetErrorHandler (orig_error_handler);
|
||||
TIFFSetWarningHandler (orig_warning_handler);
|
||||
}
|
||||
|
||||
static void
|
||||
tiff_set_error (GError **error,
|
||||
int error_code,
|
||||
const char *msg)
|
||||
{
|
||||
/* Take the error message from libtiff and merge it with
|
||||
* some context we provide.
|
||||
*/
|
||||
g_set_error (error,
|
||||
GDK_PIXBUF_ERROR,
|
||||
error_code,
|
||||
"%s%s%s",
|
||||
msg, global_error ? ": " : "", global_error);
|
||||
|
||||
if (global_error) {
|
||||
g_free (global_error);
|
||||
global_error = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
static GdkPixbuf *
|
||||
tiff_image_parse (TIFF *tiff, TiffContext *context, GError **error)
|
||||
{
|
||||
TIFF *tiff;
|
||||
guchar *pixels = NULL;
|
||||
guchar *tmppix;
|
||||
gint w, h, x, y, num_pixs, fd;
|
||||
uint32 *rast, *tmp_rast;
|
||||
gint w, h, x, y, num_pixs;
|
||||
GdkPixbuf *pixbuf;
|
||||
|
||||
fd = fileno (f);
|
||||
tiff = TIFFFdOpen (fd, "libpixbuf-tiff", "r");
|
||||
|
||||
if (!tiff) {
|
||||
/* We're called with the lock held. */
|
||||
|
||||
g_return_val_if_fail (global_error == NULL, NULL);
|
||||
|
||||
if (!TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &w) || global_error) {
|
||||
tiff_set_error (error,
|
||||
GDK_PIXBUF_ERROR_FAILED,
|
||||
_("Could not get image width (bad TIFF file)"));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &h) || global_error) {
|
||||
tiff_set_error (error,
|
||||
GDK_PIXBUF_ERROR_FAILED,
|
||||
_("Could not get image height (bad TIFF file)"));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
num_pixs = w * h;
|
||||
|
||||
if (num_pixs == 0) {
|
||||
g_set_error (error,
|
||||
GDK_PIXBUF_ERROR,
|
||||
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
|
||||
_("Failed to open TIFF image"));
|
||||
return NULL;
|
||||
_("Width or height of TIFF image is zero"));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &w);
|
||||
TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &h);
|
||||
num_pixs = w * h;
|
||||
|
||||
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, w, h);
|
||||
|
||||
if (!pixbuf) {
|
||||
g_set_error (error,
|
||||
GDK_PIXBUF_ERROR,
|
||||
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
|
||||
_("Insufficient memory to open TIFF file"));
|
||||
TIFFClose (tiff);
|
||||
return NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
G_UNLOCK (tiff_loader);
|
||||
if (context)
|
||||
(* context->prepare_func) (pixbuf, NULL, context->user_data);
|
||||
|
||||
G_LOCK (tiff_loader);
|
||||
|
||||
/* Yes, it needs to be _TIFFMalloc... */
|
||||
rast = (uint32 *) _TIFFmalloc (num_pixs * sizeof (uint32));
|
||||
|
||||
rast = (uint32 *) _TIFFmalloc (num_pixs * sizeof (uint32));
|
||||
if (!rast) {
|
||||
g_set_error (error,
|
||||
GDK_PIXBUF_ERROR,
|
||||
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
|
||||
_("Insufficient memory to open TIFF file"));
|
||||
TIFFClose (tiff);
|
||||
return NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!TIFFReadRGBAImage (tiff, w, h, rast, 0) || global_error) {
|
||||
tiff_set_error (error,
|
||||
GDK_PIXBUF_ERROR_FAILED,
|
||||
_("Failed to load RGB data from TIFF file"));
|
||||
_TIFFfree (rast);
|
||||
|
||||
if (TIFFReadRGBAImage (tiff, w, h, rast, 0)) {
|
||||
pixels = gdk_pixbuf_get_pixels (pixbuf);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
pixels = gdk_pixbuf_get_pixels (pixbuf);
|
||||
|
||||
g_assert (pixels);
|
||||
|
||||
tmppix = pixels;
|
||||
|
||||
for (y = 0; y < h; y++) {
|
||||
/* Unexplainable...are tiffs backwards? */
|
||||
/* Also looking at the GIMP plugin, this
|
||||
* whole reading thing can be a bit more
|
||||
* robust.
|
||||
*/
|
||||
tmp_rast = rast + ((h - y - 1) * w);
|
||||
for (x = 0; x < w; x++) {
|
||||
tmppix[0] = TIFFGetR (*tmp_rast);
|
||||
tmppix[1] = TIFFGetG (*tmp_rast);
|
||||
tmppix[2] = TIFFGetB (*tmp_rast);
|
||||
tmppix[3] = TIFFGetA (*tmp_rast);
|
||||
tmp_rast++;
|
||||
tmppix += 4;
|
||||
}
|
||||
}
|
||||
|
||||
g_assert (pixels);
|
||||
|
||||
tmppix = pixels;
|
||||
_TIFFfree (rast);
|
||||
|
||||
for (y = 0; y < h; y++) {
|
||||
/* Unexplainable...are tiffs backwards? */
|
||||
/* Also looking at the GIMP plugin, this
|
||||
* whole reading thing can be a bit more
|
||||
* robust.
|
||||
*/
|
||||
tmp_rast = rast + ((h - y - 1) * w);
|
||||
for (x = 0; x < w; x++) {
|
||||
tmppix[0] = TIFFGetR (*tmp_rast);
|
||||
tmppix[1] = TIFFGetG (*tmp_rast);
|
||||
tmppix[2] = TIFFGetB (*tmp_rast);
|
||||
tmppix[3] = TIFFGetA (*tmp_rast);
|
||||
tmp_rast++;
|
||||
tmppix += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
_TIFFfree (rast);
|
||||
TIFFClose (tiff);
|
||||
|
||||
if (context) {
|
||||
G_UNLOCK (tiff_loader);
|
||||
if (context)
|
||||
(* context->update_func) (pixbuf, 0, 0, w, h, context->user_data);
|
||||
gdk_pixbuf_unref (pixbuf);
|
||||
}
|
||||
|
||||
return pixbuf;
|
||||
G_LOCK (tiff_loader);
|
||||
|
||||
return pixbuf;
|
||||
}
|
||||
|
||||
|
||||
@ -148,17 +244,49 @@ gdk_pixbuf__tiff_image_load_real (FILE *f, TiffData *context, GError **error)
|
||||
static GdkPixbuf *
|
||||
gdk_pixbuf__tiff_image_load (FILE *f, GError **error)
|
||||
{
|
||||
return gdk_pixbuf__tiff_image_load_real (f, NULL, error);
|
||||
TIFF *tiff;
|
||||
int fd;
|
||||
GdkPixbuf *pixbuf;
|
||||
|
||||
g_return_val_if_fail (f != NULL, NULL);
|
||||
|
||||
G_LOCK (tiff_loader);
|
||||
|
||||
tiff_push_handlers ();
|
||||
|
||||
fd = fileno (f);
|
||||
tiff = TIFFFdOpen (fd, "libpixbuf-tiff", "r");
|
||||
|
||||
if (!tiff) {
|
||||
g_set_error (error,
|
||||
GDK_PIXBUF_ERROR,
|
||||
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
|
||||
_("Failed to open TIFF image"));
|
||||
tiff_pop_handlers ();
|
||||
|
||||
G_UNLOCK (tiff_loader);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
pixbuf = tiff_image_parse (tiff, NULL, error);
|
||||
|
||||
TIFFClose (tiff);
|
||||
if (global_error) {
|
||||
tiff_set_error (error,
|
||||
GDK_PIXBUF_ERROR_FAILED,
|
||||
_("TIFFClose operation failed"));
|
||||
}
|
||||
|
||||
tiff_pop_handlers ();
|
||||
|
||||
G_UNLOCK (tiff_loader);
|
||||
|
||||
return pixbuf;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Progressive loader */
|
||||
/*
|
||||
* Tiff loading progressively cannot be done. We write it to a file, then load
|
||||
* the file when it's done. It's not pretty.
|
||||
*/
|
||||
|
||||
|
||||
static gpointer
|
||||
gdk_pixbuf__tiff_image_begin_load (ModulePreparedNotifyFunc prepare_func,
|
||||
@ -166,54 +294,165 @@ gdk_pixbuf__tiff_image_begin_load (ModulePreparedNotifyFunc prepare_func,
|
||||
gpointer user_data,
|
||||
GError **error)
|
||||
{
|
||||
TiffData *context;
|
||||
gint fd;
|
||||
|
||||
context = g_new (TiffData, 1);
|
||||
TiffContext *context;
|
||||
|
||||
context = g_new0 (TiffContext, 1);
|
||||
context->prepare_func = prepare_func;
|
||||
context->update_func = update_func;
|
||||
context->user_data = user_data;
|
||||
context->all_okay = TRUE;
|
||||
fd = g_file_open_tmp ("gdkpixbuf-tif-tmp.XXXXXX", &context->tempname,
|
||||
NULL);
|
||||
if (fd < 0) {
|
||||
g_free (context);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
context->file = fdopen (fd, "w");
|
||||
if (context->file == NULL) {
|
||||
g_free (context->tempname);
|
||||
g_free (context);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
context->buffer = NULL;
|
||||
context->allocated = 0;
|
||||
context->used = 0;
|
||||
context->pos = 0;
|
||||
|
||||
return context;
|
||||
}
|
||||
|
||||
static tsize_t
|
||||
tiff_read (thandle_t handle, tdata_t buf, tsize_t size)
|
||||
{
|
||||
TiffContext *context = (TiffContext *)handle;
|
||||
|
||||
if (context->pos + size > context->used)
|
||||
return 0;
|
||||
|
||||
memcpy (buf, context->buffer + context->pos, size);
|
||||
context->pos += size;
|
||||
return size;
|
||||
}
|
||||
|
||||
static tsize_t
|
||||
tiff_write (thandle_t handle, tdata_t buf, tsize_t size)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
static toff_t
|
||||
tiff_seek (thandle_t handle, toff_t offset, int whence)
|
||||
{
|
||||
TiffContext *context = (TiffContext *)handle;
|
||||
|
||||
switch (whence) {
|
||||
case SEEK_SET:
|
||||
if (offset > context->used || offset < 0)
|
||||
return -1;
|
||||
context->pos = offset;
|
||||
break;
|
||||
case SEEK_CUR:
|
||||
if (offset + context->pos >= context->used)
|
||||
return -1;
|
||||
context->pos += offset;
|
||||
break;
|
||||
case SEEK_END:
|
||||
if (offset + context->used > context->used)
|
||||
return -1;
|
||||
context->pos = context->used + offset;
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
break;
|
||||
}
|
||||
return context->pos;
|
||||
}
|
||||
|
||||
static int
|
||||
tiff_close (thandle_t context)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static toff_t
|
||||
tiff_size (thandle_t handle)
|
||||
{
|
||||
TiffContext *context = (TiffContext *)handle;
|
||||
|
||||
return context->used;
|
||||
}
|
||||
|
||||
static int
|
||||
tiff_map_file (thandle_t handle, tdata_t *buf, toff_t *size)
|
||||
{
|
||||
TiffContext *context = (TiffContext *)handle;
|
||||
|
||||
*buf = context->buffer;
|
||||
*size = context->used;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
tiff_unmap_file (thandle_t handle, tdata_t data, toff_t offset)
|
||||
{
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gdk_pixbuf__tiff_image_stop_load (gpointer data,
|
||||
GError **error)
|
||||
{
|
||||
TiffData *context = (TiffData*) data;
|
||||
gboolean retval = FALSE;
|
||||
TiffContext *context = data;
|
||||
TIFF *tiff;
|
||||
gboolean retval;
|
||||
|
||||
g_return_val_if_fail (data != NULL, TRUE);
|
||||
g_return_val_if_fail (data != NULL, FALSE);
|
||||
|
||||
fflush (context->file);
|
||||
rewind (context->file);
|
||||
if (context->all_okay) {
|
||||
G_LOCK (tiff_loader);
|
||||
|
||||
tiff_push_handlers ();
|
||||
|
||||
tiff = TIFFClientOpen ("libtiff-pixbuf", "r", data,
|
||||
tiff_read, tiff_write,
|
||||
tiff_seek, tiff_close,
|
||||
tiff_size,
|
||||
tiff_map_file, tiff_unmap_file);
|
||||
if (!tiff) {
|
||||
g_set_error (error,
|
||||
GDK_PIXBUF_ERROR,
|
||||
GDK_PIXBUF_ERROR_FAILED,
|
||||
_("Failed to load TIFF image"));
|
||||
retval = FALSE;
|
||||
} else {
|
||||
GdkPixbuf *pixbuf;
|
||||
pixbuf = gdk_pixbuf__tiff_image_load_real (context->file, context, error);
|
||||
if (pixbuf != NULL)
|
||||
retval = TRUE;
|
||||
|
||||
pixbuf = tiff_image_parse (tiff, context, error);
|
||||
if (pixbuf)
|
||||
g_object_unref (G_OBJECT (pixbuf));
|
||||
retval = pixbuf != NULL;
|
||||
TIFFClose (tiff);
|
||||
}
|
||||
|
||||
if (global_error)
|
||||
g_warning ("Error left set in TIFF loader\n");
|
||||
|
||||
g_free (context->buffer);
|
||||
g_free (context);
|
||||
|
||||
fclose (context->file);
|
||||
unlink (context->tempname);
|
||||
g_free (context->tempname);
|
||||
g_free ((TiffData *) context);
|
||||
tiff_pop_handlers ();
|
||||
|
||||
G_UNLOCK (tiff_loader);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
make_available_at_least (TiffContext *context, guint needed)
|
||||
{
|
||||
guchar *new_buffer = NULL;
|
||||
guint need_alloc;
|
||||
|
||||
need_alloc = context->used + needed;
|
||||
if (need_alloc > context->allocated) {
|
||||
guint new_size = 1;
|
||||
while (new_size < need_alloc)
|
||||
new_size *= 2;
|
||||
|
||||
new_buffer = g_try_realloc (context->buffer, new_size);
|
||||
if (new_buffer) {
|
||||
context->buffer = new_buffer;
|
||||
context->allocated = new_size;
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@ -221,28 +460,28 @@ static gboolean
|
||||
gdk_pixbuf__tiff_image_load_increment (gpointer data, const guchar *buf,
|
||||
guint size, GError **error)
|
||||
{
|
||||
TiffData *context = (TiffData *) data;
|
||||
|
||||
TiffContext *context = (TiffContext *) data;
|
||||
|
||||
g_return_val_if_fail (data != NULL, FALSE);
|
||||
|
||||
if (fwrite (buf, sizeof (guchar), size, context->file) != size) {
|
||||
context->all_okay = FALSE;
|
||||
|
||||
if (!make_available_at_least (context, size)) {
|
||||
g_set_error (error,
|
||||
G_FILE_ERROR,
|
||||
g_file_error_from_errno (errno),
|
||||
_("Failed to write to temporary file when loading TIFF image"));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
GDK_PIXBUF_ERROR,
|
||||
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
|
||||
_("Insufficient memory to open TIFF file"));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
memcpy (context->buffer + context->used, buf, size);
|
||||
context->used += size;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void
|
||||
gdk_pixbuf__tiff_fill_vtable (GdkPixbufModule *module)
|
||||
{
|
||||
module->load = gdk_pixbuf__tiff_image_load;
|
||||
module->begin_load = gdk_pixbuf__tiff_image_begin_load;
|
||||
module->stop_load = gdk_pixbuf__tiff_image_stop_load;
|
||||
module->load_increment = gdk_pixbuf__tiff_image_load_increment;
|
||||
module->load = gdk_pixbuf__tiff_image_load;
|
||||
module->begin_load = gdk_pixbuf__tiff_image_begin_load;
|
||||
module->stop_load = gdk_pixbuf__tiff_image_stop_load;
|
||||
module->load_increment = gdk_pixbuf__tiff_image_load_increment;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user