moving from https://github.com/perberos/mate-desktop-environment

author: Perberos <[email protected]> 2011-12-01 22:24:23 -0300
committer: Perberos <[email protected]> 2011-12-01 22:24:23 -0300
commit: 0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree: 43261e815529cb9518ed7be37af13b846af8b26b /eel/eel-gdk-pixbuf-extensions.c
download: caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2
caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz
1 files changed, 1510 insertions, 0 deletions
diff --git a/eel/eel-gdk-pixbuf-extensions.c b/eel/eel-gdk-pixbuf-extensions.c
new file mode 100644
index 00000000..a58ef4c5
--- /dev/null
+++ b/eel/eel-gdk-pixbuf-extensions.c
@@ -0,0 +1,1510 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* eel-gdk-pixbuf-extensions.c: Routines to augment what's in gdk-pixbuf.
+
+ Copyright (C) 2000 Eazel, Inc.
+
+ The Mate 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.
+
+ The Mate 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 the Mate Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+
+ Authors: Darin Adler <[email protected]>
+ Ramiro Estrugo <[email protected]>
+*/
+
+#include <config.h>
+#include "eel-gdk-pixbuf-extensions.h"
+
+#include "eel-art-gtk-extensions.h"
+#include "eel-debug-drawing.h"
+#include "eel-debug.h"
+#include "eel-gdk-extensions.h"
+#include "eel-glib-extensions.h"
+#include "eel-graphic-effects.h"
+#include "eel-lib-self-check-functions.h"
+#include "eel-string.h"
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gdk/gdkprivate.h>
+#include <gdk/gdkx.h>
+#include <gio/gio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define LOAD_BUFFER_SIZE 65536
+
+const EelIRect eel_gdk_pixbuf_whole_pixbuf = { G_MININT, G_MININT, G_MAXINT, G_MAXINT };
+
+struct EelPixbufLoadHandle
+{
+ GCancellable *cancellable;
+ GInputStream *stream;
+ EelPixbufLoadCallback callback;
+ gpointer callback_data;
+ GdkPixbufLoader *loader;
+ char buffer[LOAD_BUFFER_SIZE];
+};
+
+/**
+ * eel_gdk_pixbuf_list_ref
+ * @pixbuf_list: A list of GdkPixbuf objects.
+ *
+ * Refs all the pixbufs.
+ **/
+void
+eel_gdk_pixbuf_list_ref (GList *pixbuf_list)
+{
+ g_list_foreach (pixbuf_list, (GFunc) g_object_ref, NULL);
+}
+
+/**
+ * eel_gdk_pixbuf_list_free
+ * @pixbuf_list: A list of GdkPixbuf objects.
+ *
+ * Unrefs all the pixbufs, then frees the list.
+ **/
+void
+eel_gdk_pixbuf_list_free (GList *pixbuf_list)
+{
+ eel_g_list_free_deep_custom (pixbuf_list, (GFunc) g_object_unref, NULL);
+}
+
+GdkPixbuf *
+eel_gdk_pixbuf_load (const char *uri)
+{
+ GdkPixbuf *pixbuf;
+ GFile *file;
+ GFileInputStream *stream;
+
+ g_return_val_if_fail (uri != NULL, NULL);
+
+ file = g_file_new_for_uri (uri);
+
+ stream = g_file_read (file, NULL, NULL);
+
+ g_object_unref (file);
+
+ if (stream == NULL)
+ {
+ return NULL;
+ }
+
+ pixbuf = eel_gdk_pixbuf_load_from_stream (G_INPUT_STREAM (stream));
+
+ g_object_unref (stream);
+
+ return pixbuf;
+}
+
+GdkPixbuf *
+eel_gdk_pixbuf_load_from_stream (GInputStream *stream)
+{
+ return eel_gdk_pixbuf_load_from_stream_at_size (stream, -1);
+}
+
+static void
+pixbuf_loader_size_prepared (GdkPixbufLoader *loader,
+ int width,
+ int height,
+ gpointer desired_size_ptr)
+{
+ int size, desired_size;
+ float scale;
+
+ size = MAX (width, height);
+ desired_size = GPOINTER_TO_INT (desired_size_ptr);
+
+ if (size != desired_size)
+ {
+ scale = (float) desired_size / size;
+ gdk_pixbuf_loader_set_size (loader,
+ floor (scale * width + 0.5),
+ floor (scale * height + 0.5));
+ }
+}
+
+GdkPixbuf *
+eel_gdk_pixbuf_load_from_stream_at_size (GInputStream *stream,
+ int size)
+{
+ char buffer[LOAD_BUFFER_SIZE];
+ gssize bytes_read;
+ GdkPixbufLoader *loader;
+ GdkPixbuf *pixbuf;
+ gboolean got_eos;
+
+
+ g_return_val_if_fail (stream != NULL, NULL);
+
+ got_eos = FALSE;
+ loader = gdk_pixbuf_loader_new ();
+
+ if (size > 0)
+ {
+ g_signal_connect (loader, "size-prepared",
+ G_CALLBACK (pixbuf_loader_size_prepared),
+ GINT_TO_POINTER (size));
+ }
+
+ while (1)
+ {
+ bytes_read = g_input_stream_read (stream, buffer, sizeof (buffer),
+ NULL, NULL);
+
+ if (bytes_read < 0)
+ {
+ break;
+ }
+ if (bytes_read == 0)
+ {
+ got_eos = TRUE;
+ break;
+ }
+ if (!gdk_pixbuf_loader_write (loader,
+ buffer,
+ bytes_read,
+ NULL))
+ {
+ break;
+ }
+ }
+
+ g_input_stream_close (stream, NULL, NULL);
+ gdk_pixbuf_loader_close (loader, NULL);
+
+ pixbuf = NULL;
+ if (got_eos)
+ {
+ pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
+ if (pixbuf != NULL)
+ {
+ g_object_ref (pixbuf);
+ }
+ }
+
+ g_object_unref (loader);
+
+ return pixbuf;
+}
+
+static void
+free_pixbuf_load_handle (EelPixbufLoadHandle *handle)
+{
+ g_object_unref (handle->cancellable);
+ if (handle->loader != NULL)
+ {
+ g_object_unref (handle->loader);
+ }
+ if (handle->stream)
+ {
+ g_input_stream_close_async (handle->stream, 0, NULL, NULL, NULL);
+ g_object_unref (handle->stream);
+ }
+ g_free (handle);
+}
+
+static void
+load_done (EelPixbufLoadHandle *handle, GError *error, gboolean get_pixbuf)
+{
+ GdkPixbuf *pixbuf;
+
+ if (handle->loader != NULL)
+ {
+ gdk_pixbuf_loader_close (handle->loader, NULL);
+ }
+
+ pixbuf = get_pixbuf ? gdk_pixbuf_loader_get_pixbuf (handle->loader) : NULL;
+
+ handle->callback (error, pixbuf, handle->callback_data);
+
+ free_pixbuf_load_handle (handle);
+}
+
+static void
+file_read_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ EelPixbufLoadHandle *handle;
+ gssize bytes_read;
+ GError *error;
+
+ handle = user_data;
+
+ if (g_cancellable_is_cancelled (handle->cancellable))
+ {
+ free_pixbuf_load_handle (handle);
+ return;
+ }
+
+ error = NULL;
+ bytes_read = g_input_stream_read_finish (G_INPUT_STREAM (source_object),
+ res, &error);
+
+ if (bytes_read > 0)
+ {
+ if (!gdk_pixbuf_loader_write (handle->loader,
+ handle->buffer,
+ bytes_read,
+ &error))
+ {
+ bytes_read = -1;
+ }
+ else
+ {
+ g_input_stream_read_async (handle->stream,
+ handle->buffer,
+ sizeof (handle->buffer),
+ 0,
+ handle->cancellable,
+ file_read_callback, handle);
+ return;
+ }
+ }
+
+ load_done (handle, error, bytes_read == 0);
+
+ if (error != NULL)
+ {
+ g_error_free (error);
+ }
+}
+
+static void
+file_opened_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ EelPixbufLoadHandle *handle;
+ GFileInputStream *stream;
+ GError *error;
+
+ handle = user_data;
+
+ if (g_cancellable_is_cancelled (handle->cancellable))
+ {
+ free_pixbuf_load_handle (handle);
+ return;
+ }
+
+ error = NULL;
+ stream = g_file_read_finish (G_FILE (source_object), res, &error);
+
+ if (stream == NULL)
+ {
+ load_done (handle, error, FALSE);
+ g_error_free (error);
+ return;
+ }
+
+ handle->stream = G_INPUT_STREAM (stream);
+ handle->loader = gdk_pixbuf_loader_new ();
+
+
+ g_input_stream_read_async (handle->stream,
+ handle->buffer,
+ sizeof (handle->buffer),
+ 0,
+ handle->cancellable,
+ file_read_callback, handle);
+}
+
+EelPixbufLoadHandle *
+eel_gdk_pixbuf_load_async (const char *uri,
+ int priority,
+ EelPixbufLoadCallback callback,
+ gpointer callback_data)
+{
+ EelPixbufLoadHandle *handle;
+ GFile *file;
+
+ handle = g_new0 (EelPixbufLoadHandle, 1);
+ handle->cancellable = g_cancellable_new ();
+ handle->callback = callback;
+ handle->callback_data = callback_data;
+
+ file = g_file_new_for_uri (uri);
+
+ g_file_read_async (file, priority, handle->cancellable,
+ file_opened_callback, handle);
+
+ return handle;
+}
+
+void
+eel_cancel_gdk_pixbuf_load (EelPixbufLoadHandle *handle)
+{
+ if (handle == NULL)
+ {
+ return;
+ }
+
+ g_cancellable_cancel (handle->cancellable);
+}
+
+/* return the average value of each component */
+guint32
+eel_gdk_pixbuf_average_value (GdkPixbuf *pixbuf)
+{
+ guint64 a_total, r_total, g_total, b_total;
+ guint row, column;
+ int row_stride;
+ const guchar *pixels, *p;
+ int r, g, b, a;
+ guint64 dividend;
+ guint width, height;
+
+ width = gdk_pixbuf_get_width (pixbuf);
+ height = gdk_pixbuf_get_height (pixbuf);
+ row_stride = gdk_pixbuf_get_rowstride (pixbuf);
+ pixels = gdk_pixbuf_get_pixels (pixbuf);
+
+ /* iterate through the pixbuf, counting up each component */
+ a_total = 0;
+ r_total = 0;
+ g_total = 0;
+ b_total = 0;
+
+ if (gdk_pixbuf_get_has_alpha (pixbuf))
+ {
+ for (row = 0; row < height; row++)
+ {
+ p = pixels + (row * row_stride);
+ for (column = 0; column < width; column++)
+ {
+ r = *p++;
+ g = *p++;
+ b = *p++;
+ a = *p++;
+
+ a_total += a;
+ r_total += r * a;
+ g_total += g * a;
+ b_total += b * a;
+ }
+ }
+ dividend = height * width * 0xFF;
+ a_total *= 0xFF;
+ }
+ else
+ {
+ for (row = 0; row < height; row++)
+ {
+ p = pixels + (row * row_stride);
+ for (column = 0; column < width; column++)
+ {
+ r = *p++;
+ g = *p++;
+ b = *p++;
+
+ r_total += r;
+ g_total += g;
+ b_total += b;
+ }
+ }
+ dividend = height * width;
+ a_total = dividend * 0xFF;
+ }
+
+ return ((a_total + dividend / 2) / dividend) << 24
+ | ((r_total + dividend / 2) / dividend) << 16
+ | ((g_total + dividend / 2) / dividend) << 8
+ | ((b_total + dividend / 2) / dividend);
+}
+
+double
+eel_gdk_scale_to_fit_factor (int width, int height,
+ int max_width, int max_height,
+ int *scaled_width, int *scaled_height)
+{
+ double scale_factor;
+
+ scale_factor = MIN (max_width / (double) width, max_height / (double) height);
+
+ *scaled_width = floor (width * scale_factor + .5);
+ *scaled_height = floor (height * scale_factor + .5);
+
+ return scale_factor;
+}
+
+/* Returns a scaled copy of pixbuf, preserving aspect ratio. The copy will
+ * be scaled as large as possible without exceeding the specified width and height.
+ */
+GdkPixbuf *
+eel_gdk_pixbuf_scale_to_fit (GdkPixbuf *pixbuf, int max_width, int max_height)
+{
+ int scaled_width;
+ int scaled_height;
+
+ eel_gdk_scale_to_fit_factor (gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
+ max_width, max_height,
+ &scaled_width, &scaled_height);
+
+ return gdk_pixbuf_scale_simple (pixbuf, scaled_width, scaled_height, GDK_INTERP_BILINEAR);
+}
+
+/* Returns a copy of pixbuf scaled down, preserving aspect ratio, to fit
+ * within the specified width and height. If it already fits, a copy of
+ * the original, without scaling, is returned.
+ */
+GdkPixbuf *
+eel_gdk_pixbuf_scale_down_to_fit (GdkPixbuf *pixbuf, int max_width, int max_height)
+{
+ int scaled_width;
+ int scaled_height;
+
+ double scale_factor;
+
+ scale_factor = eel_gdk_scale_to_fit_factor (gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
+ max_width, max_height,
+ &scaled_width, &scaled_height);
+
+ if (scale_factor >= 1.0)
+ {
+ return gdk_pixbuf_copy (pixbuf);
+ }
+ else
+ {
+ return eel_gdk_pixbuf_scale_down (pixbuf, scaled_width, scaled_height);
+ }
+}
+
+double
+eel_gdk_scale_to_min_factor (int width, int height,
+ int min_width, int min_height,
+ int *scaled_width, int *scaled_height)
+{
+ double scale_factor;
+
+ scale_factor = MAX (min_width / (double) width, min_height / (double) height);
+
+ *scaled_width = floor (width * scale_factor + .5);
+ *scaled_height = floor (height * scale_factor + .5);
+
+ return scale_factor;
+}
+
+/* Returns a scaled copy of pixbuf, preserving aspect ratio. The copy will
+ * be scaled as small as possible without going under the specified width and height.
+ */
+GdkPixbuf *
+eel_gdk_pixbuf_scale_to_min (GdkPixbuf *pixbuf, int min_width, int min_height)
+{
+ int scaled_width;
+ int scaled_height;
+
+ eel_gdk_scale_to_min_factor (gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
+ min_width, min_height,
+ &scaled_width, &scaled_height);
+
+ return gdk_pixbuf_scale_simple (pixbuf, scaled_width, scaled_height, GDK_INTERP_BILINEAR);
+}
+
+/**
+ * eel_gdk_pixbuf_is_valid:
+ * @pixbuf: A GdkPixbuf
+ *
+ * Return value: A boolean indicating whether the given pixbuf is valid.
+ *
+ * A pixbuf is valid if:
+ *
+ * 1. It is non NULL
+ * 2. It is has non NULL pixel data.
+ * 3. It has width and height greater than 0.
+ */
+gboolean
+eel_gdk_pixbuf_is_valid (const GdkPixbuf *pixbuf)
+{
+ return ((pixbuf != NULL)
+ && (gdk_pixbuf_get_pixels (pixbuf) != NULL)
+ && (gdk_pixbuf_get_width (pixbuf) > 0)
+ && (gdk_pixbuf_get_height (pixbuf) > 0));
+}
+
+/**
+ * eel_gdk_pixbuf_get_dimensions:
+ * @pixbuf: A GdkPixbuf
+ *
+ * Return value: The dimensions of the pixbuf as a EelDimensions.
+ *
+ * This function is useful in code that uses libart rect
+ * intersection routines.
+ */
+EelDimensions
+eel_gdk_pixbuf_get_dimensions (const GdkPixbuf *pixbuf)
+{
+ EelDimensions dimensions;
+
+ g_return_val_if_fail (eel_gdk_pixbuf_is_valid (pixbuf), eel_dimensions_empty);
+
+ dimensions.width = gdk_pixbuf_get_width (pixbuf);
+ dimensions.height = gdk_pixbuf_get_height (pixbuf);
+
+ return dimensions;
+}
+
+/**
+ * eel_gdk_pixbuf_fill_rectangle_with_color:
+ * @pixbuf: Target pixbuf to fill into.
+ * @area: Rectangle to fill.
+ * @color: The color to use.
+ *
+ * Fill the rectangle with the the given color.
+ */
+void
+eel_gdk_pixbuf_fill_rectangle_with_color (GdkPixbuf *pixbuf,
+ EelIRect area,
+ guint32 color)
+{
+ EelIRect target;
+ guchar red;
+ guchar green;
+ guchar blue;
+ guchar alpha;
+ guchar *pixels;
+ gboolean has_alpha;
+ guint pixel_offset;
+ guint rowstride;
+ guchar *row_offset;
+ int x;
+ int y;
+
+ g_return_if_fail (eel_gdk_pixbuf_is_valid (pixbuf));
+
+ target = eel_gdk_pixbuf_intersect (pixbuf, 0, 0, area);
+ if (eel_irect_is_empty (&target))
+ {
+ return;
+ }
+
+ pixels = gdk_pixbuf_get_pixels (pixbuf);
+ rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+ has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
+ pixel_offset = has_alpha ? 4 : 3;
+ red = EEL_RGBA_COLOR_GET_R (color);
+ green = EEL_RGBA_COLOR_GET_G (color);
+ blue = EEL_RGBA_COLOR_GET_B (color);
+ alpha = EEL_RGBA_COLOR_GET_A (color);
+
+ row_offset = pixels + target.y0 * rowstride;
+
+ for (y = target.y0; y < target.y1; y++)
+ {
+ guchar *offset = row_offset + (target.x0 * pixel_offset);
+
+ for (x = target.x0; x < target.x1; x++)
+ {
+ *(offset++) = red;
+ *(offset++) = green;
+ *(offset++) = blue;
+
+ if (has_alpha)
+ {
+ *(offset++) = alpha;
+ }
+
+ }
+
+ row_offset += rowstride;
+ }
+}
+
+gboolean
+eel_gdk_pixbuf_save_to_file (const GdkPixbuf *pixbuf,
+ const char *file_name)
+{
+ return gdk_pixbuf_save ((GdkPixbuf *) pixbuf,
+ file_name, "png", NULL, NULL);
+}
+
+void
+eel_gdk_pixbuf_ref_if_not_null (GdkPixbuf *pixbuf_or_null)
+{
+ if (pixbuf_or_null != NULL)
+ {
+ g_object_ref (pixbuf_or_null);
+ }
+}
+
+void
+eel_gdk_pixbuf_unref_if_not_null (GdkPixbuf *pixbuf_or_null)
+{
+ if (pixbuf_or_null != NULL)
+ {
+ g_object_unref (pixbuf_or_null);
+ }
+}
+
+void
+eel_gdk_pixbuf_draw_to_drawable (const GdkPixbuf *pixbuf,
+ GdkDrawable *drawable,
+ GdkGC *gc,
+ int source_x,
+ int source_y,
+ EelIRect destination_area,
+ GdkRgbDither dither,
+ GdkPixbufAlphaMode alpha_compositing_mode,
+ int alpha_threshold)
+{
+ EelDimensions dimensions;
+ EelIRect target;
+ EelIRect source;
+ int target_width;
+ int target_height;
+ int source_width;
+ int source_height;
+
+ g_return_if_fail (eel_gdk_pixbuf_is_valid (pixbuf));
+ g_return_if_fail (drawable != NULL);
+ g_return_if_fail (gc != NULL);
+ g_return_if_fail (!eel_irect_is_empty (&destination_area));
+ g_return_if_fail (alpha_threshold > EEL_OPACITY_FULLY_TRANSPARENT);
+ g_return_if_fail (alpha_threshold <= EEL_OPACITY_FULLY_OPAQUE);
+ g_return_if_fail (alpha_compositing_mode >= GDK_PIXBUF_ALPHA_BILEVEL);
+ g_return_if_fail (alpha_compositing_mode <= GDK_PIXBUF_ALPHA_FULL);
+
+ dimensions = eel_gdk_pixbuf_get_dimensions (pixbuf);
+
+ g_return_if_fail (source_x >= 0);
+ g_return_if_fail (source_y >= 0);
+ g_return_if_fail (source_x < dimensions.width);
+ g_return_if_fail (source_y < dimensions.height);
+
+ /* Clip the destination area to the pixbuf dimensions; bail if no work */
+ target = eel_gdk_pixbuf_intersect (pixbuf,
+ destination_area.x0,
+ destination_area.y0,
+ destination_area);
+ if (eel_irect_is_empty (&target))
+ {
+ return;
+ }
+
+ /* Assign the source area */
+ source = eel_irect_assign (source_x,
+ source_y,
+ dimensions.width - source_x,
+ dimensions.height - source_y);
+
+ /* Adjust the target width if the source area is smaller than the
+ * source pixbuf dimensions */
+ target_width = target.x1 - target.x0;
+ target_height = target.y1 - target.y0;
+ source_width = source.x1 - source.x0;
+ source_height = source.y1 - source.y0;
+
+ target.x1 = target.x0 + MIN (target_width, source_width);
+ target.y1 = target.y0 + MIN (target_height, source_height);
+
+ gdk_draw_pixbuf (drawable, gc, (GdkPixbuf *) pixbuf,
+ source.x0,
+ source.y0,
+ target.x0,
+ target.y0,
+ target.x1 - target.x0,
+ target.y1 - target.y0,
+ dither,
+ 0,
+ 0);
+}
+
+/**
+ * eel_gdk_pixbuf_draw_to_pixbuf:
+ * @pixbuf: The source pixbuf to draw.
+ * @destination_pixbuf: The destination pixbuf.
+ * @source_x: The source pixbuf x coordiate to composite from.
+ * @source_y: The source pixbuf y coordiate to composite from.
+ * @destination_area: The destination area within the destination pixbuf.
+ * This area will be clipped if invalid in any way.
+ *
+ * Copy one pixbuf onto another another.. This function has some advantages
+ * over plain gdk_pixbuf_copy_area():
+ *
+ * Composition paramters (source coordinate, destination area) are
+ * given in a way that is consistent with the rest of the extensions
+ * in this file. That is, it matches the declaration of
+ * eel_gdk_pixbuf_draw_to_pixbuf_alpha() and
+ * eel_gdk_pixbuf_draw_to_drawable() very closely.
+ *
+ * All values are clipped to make sure they are valid.
+ *
+ */
+void
+eel_gdk_pixbuf_draw_to_pixbuf (const GdkPixbuf *pixbuf,
+ GdkPixbuf *destination_pixbuf,
+ int source_x,
+ int source_y,
+ EelIRect destination_area)
+{
+ EelDimensions dimensions;
+ EelIRect target;
+ EelIRect source;
+ int target_width;
+ int target_height;
+ int source_width;
+ int source_height;
+
+ g_return_if_fail (eel_gdk_pixbuf_is_valid (pixbuf));
+ g_return_if_fail (eel_gdk_pixbuf_is_valid (destination_pixbuf));
+ g_return_if_fail (!eel_irect_is_empty (&destination_area));
+
+ dimensions = eel_gdk_pixbuf_get_dimensions (pixbuf);
+
+ g_return_if_fail (source_x >= 0);
+ g_return_if_fail (source_y >= 0);
+ g_return_if_fail (source_x < dimensions.width);
+ g_return_if_fail (source_y < dimensions.height);
+
+ /* Clip the destination area to the pixbuf dimensions; bail if no work */
+ target = eel_gdk_pixbuf_intersect (destination_pixbuf, 0, 0, destination_area);
+ if (eel_irect_is_empty (&target))
+ {
+ return;
+ }
+
+ /* Assign the source area */
+ source = eel_irect_assign (source_x,
+ source_y,
+ dimensions.width - source_x,
+ dimensions.height - source_y);
+
+ /* Adjust the target width if the source area is smaller than the
+ * source pixbuf dimensions */
+ target_width = target.x1 - target.x0;
+ target_height = target.y1 - target.y0;
+ source_width = source.x1 - source.x0;
+ source_height = source.y1 - source.y0;
+
+ target.x1 = target.x0 + MIN (target_width, source_width);
+ target.y1 = target.y0 + MIN (target_height, source_height);
+
+ gdk_pixbuf_copy_area (pixbuf,
+ source.x0,
+ source.y0,
+ target.x1 - target.x0,
+ target.y1 - target.y0,
+ destination_pixbuf,
+ target.x0,
+ target.y0);
+}
+
+/**
+ * eel_gdk_pixbuf_draw_to_pixbuf_alpha:
+ * @pixbuf: The source pixbuf to draw.
+ * @destination_pixbuf: The destination pixbuf.
+ * @source_x: The source pixbuf x coordiate to composite from.
+ * @source_y: The source pixbuf y coordiate to composite from.
+ * @destination_area: The destination area within the destination pixbuf.
+ * This area will be clipped if invalid in any way.
+ * @opacity: The opacity of the drawn tiles where 0 <= opacity <= 255.
+ * @interpolation_mode: The interpolation mode. See <gdk-pixbuf.h>
+ *
+ * Composite one pixbuf over another. This function has some advantages
+ * over plain gdk_pixbuf_composite():
+ *
+ * Composition paramters (source coordinate, destination area) are
+ * given in a way that is consistent with the rest of the extensions
+ * in this file. That is, it matches the declaration of
+ * eel_gdk_pixbuf_draw_to_pixbuf() and
+ * eel_gdk_pixbuf_draw_to_drawable() very closely.
+ *
+ * All values are clipped to make sure they are valid.
+ *
+ * Workaround a limitation in gdk_pixbuf_composite() that does not allow
+ * the source (x,y) to be greater than (0,0)
+ *
+ */
+void
+eel_gdk_pixbuf_draw_to_pixbuf_alpha (const GdkPixbuf *pixbuf,
+ GdkPixbuf *destination_pixbuf,
+ int source_x,
+ int source_y,
+ EelIRect destination_area,
+ int opacity,
+ GdkInterpType interpolation_mode)
+{
+ EelDimensions dimensions;
+ EelIRect target;
+ EelIRect source;
+ int target_width;
+ int target_height;
+ int source_width;
+ int source_height;
+
+ g_return_if_fail (eel_gdk_pixbuf_is_valid (pixbuf));
+ g_return_if_fail (eel_gdk_pixbuf_is_valid (destination_pixbuf));
+ g_return_if_fail (!eel_irect_is_empty (&destination_area));
+ g_return_if_fail (opacity >= EEL_OPACITY_FULLY_TRANSPARENT);
+ g_return_if_fail (opacity <= EEL_OPACITY_FULLY_OPAQUE);
+ g_return_if_fail (interpolation_mode >= GDK_INTERP_NEAREST);
+ g_return_if_fail (interpolation_mode <= GDK_INTERP_HYPER);
+
+ dimensions = eel_gdk_pixbuf_get_dimensions (pixbuf);
+
+ g_return_if_fail (source_x >= 0);
+ g_return_if_fail (source_y >= 0);
+ g_return_if_fail (source_x < dimensions.width);
+ g_return_if_fail (source_y < dimensions.height);
+
+ /* Clip the destination area to the pixbuf dimensions; bail if no work */
+ target = eel_gdk_pixbuf_intersect (destination_pixbuf, 0, 0, destination_area);
+ if (eel_irect_is_empty (&target))
+ {
+ return;
+ }
+
+ /* Assign the source area */
+ source = eel_irect_assign (source_x,
+ source_y,
+ dimensions.width - source_x,
+ dimensions.height - source_y);
+
+ /* Adjust the target width if the source area is smaller than the
+ * source pixbuf dimensions */
+ target_width = target.x1 - target.x0;
+ target_height = target.y1 - target.y0;
+ source_width = source.x1 - source.x0;
+ source_height = source.y1 - source.y0;
+
+ target.x1 = target.x0 + MIN (target_width, source_width);
+ target.y1 = target.y0 + MIN (target_height, source_height);
+
+ /* If the source point is not (0,0), then we need to create a sub pixbuf
+ * with only the source area. This is needed to work around a limitation
+ * in gdk_pixbuf_composite() that requires the source area to be (0,0). */
+ if (source.x0 != 0 || source.y0 != 0)
+ {
+ EelIRect area;
+ int width;
+ int height;
+
+ width = dimensions.width - source.x0;
+ height = dimensions.height - source.y0;
+
+ area.x0 = source.x0;
+ area.y0 = source.y0;
+ area.x1 = area.x0 + width;
+ area.y1 = area.y0 + height;
+
+ pixbuf = eel_gdk_pixbuf_new_from_pixbuf_sub_area ((GdkPixbuf *) pixbuf, area);
+ }
+ else
+ {
+ g_object_ref (G_OBJECT (pixbuf));
+ }
+
+ gdk_pixbuf_composite (pixbuf,
+ destination_pixbuf,
+ target.x0,
+ target.y0,
+ target.x1 - target.x0,
+ target.y1 - target.y0,
+ target.x0,
+ target.y0,
+ 1.0,
+ 1.0,
+ interpolation_mode,
+ opacity);
+
+ g_object_unref (G_OBJECT (pixbuf));
+}
+
+static void
+pixbuf_destroy_callback (guchar *pixels,
+ gpointer callback_data)
+{
+ g_assert (pixels != NULL);
+ g_assert (callback_data != NULL);
+
+ g_object_unref (callback_data);
+}
+
+/**
+ * eel_gdk_pixbuf_new_from_pixbuf_sub_area:
+ * @pixbuf: The source pixbuf.
+ * @area: The area within the source pixbuf to use for the sub pixbuf.
+ * This area needs to be contained within the bounds of the
+ * source pixbuf, otherwise it will be clipped to that.
+ *
+ * Return value: A newly allocated pixbuf that shares the pixel data
+ * of the source pixbuf in order to represent a sub area.
+ *
+ * Create a pixbuf from a sub area of another pixbuf. The resulting pixbuf
+ * will share the pixel data of the source pixbuf. Memory bookeeping is
+ * all taken care for the caller. All you need to do is g_object_unref()
+ * the resulting pixbuf to properly free resources.
+ */
+GdkPixbuf *
+eel_gdk_pixbuf_new_from_pixbuf_sub_area (GdkPixbuf *pixbuf,
+ EelIRect area)
+{
+ GdkPixbuf *sub_pixbuf;
+ EelIRect target;
+ guchar *pixels;
+
+ g_return_val_if_fail (eel_gdk_pixbuf_is_valid (pixbuf), NULL);
+ g_return_val_if_fail (!eel_irect_is_empty (&area), NULL);
+
+ /* Clip the pixbuf by the given area; bail if no work */
+ target = eel_gdk_pixbuf_intersect (pixbuf, 0, 0, area);
+ if (eel_irect_is_empty (&target))
+ {
+ return NULL;
+ }
+
+ /* Since we are going to be sharing the given pixbuf's data, we need
+ * to ref it. It will be unreffed in the destroy function above */
+ g_object_ref (pixbuf);
+
+ /* Compute the offset into the pixel data */
+ pixels =
+ gdk_pixbuf_get_pixels (pixbuf)
+ + (target.y0 * gdk_pixbuf_get_rowstride (pixbuf))
+ + (target.x0 * (gdk_pixbuf_get_has_alpha (pixbuf) ? 4 : 3));
+
+ /* Make a pixbuf pretending its real estate is the sub area */
+ sub_pixbuf = gdk_pixbuf_new_from_data (pixels,
+ GDK_COLORSPACE_RGB,
+ gdk_pixbuf_get_has_alpha (pixbuf),
+ 8,
+ eel_irect_get_width (target),
+ eel_irect_get_height (target),
+ gdk_pixbuf_get_rowstride (pixbuf),
+ pixbuf_destroy_callback,
+ pixbuf);
+
+ return sub_pixbuf;
+}
+
+/**
+ * eel_gdk_pixbuf_new_from_existing_buffer:
+ * @buffer: The existing buffer.
+ * @buffer_rowstride: The existing buffer's rowstride.
+ * @buffer_has_alpha: A boolean value indicating whether the buffer has alpha.
+ * @area: The area within the existing buffer to use for the pixbuf.
+ * This area needs to be contained within the bounds of the
+ * buffer, otherwise memory will be trashed.
+ *
+ * Return value: A newly allocated pixbuf that uses the existing buffer
+ * for its pixel data.
+ *
+ * Create a pixbuf from an existing buffer.
+ *
+ * The resulting pixbuf is only valid for as long as &buffer is valid. It is
+ * up to the caller to make sure they both exist in the same scope.
+ * Also, it is up to the caller to make sure that the given area is fully
+ * contained in the buffer, otherwise memory trashing will happen.
+ */
+GdkPixbuf *
+eel_gdk_pixbuf_new_from_existing_buffer (guchar *buffer,
+ int buffer_rowstride,
+ gboolean buffer_has_alpha,
+ EelIRect area)
+{
+ GdkPixbuf *pixbuf;
+ guchar *pixels;
+
+ g_return_val_if_fail (buffer != NULL, NULL);
+ g_return_val_if_fail (buffer_rowstride > 0, NULL);
+ g_return_val_if_fail (!eel_irect_is_empty (&area), NULL);
+
+ /* Compute the offset into the buffer */
+ pixels =
+ buffer
+ + (area.y0 * buffer_rowstride)
+ + (area.x0 * (buffer_has_alpha ? 4 : 3));
+
+ pixbuf = gdk_pixbuf_new_from_data (pixels,
+ GDK_COLORSPACE_RGB,
+ buffer_has_alpha,
+ 8,
+ eel_irect_get_width (area),
+ eel_irect_get_height (area),
+ buffer_rowstride,
+ NULL,
+ NULL);
+
+ return pixbuf;
+}
+
+/**
+ * eel_gdk_pixbuf_intersect:
+ * @pixbuf: A GdkPixbuf.
+ * @pixbuf_x: X coordinate of pixbuf.
+ * @pixbuf_y: Y coordinate of pixbuf.
+ * @rectangle: An EelIRect.
+ *
+ * Return value: The intersection of the pixbuf and the given rectangle.
+ *
+ */
+EelIRect
+eel_gdk_pixbuf_intersect (const GdkPixbuf *pixbuf,
+ int pixbuf_x,
+ int pixbuf_y,
+ EelIRect rectangle)
+{
+ EelIRect intersection;
+ EelIRect bounds;
+ EelDimensions dimensions;
+
+ g_return_val_if_fail (eel_gdk_pixbuf_is_valid (pixbuf), eel_irect_empty);
+
+ dimensions = eel_gdk_pixbuf_get_dimensions (pixbuf);
+ bounds = eel_irect_assign_dimensions (pixbuf_x, pixbuf_y, dimensions);
+
+ eel_irect_intersect (&intersection, &rectangle, &bounds);
+
+ /* In theory, this is not needed because a rectangle is empty
+ * regardless of how MUCH negative the dimensions are.
+ * However, to make debugging and self checks simpler, we
+ * consistenly return a standard empty rectangle.
+ */
+ if (eel_irect_is_empty (&intersection))
+ {
+ return eel_irect_empty;
+ }
+
+ return intersection;
+}
+
+GdkPixbuf *
+eel_gdk_pixbuf_scale_down (GdkPixbuf *pixbuf,
+ int dest_width,
+ int dest_height)
+{
+ int source_width, source_height;
+ int s_x1, s_y1, s_x2, s_y2;
+ int s_xfrac, s_yfrac;
+ int dx, dx_frac, dy, dy_frac;
+ div_t ddx, ddy;
+ int x, y;
+ int r, g, b, a;
+ int n_pixels;
+ gboolean has_alpha;
+ guchar *dest, *src, *xsrc, *src_pixels;
+ GdkPixbuf *dest_pixbuf;
+ int pixel_stride;
+ int source_rowstride, dest_rowstride;
+
+ if (dest_width == 0 || dest_height == 0)
+ {
+ return NULL;
+ }
+
+ source_width = gdk_pixbuf_get_width (pixbuf);
+ source_height = gdk_pixbuf_get_height (pixbuf);
+
+ g_assert (source_width >= dest_width);
+ g_assert (source_height >= dest_height);
+
+ ddx = div (source_width, dest_width);
+ dx = ddx.quot;
+ dx_frac = ddx.rem;
+
+ ddy = div (source_height, dest_height);
+ dy = ddy.quot;
+ dy_frac = ddy.rem;
+
+ has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
+ source_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+ src_pixels = gdk_pixbuf_get_pixels (pixbuf);
+
+ dest_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, has_alpha, 8,
+ dest_width, dest_height);
+ dest = gdk_pixbuf_get_pixels (dest_pixbuf);
+ dest_rowstride = gdk_pixbuf_get_rowstride (dest_pixbuf);
+
+ pixel_stride = (has_alpha)?4:3;
+
+ s_y1 = 0;
+ s_yfrac = -dest_height/2;
+ while (s_y1 < source_height)
+ {
+ s_y2 = s_y1 + dy;
+ s_yfrac += dy_frac;
+ if (s_yfrac > 0)
+ {
+ s_y2++;
+ s_yfrac -= dest_height;
+ }
+
+ s_x1 = 0;
+ s_xfrac = -dest_width/2;
+ while (s_x1 < source_width)
+ {
+ s_x2 = s_x1 + dx;
+ s_xfrac += dx_frac;
+ if (s_xfrac > 0)
+ {
+ s_x2++;
+ s_xfrac -= dest_width;
+ }
+
+ /* Average block of [x1,x2[ x [y1,y2[ and store in dest */
+ r = g = b = a = 0;
+ n_pixels = 0;
+
+ src = src_pixels + s_y1 * source_rowstride + s_x1 * pixel_stride;
+ for (y = s_y1; y < s_y2; y++)
+ {
+ xsrc = src;
+ if (has_alpha)
+ {
+ for (x = 0; x < s_x2-s_x1; x++)
+ {
+ n_pixels++;
+
+ r += xsrc[3] * xsrc[0];
+ g += xsrc[3] * xsrc[1];
+ b += xsrc[3] * xsrc[2];
+ a += xsrc[3];
+ xsrc += 4;
+ }
+ }
+ else
+ {
+ for (x = 0; x < s_x2-s_x1; x++)
+ {
+ n_pixels++;
+ r += *xsrc++;
+ g += *xsrc++;
+ b += *xsrc++;
+ }
+ }
+ src += source_rowstride;
+ }
+
+ if (has_alpha)
+ {
+ if (a != 0)
+ {
+ *dest++ = r / a;
+ *dest++ = g / a;
+ *dest++ = b / a;
+ *dest++ = a / n_pixels;
+ }
+ else
+ {
+ *dest++ = 0;
+ *dest++ = 0;
+ *dest++ = 0;
+ *dest++ = 0;
+ }
+ }
+ else
+ {
+ *dest++ = r / n_pixels;
+ *dest++ = g / n_pixels;
+ *dest++ = b / n_pixels;
+ }
+
+ s_x1 = s_x2;
+ }
+ s_y1 = s_y2;
+ dest += dest_rowstride - dest_width * pixel_stride;
+ }
+
+ return dest_pixbuf;
+}
+
+static guchar
+eel_gdk_pixbuf_lighten_pixbuf_component (guchar cur_value,
+ guint lighten_value)
+{
+ int new_value = cur_value;
+ if (lighten_value > 0)
+ {
+ new_value += lighten_value + (new_value >> 3);
+ if (new_value > 255)
+ {
+ new_value = 255;
+ }
+ }
+ return (guchar) new_value;
+}
+
+static GdkPixbuf *
+eel_gdk_pixbuf_lighten (GdkPixbuf* src,
+ guint lighten_value)
+{
+ GdkPixbuf *dest;
+ int i, j;
+ int width, height, has_alpha, src_row_stride, dst_row_stride;
+ guchar *target_pixels, *original_pixels;
+ guchar *pixsrc, *pixdest;
+
+ g_assert (gdk_pixbuf_get_colorspace (src) == GDK_COLORSPACE_RGB);
+ g_assert ((!gdk_pixbuf_get_has_alpha (src)
+ && gdk_pixbuf_get_n_channels (src) == 3)
+ || (gdk_pixbuf_get_has_alpha (src)
+ && gdk_pixbuf_get_n_channels (src) == 4));
+ g_assert (gdk_pixbuf_get_bits_per_sample (src) == 8);
+
+ dest = gdk_pixbuf_new (gdk_pixbuf_get_colorspace (src),
+ gdk_pixbuf_get_has_alpha (src),
+ gdk_pixbuf_get_bits_per_sample (src),
+ gdk_pixbuf_get_width (src),
+ gdk_pixbuf_get_height (src));
+
+ has_alpha = gdk_pixbuf_get_has_alpha (src);
+ width = gdk_pixbuf_get_width (src);
+ height = gdk_pixbuf_get_height (src);
+ dst_row_stride = gdk_pixbuf_get_rowstride (dest);
+ src_row_stride = gdk_pixbuf_get_rowstride (src);
+ target_pixels = gdk_pixbuf_get_pixels (dest);
+ original_pixels = gdk_pixbuf_get_pixels (src);
+
+ for (i = 0; i < height; i++)
+ {
+ pixdest = target_pixels + i * dst_row_stride;
+ pixsrc = original_pixels + i * src_row_stride;
+ for (j = 0; j < width; j++)
+ {
+ *pixdest++ = eel_gdk_pixbuf_lighten_pixbuf_component (*pixsrc++, lighten_value);
+ *pixdest++ = eel_gdk_pixbuf_lighten_pixbuf_component (*pixsrc++, lighten_value);
+ *pixdest++ = eel_gdk_pixbuf_lighten_pixbuf_component (*pixsrc++, lighten_value);
+ if (has_alpha)
+ {
+ *pixdest++ = *pixsrc++;
+ }
+ }
+ }
+ return dest;
+}
+
+GdkPixbuf *
+eel_gdk_pixbuf_render (GdkPixbuf *pixbuf,
+ guint render_mode,
+ guint saturation,
+ guint brightness,
+ guint lighten_value,
+ guint color)
+{
+ GdkPixbuf *temp_pixbuf, *old_pixbuf;
+
+ if (render_mode == 1)
+ {
+ /* lighten icon */
+ temp_pixbuf = eel_create_spotlight_pixbuf (pixbuf);
+ }
+ else if (render_mode == 2)
+ {
+ /* colorize icon */
+ temp_pixbuf = eel_create_colorized_pixbuf (pixbuf,
+ EEL_RGBA_COLOR_GET_R (color),
+ EEL_RGBA_COLOR_GET_G (color),
+ EEL_RGBA_COLOR_GET_B (color));
+ }
+ else if (render_mode == 3)
+ {
+ /* monochromely colorize icon */
+ old_pixbuf = eel_create_darkened_pixbuf (pixbuf, 0, 255);
+ temp_pixbuf = eel_create_colorized_pixbuf (old_pixbuf,
+ EEL_RGBA_COLOR_GET_R (color),
+ EEL_RGBA_COLOR_GET_G (color),
+ EEL_RGBA_COLOR_GET_B (color));
+ g_object_unref (old_pixbuf);
+ }
+ else
+ {
+ temp_pixbuf = NULL;
+ }
+
+ if (saturation < 255 || brightness < 255 || temp_pixbuf == NULL) // temp_pixbuf == NULL just for safer code (return copy)
+ {
+ old_pixbuf = temp_pixbuf;
+ temp_pixbuf = eel_create_darkened_pixbuf (temp_pixbuf ? temp_pixbuf : pixbuf, saturation, brightness);
+ if (old_pixbuf)
+ {
+ g_object_unref (old_pixbuf);
+ }
+ }
+
+ if (lighten_value > 0)
+ {
+ old_pixbuf = temp_pixbuf;
+ temp_pixbuf = eel_gdk_pixbuf_lighten (temp_pixbuf ? temp_pixbuf : pixbuf, lighten_value);
+ if (old_pixbuf)
+ {
+ g_object_unref (old_pixbuf);
+ }
+ }
+
+ return temp_pixbuf;
+}
+
+
+#if !defined (EEL_OMIT_SELF_CHECK)
+
+static char *
+check_average_value (int width, int height, const char* fill)
+{
+ char c;
+ guint r, g, b, a;
+ gboolean alpha, gray;
+ int gray_tweak;
+ GdkPixbuf *pixbuf;
+ int x, y, rowstride, n_channels;
+ guchar *pixels;
+ guint32 average;
+ guchar v;
+
+ r = g = b = a = 0;
+ alpha = FALSE;
+ gray = FALSE;
+ gray_tweak = 0;
+ if (sscanf (fill, " %x,%x,%x,%x %c", &r, &g, &b, &a, &c) == 4)
+ {
+ alpha = TRUE;
+ }
+ else if (sscanf (fill, " %x,%x,%x %c", &r, &g, &b, &c) == 3)
+ {
+ }
+ else if (sscanf (fill, " gray%d %c", &gray_tweak, &c) == 1)
+ {
+ gray = TRUE;
+ }
+ else
+ {
+ return g_strdup ("bad fill string format");
+ }
+
+ pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, alpha, 8, width, height);
+
+ pixels = gdk_pixbuf_get_pixels (pixbuf);
+ rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+ n_channels = gdk_pixbuf_get_n_channels (pixbuf);
+
+ if (!gray)
+ {
+ for (y = 0; y < height; y++)
+ {
+ for (x = 0; x < width; x++)
+ {
+ pixels [y * rowstride + x * n_channels + 0] = r;
+ pixels [y * rowstride + x * n_channels + 1] = g;
+ pixels [y * rowstride + x * n_channels + 2] = b;
+ if (alpha)
+ {
+ pixels [y * rowstride + x * n_channels + 3] = a;
+ }
+ }
+ }
+ }
+ else
+ {
+ for (y = 0; y < height; y++)
+ {
+ for (x = 0; x < width; x++)
+ {
+ v = ((x + y) & 1) ? 0x80 : 0x7F;
+ if (((x + y) & 0xFF) == 0)
+ v += gray_tweak;
+ pixels [y * rowstride + x * n_channels + 0] = v;
+ pixels [y * rowstride + x * n_channels + 1] = v;
+ pixels [y * rowstride + x * n_channels + 2] = v;
+ }
+ }
+ pixels [0] += gray_tweak;
+ pixels [1] += gray_tweak;
+ pixels [2] += gray_tweak;
+ }
+
+ average = eel_gdk_pixbuf_average_value (pixbuf);
+ g_object_unref (pixbuf);
+
+ return g_strdup_printf ("%02X,%02X,%02X,%02X",
+ (average >> 16) & 0xFF,
+ (average >> 8) & 0xFF,
+ average & 0xFF,
+ average >> 24);
+}
+
+void
+eel_self_check_gdk_pixbuf_extensions (void)
+{
+ GdkPixbuf *pixbuf;
+ EelIRect clip_area;
+
+ pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, 100, 100);
+
+ EEL_CHECK_BOOLEAN_RESULT (eel_gdk_pixbuf_is_valid (pixbuf), TRUE);
+ EEL_CHECK_BOOLEAN_RESULT (eel_gdk_pixbuf_is_valid (NULL), FALSE);
+
+ EEL_CHECK_DIMENSIONS_RESULT (eel_gdk_pixbuf_get_dimensions (pixbuf), 100, 100);
+
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, eel_gdk_pixbuf_whole_pixbuf), 0, 0, 100, 100);
+
+ clip_area = eel_irect_assign (0, 0, 0, 0);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 0, 0);
+
+ clip_area = eel_irect_assign (0, 0, 0, 0);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 0, 0);
+
+ clip_area = eel_irect_assign (0, 0, 100, 100);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 100, 100);
+
+ clip_area = eel_irect_assign (-10, -10, 100, 100);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 90, 90);
+
+ clip_area = eel_irect_assign (-10, -10, 110, 110);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 100, 100);
+
+ clip_area = eel_irect_assign (0, 0, 99, 99);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 99, 99);
+
+ clip_area = eel_irect_assign (0, 0, 1, 1);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 1, 1);
+
+ clip_area = eel_irect_assign (-1, -1, 1, 1);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 0, 0);
+
+ clip_area = eel_irect_assign (-1, -1, 2, 2);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 1, 1);
+
+ clip_area = eel_irect_assign (100, 100, 1, 1);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 0, 0);
+
+ clip_area = eel_irect_assign (101, 101, 1, 1);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 0, 0, 0, 0);
+
+ clip_area = eel_irect_assign (80, 0, 100, 100);
+ EEL_CHECK_RECTANGLE_RESULT (eel_gdk_pixbuf_intersect (pixbuf, 0, 0, clip_area), 80, 0, 100, 100);
+
+ g_object_unref (pixbuf);
+
+ /* No checks for empty pixbufs because GdkPixbuf doesn't seem to allow them. */
+ EEL_CHECK_STRING_RESULT (check_average_value (1, 1, "00,00,00"), "00,00,00,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1, 1, "00,00,00,00"), "00,00,00,00");
+ EEL_CHECK_STRING_RESULT (check_average_value (1, 1, "00,00,00,FF"), "00,00,00,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1, 1, "01,01,01"), "01,01,01,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1, 1, "FE,FE,FE"), "FE,FE,FE,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1, 1, "FF,FF,FF"), "FF,FF,FF,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1, 1, "FF,FF,FF,00"), "00,00,00,00");
+ EEL_CHECK_STRING_RESULT (check_average_value (1, 1, "11,22,33"), "11,22,33,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "00,00,00"), "00,00,00,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "00,00,00,00"), "00,00,00,00");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "00,00,00,FF"), "00,00,00,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "01,01,01"), "01,01,01,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "FE,FE,FE"), "FE,FE,FE,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "FF,FF,FF"), "FF,FF,FF,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "FF,FF,FF,00"), "00,00,00,00");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "11,22,33"), "11,22,33,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "gray -1"), "7F,7F,7F,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "gray 0"), "80,80,80,FF");
+ EEL_CHECK_STRING_RESULT (check_average_value (1000, 1000, "gray 1"), "80,80,80,FF");
+}
+
+#endif /* !EEL_OMIT_SELF_CHECK */
+
author	Perberos <[email protected]>	2011-12-01 22:24:23 -0300
committer	Perberos <[email protected]>	2011-12-01 22:24:23 -0300
commit	0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree	43261e815529cb9518ed7be37af13b846af8b26b /eel/eel-gdk-pixbuf-extensions.c
download	caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2 caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz